Forelæsning Uge 6 – Mandag Tingene i denne forelæsning er ikke eksamenspensum Forelæsningen afrunder kurset, og forklarer nogle af de begreber, som I har mødt under kurset uden at få detaljeret forklaring på Mange af tingene tages op i kurset Programmering 2 Nedarvning, abstrakte klasser og interfaces Sortering via forprogrammerede metoder i Java Library Comparable interfacet og compareTo metoden (naturlig ordning) Comparator interfacet og compare metoden (flere ordninger) findBest algoritmeskabelonen som sorteringsproblem

● Nedarvning, abstrakte klasser og interfaces Vi vil gerne modellere et simpelt nyhedssystem, med to slags meddelelser Almindelige tekstmeddelelse (MessagePost) Fotomeddelelse (PhotoPost) Uden brug af subklasser ser det sådan ud Feltvariabler Metoder Stort overlap, men ikke identiske

Duplikering af kode MessagePost og PhotoPost ligner hinanden Store dele af de to klassers Java kode er identisk Det gør koden svær at overskue og vanskelig at vedligeholde Der opstår let fejl og inkonsistens, f.eks. når man ændrer noget i den ene klasse, men glemmer at rette i den anden Også duplikering i NewsFeed klassen Den har to arraylister Mange metoder gennemløber begge lister (duplikeret kode)

Forskellige feltvariabler og metoder Brug af subklasser Vi kan i stedet lave en Post klasse, som har MessagePost og PhotoPost som subklasser Fælles feltvariabler og metoder Forskellige feltvariabler og metoder Nu har vi kun én arrayliste postings PhotoPost MessagePost Post Nemmere at overskue Ingen kodeduplikering

Object klassen Alle klasser i Java er subklasser af Object klassen Object klassen indeholder en række nyttige metoder toString metoden returnerer en tekstrepræsentation af det pågældende objekt (Person@19bb25a) equals metoden tjekker om to objekter er ens (tjekker identitet, ==) Mange klasser redefinerer metoder fra Object klassen (f.eks. String)

Act metoden i Greenfoot I Greenfoot skal alle subklasser af Actor klassen have en act metode Dette kan sikres ved, at Actor klassen definerer act til at være en abstrakt metode, dvs. kun angiver signaturen og udelader kroppen Dette tvinger alle subklasser til at implementere metoden – ellers vil compileren protestere I Greenfoot har man dog valgt en lidt anden løsning Act metoden er defineret som en almindelig metode Den har en tom krop og gør derfor ingen ting For at et objekt kan bevæge sig, skal den pågældende subklasse redefinere act metoden – sådan som I gjorde for krabben og hummeren Denne løsning er valgt, fordi den gør det lettere for nybegyndere at komme i gang og giver mere forståelige fejlmeddelelser Hvis man ikke redefinerer act bruges versionen fra Actor klassen

Abstrakte klasser En klasse kan defineres til at være abstrakt Det medfører, at den kan indeholde abstrakte metoder, dvs. metoder der ikke er implementeret – men den behøver ikke gøre det Man kan ikke lave instanser (dvs. objekter) af en abstrakt klasse Men man kan definere subklasser (som kan være abstrakte eller konkrete) Compileren tjekker at en konkret subklasse implementerer alle de abstrakte metoder fra den abstrakte superklasse En abstrakt klasse kan indeholde en blanding af abstrakte og konkrete metoder Klassen kan derfor indeholde en delvis implementation, mens resten overlades til subklasserne

Interfaces I et interface er alle metoder abstrakte Interfacet specificerer, hvilke metoder der skal være, og angiver deres signaturer Implementationen af metoderne overlades til de klasser, der implementerer interfacet Interface ≈ abstrakt klasse, hvor alle metoder er abstrakte Hvorfor har Java både abstrakte klasser og interfaces? En klasse kan kun være (direkte) subklasse af én anden klasse, men den kan godt implementere flere interfaces En abstrakt klasse kan indeholde en delvis implementation (og feltvariabler) ‒ det kan et interface ikke Hvor meget er implementeret? Almindelig (konkret) klasse: alt er implementeret (100%) Interface: ingen implementation (0%) Abstrakt klasse: delvis implementation (0-100%)

