generics en documentation

In je BandServiceImpl gebruik je List<Band>. Waarom schrijf je die <Band> erbij? Vroeger in Java (voor versie 5) deden we dat niet. Wat is het grote voordeel?

• TYPE SAFETY

• compile-time check: met <Band> controleert compiler tijdens het typen of je er per ongeluk een String of Student ofzo in stopt. Als je dat doet, krijg je meteen een warning.

• zonder generics: zou je er alles in kunne stoppen en merk je de fout pas als de app draati en crasht met een runtime error

• geen casts nodig: zonder generics moest je vroeger typen Band b = (Band) lijst.get(0); Met generics weet java al dat het een Band is Band b = lijst.get(0)

Zelf een Generieke Klasse maken (Live Coding)

De docent kan vragen: "Stel dat we een algemene 'Container' willen maken die eender welk object kan vasthouden (een Band, een String, een Integer). Schrijf die klasse."

Je moet dan weten hoe je de T (van Type) gebruikt.

// De <T> vertelt Java: "Deze klasse werkt met een Type dat we later pas kiezen"

public class Container<T> {

private T inhoud;

public void setInhoud(T inhoud) {

this.inhoud = inhoud;

}

public T getInhoud() {

return inhoud;

}

}

Op het examen gebruik je dit dan zo: Container<Band> bandDoos = new Container<>();

Vraag 3: Type Erasure (De strikvraag voor hoge punten)

Vraag: "Bestaat die <Band> info nog als het programma draait (at runtime)?"

nee, dit heet type erasure, de compiler gebruikt de <Band> info om te checken op fouten. zodra de code gecompileerd is naar .class files wist java al die <Band> haakjes weg en vervangt ze door Object. daarom kun je runtime niet checken if(lisjt instanceof List<Band>. je kunt alleen checken if (lijst instanceof List)

Vraag 4: Syntax Herkennen

Vraag: "Wat is het verschil tussen //, /* */ en /** */?"

• // = Commentaar voor één regel (voor de programmeur).

• /* ... */ = Commentaar voor meerdere regels (voor de programmeur).

• /** ... */ = Javadoc. Dit is officiële documentatie. Hiermee kan je een HTML-website genereren die andere ontwikkelaars kunnen lezen om te snappen hoe jouw klasse werkt (zonder de code te moeten lezen).

"Schrijf de correcte Javadoc boven je getAverageAwesomeness methode in de Service laag."

Je moet hier de juiste Tags gebruiken (@param, @return, etc.).

/**

* Berekent de gemiddelde awesomeness score van alle bands in de database.

* * @return Een double die het gemiddelde voorstelt. Geeft 0.0 terug als de lijst leeg is.

* @throws BandException Als er een probleem is met de database connectie.

*/

public double getAverageAwesomeness() {

// ... code ...

}

tags uitleg javadoc

• @param: Beschrijft een input parameter (naam + wat het is). Hier niet nodig want de methode heeft geen parameters.

• @return: Beschrijft wat er uitkomt.

• @throws: Zeer belangrijk! Vertel de gebruiker welke fouten er kunnen optreden.

• @author: (Vaak boven de klasse gezet) Jouw naam.

Op het examen vragen ze vaak: "Waarom geeft List<Object> lijst = new ArrayList<String>(); een compile error?" Het antwoord heeft alles te maken met Wildcards.

1. Het Probleem (Waarom hebben we ze nodig?)

Stel je hebt een subklasse MetalBand die overerft van Band.

• Logica zegt: Een MetalBand is een Band. (Polymorfisme werkt: Band b = new MetalBand()).

• Generics zeggen: Een List<MetalBand> is GEEN List<Band>.

Waarom niet? Als Java dit zou toelaten, zou je dit kunnen doen:

List<MetalBand> metalBands = new ArrayList<>();

List<Band> bands = metalBands; // STEL dat dit mocht...

// Omdat 'bands' een lijst van Band is, mag ik er een JazzBand in steken:

bands.add(new JazzBand());

// ... Maar wacht! De variabele 'metalBands' wijst naar diezelfde lijst!

// Als ik nu metalBands.get(0) doe, krijg ik een JazzBand terug terwijl ik Metal verwacht.

// CRASH (ClassCastException).

A. De Unbounded Wildcard (List<?>)

Dit betekent: "Een lijst van iets, maar ik weet niet wat."

• Gebruik: Als het type je eigenlijk niet uitmaakt (bv. je wil alleen de lijstgrootte weten of de lijst leegmaken).

• Beperking: Je kunt niets toevoegen aan deze lijst (behalve null), want Java weet niet welk type erin mag.

• Voorbeeld:

• // Deze methode werkt voor List<String>, List<Band>, List<Integer>...

  public void printSize(List<?> lijst) {

  System.out.println(lijst.size());

  // lijst.add(new Band()); // ERROR! Mag niet.

  }

• B. De Upper Bounded Wildcard (List<? extends Band>)

  Dit is de meest voorkomende op het examen. Dit betekent: "Een lijst van objecten die Band zijn, of een subklasse van Band."

  • Lezen (Get): Veilig. Je weet zeker dat alles wat eruit komt minstens een Band is.

  • Schrijven (Add): VERBODEN! Je kunt niets toevoegen. Waarom? Omdat de lijst in werkelijkheid een List<MetalBand> kan zijn, en dan mag je er geen JazzBand bij proppen.

  • Examenvraag: "Schrijf een methode die de totale awesomeness berekent van een lijst, ongeacht of het MetalBands of JazzBands zijn."

  • // Accepteert List<Band>, List<MetalBand>, List<JazzBand>

    public double totalAwesomeness(List<? extends Band> bands) {

    double total = 0;

    for (Band b : bands) { // We weten zeker dat het een Band is

    total += b.getAwesomeness();

    }

    return total;

    }

  • C. De Lower Bounded Wildcard (List<? super MetalBand>)

    Dit betekent: "Een lijst van objecten die MetalBand zijn, of een superklasse ervan (bv. Band of Object)."

    • Lezen (Get): Lastig. Je krijgt enkel Object terug, want je weet niet hoe hoog in de boom de lijst zit.

    • Schrijven (Add): Veilig! Je mag hier een MetalBand aan toevoegen. Want of de lijst nu List<MetalBand>, List<Band> of List<Object> is, een MetalBand past er altijd in

    • 3. De Gouden Regel voor het Examen: PECS

      Als je twijfelt welk pijltje je moet gebruiken, onthoud de afkorting PECS. Veel docenten vragen hier letterlijk naar.

      PECS staat voor: Producer Extends, Consumer Super.

      1. Producer Extends (? extends T):

         • Gebruik dit als de lijst data aan jou geeft (jij haalt er data uit om mee te rekenen/lezen). De lijst produceert data.

         • Voorbeeld: Je totalAwesomeness methode leest alleen maar data. -> extends.

      2. Consumer Super (? super T):

         • Gebruik dit als jij data in de lijst stopt. De lijst consumeert jouw data.

         • Voorbeeld: Je wil nieuwe MetalBands toevoegen aan een bestaande lijst (die misschien een lijst van Bands is). -> super.