Föreläsningsmaterial (Arv) Skrivet av Andreas Lund Inledning Arv är ett begrepp som är tätt förknippat med objektorientering. Principerna bakom arv är grundade i högst vardagliga relationer mellan olika typer av objekt. Låt oss betrakta följande objekt : En student En lektor En informatikstudent En adjunkt En människa En universitetslärare Objekten är inte listade i någon särskild ordning, men det kommer vi till. Det viktiga just nu är att alla objekten i listan är exempel på människo-objekt. En student är en människa, precis som en adjunkt också är en människa och som en informatikstudent är en människa. Det kan tyckas uppenbart, men denna är-relation går bara i en riktning: att alla studenter är människor betyder inte att alla människor är studenter. Ett annat sätt att uttrycka denna är-relation är att säga att en student ärver de egenskaper som människor har. En student är (i objektorienteringens terminologi) en specialisering eller utökning av begreppet människa, medan begreppet människa är en generalisering av studenter, lärare eller vad människor kan tänkas vara utöver att vara just människor. Denna typ av relation kan vi uttrycka grafiskt med hjälp av UML på följande sätt.
Ur denna bild kan vi utläsa att klassen Människa är en generalisering av klassen Student och (underförstått) att klassen Student är en specialisering av klassen Människa. Lite slarvigt, men nog så korrekt kan vi säga att en student är en människa och lite till. Det är detta lite till som gör att en student inte bara är en människa utan också något mer som inte gäller för alla människor. Arv kan ofta beskrivas hierarkiskt. Ovanstående lista kan beskrivas hierarkiskt med hjälp av UML på följande sätt: Arv i Java Ett nyckelord för arv: extends class Cirkel extends Form......... Innebörd: klassen Cirkel utökar klassen Form. Cirkel blir en ny klass som ärver alla egenskaper från klassen Form, samt lägger till nya egenskaper. Ett Cirkel-objekt är en Cirkel, men det är också ett Form-objekt (på samma sätt som en student är just en student, men också en människa.) Scenario Ett företag som säljer datorkomponenter ska utveckla ett nytt system för hantering av sina artiklar. Företaget säljer en mängd olika typer av produkter: datorer, programvara, processorer, etc. Problemet som man ser är att man vill å ena sidan kunna behandla alla produkter på ett och samma sätt, å andra sidan vill man kunna ta fasta på vad som är specifikt för de olika typerna av produkter. Gemensamt för alla produkter är att de har ett namn, ett artikelnummer och ett pris. Utöver det så har varje produkttyp egenskaper som är specifika för artikeltypen. En sommararbetande informatikstudent ser att detta är ett typfall av arv. Hon föreslår att de produktegenskaper som är gemensamma för alla produkter samlas i en basklass, dvs en klass utifrån vilken man därefter kan göra specialiseringsklasser som hanterar respektive produkttyp. Nedan följer exempel på hur detta kan göras för två produkttyper: programvara och processorer. Basklassen Produkt (lagrad i Produkt.java) class Produkt private String namn; private double pris; private int artikelnummer; public Produkt(String n, double p, int anummer) namn = n; pris = p; artikelnummer = anummer;
public int getartikelnummer() return artikelnummer; public void setartikelnummer(int anummer) artikelnummer = anummer; public String getnamn() return namn; public void setnamn(string n) namn = n; public double getpris() return pris; public void setpris(double p) pris = p; Den härledda klassen Programvara (lagrad i Programvara.java) class Programvara extends Produkt private String kategori; public Programvara(String n, double p, int anummer, String k) /* Nedanstående rad innebär att den överordnade klassens konstruktor anropas */ super(n, p, anummer); kategori = k; public String getkategori() return kategori; public void setkategori(string k) kategori = k;
Den härledda klassen Processor (lagrad i Processor.java) class Processor extends Produkt private String klockfrekvens; public Processor(String n, double p, int anummer, String kfrekvens) /* Nedanstående rad innebär att den överordnade klassens konstruktor anropas */ super(n, p, anummer); klockfrekvens = kfrekvens; public String getklockfrekvens() return klockfrekvens; public void setklockfrekvens(string kfrekvens) klockfrekvens = kfrekvens; En applikationsklass som utnyttjar de nedärvda klasserna (ProduktApp.java) class ProduktApp public static void main(string args[]) Programvara pgm = new Programvara("Quake 3", 450.0, 234, "Spel"); Processor proc = new Processor("Pentium 4 Extreme Edition", 11200.0, 321, "3.4 GHz"); System.out.println("Pris för: "+pgm.getnamn()+" är " + pgm.getpris()+ " kr."); En klass för att representera samlingar av Produktobjekt (ProduktRegister.java) Målsättning: vi vill ha en klass som kan utgöra en behållare för alla Produkt-objekt, dvs en klass som inte är specifik för Programvara eller Processor. Lösning: deklarera en array bestående av referenser till Produkt-objekt. class ProduktRegister private Produkt[] produktlista; private int antalprodukter; public ProduktRegister(int maxantal) produktlista = new Produkt[maxAntal];
antalprodukter = 0; public void laggtillprodukt(produkt p) produktlista[antalprodukter] = p; antalprodukter++; public Produkt getprodukt(int index) return produktlista[index]; public int getantalprodukter() return antalprodukter; Overriding, overloading och abstrakta klasser Målsättning: vi vill förändra Produktregisterklassen så att den kan skriva ut information om de produkter som ingår i registret, även avseende de egenskaper som är specifika för Programvara och Processor. Problem: ProduktRegister-klassen känner bara till de egenskaper som är definierade för Produkt, inte de specifika egenskaperna för Programvara och Processor. Lösning 1: Lägg till en metod till Produkt-klassen som heter getinfo(). I Produktklassen är denna metod tom; den utför ingenting. Sub-klasserna Programvara och Processor ärver denna tomma metod, men gör en så kallad override på metoden. Att göra override på en metod innebär att en subklass implementerar sin egen version av den metod som den har ärvt från basklassen. Observera att metodens deklaration måste vara densamma. Konsekvens: Om Produkt.klassen har en metod som heter getinfo() så kan denna metod anropas för alla Produkt-objekt, oavsett om de är specialiseringar i form av Programvara eller Processor. Det intressanta med override på metoder är att javatolken kommer att avgöra under pågående exekvering vad för slags Produktobjekt det är fråga om (Programvara- eller Processor-objekt) och exekvera den version av getinfo()-metoden som gäller för just den klass som objektet är en instans av. Förändrad basklass class Produkt private String namn; private double pris; private int artikelnummer; public Produkt(String n, double p, int anummer) namn = n; pris = p; artikelnummer = anummer; public int getartikelnummer() return artikelnummer; public void setartikelnummer(int anummer) artikelnummer = anummer; public String getnamn() return namn;
public void setnamn(string n) namn = n; public double getpris() return pris; public void setpris(double p) pris = p; public String getinfo() return null; Förändrade subklasser class Processor extends Produkt private String klockfrekvens; public Processor(String n, double p, int anummer, String kfrekvens) /* Nedanstående rad innebär att den överordnade klassens konstruktor anropas */ super(n, p, anummer); klockfrekvens = kfrekvens; public String getklockfrekvens() return klockfrekvens; public void setklockfrekvens(string kfrekvens) klockfrekvens = kfrekvens; public String getinfo() String info; info = this.getnamn() + " är en processor med klockfrekvensen " + this.getklockfrekvens(); return info; class Programvara extends Produkt private String kategori; public Programvara(String n, double p, int anummer, String k) /* Nedanstående rad innebär att den överordnade klassens konstruktor anropas */ super(n, p, anummer); kategori = k; public String getkategori() return kategori; public void setkategori(string k) kategori = k; public String getinfo() String info;
info = this.getnamn() + " är ett program i kategorin +this.getkategori(); return info; Förändring av ProduktRegister class ProduktRegister private Produkt[] produktlista; private int antalprodukter; public ProduktRegister(int maxantal) produktlista = new Produkt[maxAntal]; antalprodukter = 0; public void laggtillprodukt(produkt p) produktlista[antalprodukter] = p; antalprodukter++; public Produkt getprodukt(int index) return produktlista[index]; public int getantalprodukter() return antalprodukter; public void skrivut() for(int i=0; i < antalprodukter; i++) String information; Produkt p = produktlista[i]; information = p.getinfo(); System.out.println(information); ProduktApp_3.java class ProduktApp_3 public static void main(string args[]) ProduktRegister preg; Programvara pgm; Processor proc; preg = new ProduktRegister(100); pgm = new Programvara("Quake 3", 450.0, 234, "Spel"); preg.laggtillprodukt(pgm); pgm = new Programvara("RedHat Linux", 200.0, 2, "Operativsystem"); preg.laggtillprodukt(pgm); proc = new Processor("Pentium 4 Extreme Edition", 11200.0, 321, "3.4 GHz"); preg.laggtillprodukt(proc); proc = new Processor("Intel Xeon", 8200.0, 543, "2.8 GHz"); preg.laggtillprodukt(proc); preg.skrivut(); Observation: I scenariot så samlas alla gemensamma egenskaper i en basklass. Men det verkar rimligt att anta att denna klass i sig inte är tillräcklig för att beskriva alla egenskaper i någon tänkbar produkt. Alla produkttyper är mer specifika än typernas minsta gemensamma nämnare
(det vill säga egenskaperna i Produkt). Annorlunda uttryckt så kommer aldrig ett objekt vara en instans av enbart Produkt. De objekt som skapas är alltid instanser av Programvara eller Processor. I sin nuvarande utformning så tillåter klassen Produkt att vi gör direkta instanser av denna klass. Detta är dock inte önskvärt eftersom ett renodlat Produkt-objekt saknar innebörd i det här sammanhanget. Med en likelse kan man säga att detta är som att vid en anställingsintervju besvara frågan om vilka egenskaper man har med att man är en människa. Det är förvisso korrekt och viktigt, men i sig inte tillräckligt specifikt för att vara användbart i den situationen. I java kan man förhindra att klasser som är så generella som Produkt instantieras. Vad man däremot kan instantiera är klasser som är härledda (som ärver) från den generella klassen i fråga. Den allmänna formen for att deklarera en klass som abstrakt är: abstract class KlassNamn......... Det är dock inte endast klasser som kan vara abstrakta. En abstrakt klass kan dessutom innehålla abstrakta metoder. En abstrakt metod är endast en metoddeklaration utan innehåll. En klass som ärver från en klass med en eller flera abstrakta metoder måste implementera basklassens abstrakta metoder, dvs ge dem ett innehåll. Nedanstående exempel visar hur Produktklassen kan förändras så att den blir abstrakt och innehåller en abstrakt metod. Den abstrakta metoden i fråga är getinfo() och genom att göra på detta sätt har vi en lösning 2 på det problem som identifierades tidigare. Under kursen har vi inte diskuterat programmeringsstil i någon omfattning, men det kan nämnas att lösningen med en abstrakt klass med en abstrakt metod är en mer elegant lösning. Observera att vi inte behöver göra några förändringar i Processor eller Programvara eftersom de sedan tidigare har implementationer av getinfo(). Produkt som en abstrakt klass abstract class Produkt private String namn; private double pris; private int artikelnummer; public Produkt(String n, double p, int anummer) namn = n; pris = p; artikelnummer = anummer; public int getartikelnummer() return artikelnummer; public void setartikelnummer(int anummer) artikelnummer = anummer; public String getnamn() return namn; public void setnamn(string n) namn = n;
public double getpris() return pris; public void setpris(double p) pris = p; abstract public String getinfo(); Overloading Ett begrepp som i strikt mening inte är specifikt relaterat till arv men som på en språklig nivå är likt overriding är overloading. Overloading innebär att en klass kan ha flera metoder med samma namn och typ men med olika parameteruppsättningar. Antag att vi vill att klassen ProduktRegister ska ha, utöver metoden skrivut(), en metod skrivut(int i) som skriver ut information om produkten som ligger lagrad på plats i i den array som lagrar produktinformationen. Denna metod skulle kunna se enligt följande: public void skrivut(int i) String information; Produkt p = produktlista[i]; information = p.getinfo(); System.out.println(information); Denna metod har samma namn som den ursprungliga skrivut(), Skillnaden är att den nya skrivut-metoden använder sig av en heltalsparameter. Detta förfarande kallas att göra en overload på metoden ifråga. Grader av synlighet: Private, Public & Protected En grundläggand tanke inom objektorientering är den om inkapsling. Ett objekts data (dess attribut) bör som princip alltid vara tillgängliga endast genom metoder. Denna princip gestaltar sig genom bruket av privata attribut och publika metoder. Att direkt göra åtkomst till ett privat attribut är möjligt endast inom den klass där attributet är definierat. Arv innebär som vi behandlat att en subklass ärver en överordnad klass alla egenskaper i form av metoder och attribut. Detta kan tolkas som att de privata attributen hos en överordnad klass är direkt tillgängliga (dvs utan att göra åtkomsten via metoder). Detta är dock inte fallet. Antag att vi lägger till nedanstående metod till klassen Programvara (Programvara_protected.java): public void skrivutpris() System.out.println("Produktens pris är: " + pris); Om vi kompilerar klassen så kommer vi få ett meddelande i form av nedanstående text:
C:\eclipse\workspace\Arv>javac Programvara_protected.java Programvara_protected.java:32: pris has private access in Produkt System.out.println("Produktens pris _r: " + pris); Att pris har private access in Produkt betyder att vi inte kan göra denna typ av direkta åtkomst till attributet. Man brukar säga att basklassens privata attribut inte är synligt från den härledda klassen. Det finns två tänkbara och otänkbart sätt att komma tillrätta med felet. Det ena är att förändra metoden så att vi gör åtkomst till attributet via en metod: public void skrivutpris() System.out.println("Produktens pris är: " + getpris()); Det andra är att vi förändrar synligheten för pris-attributet. Eftersom attributet är deklarerat i basklassen Produk så är det där vi får göra förändringen (se filen Produkt_protected.java): protected double pris; Genom att deklarera attributet som protected (snarare än private) så har vi förändrat synligheten på ett sådant sätt att attributet är synligt (och tillgängligt för direkt åtkomst utan metoder) även från klasser som ärver från basklassen. Attributet är dock fortfarande osynligt inifrån klasser som inte har Produkt som basklass. Övningsuppgifter 1 Skapa två klasser som ärver från klassen Produkt så att ytterligare två produkttyper kan representeras. Testa dina klasser genom att förändra ProduktApp_3.java så att de nya klasserna används för att skapa ny objekt som läggs till preg-objektet. 2 Det finns många olika typer av fordon: cyklar, motorcyklar, bilar, lastbilar, etc. Skapa en abstrakt basklass med namnet Fordon som samlar gemensamma egenskaper för samtliga fordonstyper. Skapa dessutom några härledda klasser som ärver Fordonsegenskaper, men som utökar med egenskaper som är specifika för en särskild fordonstyp. 3 Som en fortsättning på uppgift två kan du skapa en klass med namnet Fordonsregister som representerar egenskaper för samlingar av fordon. Klassen ska innehålla en metod med namnet skrivut som skriver ut både gemensamma attribut för samtliga fordon, men också attribut som är specifika för de härledda klasserna. 4 En gemensam egenskap för volymobjekt (t ex kub, cylinder, kon, sfär, etc) är att alla har en volym. Det finns dock många skillnader mellan olika typer av volymer, dels utmärks de av de har
olika attribut. En cylinder har t ex en radie och en höjd, medan en kub utmärks av sidlängd. Detta medför att volymen för dessa olika kroppar beräknas på olika sätt. Gör en basklass med namnet Volym. Denna klass har som enda egenskap en metod med namnet beraknavolym. Metoden accepterar inga parametrar och returnerar ett värde av typen double. Metoden är abstrakt. Gör två eller flera härledda klasser som utökar Volym med attribut som är relevanta för den typ av volym som klassen är tänkt att representera. De härledda klasserna ska implementera basklassens abstrakta metod beraknavolym. Det ingår i uppgiften att söka reda på formler för volymberäkning. Interface(Gränssnitt) Interface är en konstruktion i Java som är lik en klass. Ett interface används för att specificera en mängd behov/fordran som är ålagda en samling klasser. De klasser som implementerar ett interface är garanterade att ha vissa funktioner/uppträdanden samt att de också ärver de konstanter som är definierade i interfacet. Ett interface beskriver ett antal metoder en klass ska ha för att ha en viss egenskap. Det kan vara lagringsbar, ritningsbas, betalningsbar etc. Det interfacet gör är att det sätter en standard för hur klasser ska se ut för att vara t.ex. Payable. Ett gränssnitt innehåller ingen kod. Och man använder sig av nyckelordet interface för att visa att det är just ett gränssnitt. De metoder som man sedan deklarerar i gränssnittet anges bara med sina signaturer. Detta interface skapas på liknande sätt som man skapar en klass. Exempel; public interface Payable double calcweeklypay( ); Och skulle sparas i en fil som exempelvis hette Payable.java För att implementera ett interface till en klass så måste klassens huvud uppdateras. Det skulle kunna se ut på följande sätt: public class HourlyEmployee extends NewEmployee implements Payable public double calcweeklypay() //kod för att beräkna veckolönen Gränssnittets alla metoder MÅSTE skrivas i klassen som implementerar det.
En klass kan bara förlänga/ärva en superklass men den kan implementera multipla interfaces. För att göra det så behöver man bara separera interfacet (Payable) med en kommatering från den efterföljande implements xxx.