Hvad opnår vi? Fælles for abstrakte klasser og interfaces De bestemmer en type Man kan lave metoder, som kan bruges på alle subklasser af en abstrakt klasse alle de klasser, der implementerer et interface Sådanne metoder kaldes polymorfe (mangeartede) F.eks. kan reverse og shuffle metoderne i Collections klassen bruges på alle objektsamlinger, der implementerer Collection interfacet, mens min, max og sort metoderne desuden kræver, at element typen i objektsamlingen implementerer Comparable interfacet Nedarvning fra abstrakt eller konkret superklasse Vi arver både noget implementation og en type Klassen bliver en subtype af superklassen, og dens objekter kan bruges alle de steder superklassens objekter kan bruges Implementation af interface Vi arver kun typen

Collection frameworket (udsnit) implements extends <<interface>> Collection <<abstract class>> AbstractCollection <<interface>> Set <<interface>> List <<interface>> Queue HashSet <<interface>> SortedSet <<abstract class>> AbstractList LinkedList PriorityQueue LinkedHashSet <<interface>> NavigableSet ArrayList Vector Subklasser af klassen AbstractList og dermed forskellige implementationer af interfacet List Hver implementation har sine fordele og ulemper Nemt at skifte imellem dem (de har de samme metoder) TreeSet Collection frameworket 12 interfaces 35 klasser (heraf 5 abstrakte)

● Sortering via forprogrammerede metoder Lidt repetition fra i mandags Klassen Collections indeholder en række nyttige metoder Metoderne kan bruges på forskellige typer objektsamlinger Typen skal implementere Collection interfacet Det er f.eks. tilfældet for ArrayList T min(Collection<T> c) //returnerer mindste element T max(Collection<T> c) //returnerer største element void sort(List<T> l) //sorterer listen void shuffle(List<T> l) //blander listen void reverse(List<T> l) //vender listen om boolean disjoint(Collection<T> c1, Collection<T> c2) int frequency(Collection<T> c, Object o) ...

Ordning Metoderne min, max og sort kan kun anvendes, hvis elementerne i ArrayListen har en ordning String klassen har en indbygget ordning (alfabetisk sortering) Derfor kan vi uden videre bruge min, max og sort på ArrayList<String> Når vi selv laver en klasse (f.eks Person, Date eller Pixel), skal vi selv definere en ordning – hvis vi vil kunne bruge min, max og sort Til det formål bruges Comparable interfacet public interface Comparable<T> { public int compareTo(T o); } public class Person implements Comparable<Person> { ... public int compareTo(Person p) { } Naturlige ordning negativ  this < p nul  this = p positiv  p < this

Hvad gør vi, når vi har brug for flere ordninger? For personer kan vi for eksempel ønske at sortere efter alder, sortere efter fornavn, sortere efter efternavn, kombinere nogle af ovenstående sorteringskriterier Comparable tillader kun én ordning Specificeret via compareTo metoden Comparator tillader flere ordninger min, max og sort har en ekstra parameter, der specificerer, hvilken ordning man vil bruge Parameteren skal være et objekt i en klasse, der implementerer interfacet Comparator Dette indeholder en compare metode, der sammenligner to elementer af den type, der ønskes sorteret

Brug af Comparator på ArrayList<Person> public class Driver { public static void run() { ArrayList<Person> list; list = new ArrayList<Person>(); list.add(new Person("Cecilie", 18)); list.add(new Person("Erik", 16)); list.add(new Person("Adam", 16)); list.add(new Person("Bo", 39)); list.add(new Person("Dora", 47)); print("*******************"); print("liste: " + list); print("min: " + Collections.min(list, new ByName())); print("max: " + Collections.max(list) new ByName())); Collections.sort(list, new ByName()); print("sorteret liste: " + list); } ... Klasse, der implementerer Comparator<Person>

Metode fra String klassen (sorterer alfabetisk) Sortering efter navn negativ  p1 < p2 nul  p1 = p2 positiv  p2 < p1 import java.util.Comparator; public class ByName implements Comparator<Person> { public int compare(Person p1, Person p2){ return p1.getName() . compareTo ( p2.getName() ); } Metode fra String klassen (sorterer alfabetisk) p1's navn (textstreng) p2's navn (textstreng)

Sortering efter alder (med yngste først) negativ  p1 < p2 nul  p1 = p2 positiv  p2 < p1 import java.util.Comparator; public class ByAge implements Comparator<Person> { public int compare(Person p1, Person p2){ return p1.getAge() - p2.getAge(); } p1's alder Subtraktion (af heltal) p2's alder

Sortering efter alder og navn import java.util.Comparator; public class ByAgeName implements Comparator<Person> { public int compare(Person p1, Person p2){ if (p1.getAge() != p2.getAge()) { return p1.getAge() - p2.getAge(); } //alderen er identisk return p1.getName().compareTo(p2.getName());

Klassediagram for brug af Comparable Collections T min(Collection<T> c) T max(Collection<T> c) void sort(List<T> l) void reverse(List<T> l) void shuffle(List<T> l) ... uses uses <<interface>> Comparable int compareTo(T o) <<interface>> Collection boolean add(E e) boolean contains(Object o) ... Nyttige metoder (programmeret en gang for alle) Diagrammet er ikke eksamenspensum extends implements implements <<interface>> List <<interface>> Set <<interface>> Queue … Pixel Person … String compareTo compareTo compareTo implements implements implements Vi skal lave compareTo metoderne Resten er genbrug fra Java's API ArrayList HashSet LinkedList Ca. 35 forskellige Collection klasser

Klassediagram for brug af Comparator Collections T min(Collection<T> c, Comparator<T> comp ) T max(Collection<T> c, Comparator<T> comp ) void sort(List<T> l, Comparator<T> comp ) ... Metoderne er parametriseret med et Comparator objekt uses uses <<interface>> Comparator int compare(T o1,T o2) <<interface>> Collection boolean add(E e) boolean contains(Object o) ... Nyttige metoder (programmeret en gang for alle) Diagrammet er ikke eksamenspensum extends implements implements <<interface>> List <<interface>> Set <<interface>> Queue Pixel Person … … String compare compare compare implements implements implements Vi skal lave compare metoderne Resten er genbrug fra Java's API ArrayList HashSet LinkedList Ca. 35 forskellige Collection klasser

Comparable eller Comparator public int compareTo(Person p){ return this.age - p.age; } Simpel compareTo metoden defineres i Person klassen, som implementerer interfacet Comparable Man kan kun have en ordning ad gangen (naturlige ordning) Comparable public Person findOldestPerson() { return Collections.max(persons); } public class ByAge implements Comparator<Person> { public int compare (Person p1, Person p2){ return p1.getAge() - p2.getAge(); } Mere kompleks compare metoden defineres i en ny klasse, som implementerer interfacet Comparator min, max og sort metoderne har en ekstra parameter Til gengæld er det nu muligt at have flere ordninger samtidigt Comparator public Person findOldestPerson() { return Collections.max(persons, new ByAge()); } public Person findFirstPerson() { return Collections.min(persons, new ByName()); } I dIntProg eksamensopgaverne er det tilstrækkeligt at bruge Comparable

● findBest = finder bedste element i liste public TYPE findBest( PARAM ) { TYPE result = null; for ( TYPE elem : LISTE ) { if ( TEST(elem,PARAM) ) { if ( result == null || BEST(elem,result,PARAM) ) { result = elem; } return result; Algoritmeskabelon Gennemsøger LISTE og returnerer det BEDSTE af de elementer, der opfylder TEST Hvis flere elementer er lige gode returneres et vilkårligt af disse Hvis der ingen er, returneres null

findBest er ofte et sorteringsproblem Hvis man vil finde den ældste kvinde i en liste af personer, kan det gøres på følgende måde Definer en ordning, efter alder, på objekterne i Person klassen ved hjælp af compareTo i Comparable eller compare i Comparator Brug findAll algortimeskabelonen til at finde en delliste indeholdende alle kvinder (fra den oprindelige liste) Brug max metoden i Collections til at finde den ældste kvinde i dellisten (hvis dellisten er tom returneres null) Alternativt kan man erstatte de sidste to skridt med Brug sort metoden i Collections til at sortere Person listen efter alder (med de ældste først) Brug findOne algoritmeskabelonen til at finde den første person, som er en kvinde (i den sorterede liste) Hvilken af de to fremgangsmåde er bedst og hvorfor? I den sidste laver man en sortering, hvilket kan være dyrt I den sidste antager man, at findOne returnerer det første element, der opfylder betingelsen

● Opsummering Nedarvning, abstrakte klasser og interfaces En subklasse arver alle de egenskaber (feltvariabler og metoder), som dens superklasse har (metoder fra superklassen kan redefineres) En abstrakt klasse kan indeholde abstrakte metoder, der ikke er implementeret, men kun specificeret via deres signatur I et interface er alle metoder abstrakte Sortering via forprogrammerede metoder i Java Library Comparable interfacet og compareTo metoden (naturlig ordning) Comparator interfacet og compare metoden (flere ordninger) findBest algoritmeskabelonen som sorteringsproblem

Det var alt for nu….. … spørgsmål