Merkloos product

"Hallo Amigo!"

"Hallo, Ellie!"

"Vandaag gaan Rishi en ik je alles vertellen over generieke geneesmiddelen."

"Wacht, ik denk dat ik bijna alles al weet."

"Bijna alles, maar niet alles."

"Echt waar? Oké, ik ben klaar om te luisteren."

"Laten we dan beginnen."

"In Java zijn generieke klassen klassen met typeparameters."

"Zie voor de reden waarom generieke geneesmiddelen zijn uitgevonden de opmerkingen in de code:"

ArrayList stringList = new ArrayList();
stringList.add("abc"); // Add a string to the list
stringList.add("abc"); // Add a string to the list
stringList.add( 1 ); // Add a number to the list

for(Object o: stringList)
{
 String s = (String) o; // There will be an exception here when we get to the integer
}

Hoe het probleem op te lossen met Generics:

ArrayList<String> stringList = new ArrayList<String>();
stringList.add("abc"); // Add a string to the list
stringList.add("abc"); // Add a string to the list
stringList.add( 1 ); // There will be a compilation error here

for(Object o: stringList)
{
 String s = (String) o;
}

"Deze code kan gewoon niet worden gecompileerd en de fout die wordt veroorzaakt door het toevoegen van het verkeerde gegevenstype, wordt tijdens het compileren opgemerkt."

"Ja, dit weet ik al."

"Oké, goed. Herhaling is de moeder van leren."

"Maar de makers van Java waren een beetje lui toen ze generieken maakten. In plaats van volwaardige typen met parameters te maken, gleed ze in een gelikte optimalisatie. In werkelijkheid voegden ze geen informatie over typeparameters toe aan generieke magie vindt plaats tijdens de compilatie."

List<String> strings = new ArrayList<String>();
strings.add("abc");
strings.add("abc");
strings.add( 1); // Compilation error

for(String s: strings)
{
 System.out.println(s);
}

List strings = new ArrayList();

strings.add((String)"abc");
strings.add((String)"abc");
strings.add((String) 1); // Compilation error

for(String s: strings)
{
 System.out.println(s);
}

"Dat is glad."

"Ja, maar deze benadering heeft een neveneffect.  Er wordt geen informatie over typeparameters opgeslagen in een generieke klasse.  Deze benadering werd later bekend als typeverwijdering ."

"Met andere woorden, als je je eigen klasse hebt met typeparameters, kun je geen informatie daarover binnen de klasse gebruiken."

class Zoo<T>
{
 ArrayList<T> pets = new ArrayList<T>();

 public T createAnimal()
 {
  T animal = new T();
  pets.add(animal)
  return animal;
 }
}

class Zoo
{
 ArrayList pets = new ArrayList();

 public Object createAnimal()
 {
  Object animal = new ???();
  pets.add(animal)
  return animal;
 }
}

"Tijdens de compilatie worden alle parametertypen vervangen door Object. En binnen de klasse is er geen informatie over het type dat eraan wordt doorgegeven."

"Ja, daar ben ik het mee eens, dat is niet het beste."

'Het is niet zo eng. Ik zal je later vertellen hoe je dit probleem kunt omzeilen.'

Maar er is meer. Met Java kunt u een bovenliggend type specificeren voor typeparameters. Hiervoor wordt het sleutelwoord extends gebruikt. Bijvoorbeeld:

class Zoo<T extends Cat>
{
 T cat;

 T getCat()
 {
  return cat;
 }

 void setCat (T cat)
 {
  this.cat = cat;
 }

 String getCatName()
 {
  return this.cat.getName();
 }
}

class Zoo
{
 Cat cat;

 Cat getCat()
 {
  return cat;
 }

 void setCat(Cat cat)
 {
  this.cat = cat;
 }

 String getCatName()
 {
  return this.cat.getName();
 }
}

"Let op twee feiten:"

"Ten eerste kun je niet zomaar elk type als parameter doorgeven - je kunt alleen een Cat of een klasse doorgeven die Cat erft."

"Ten tweede kunnen variabelen van het type T binnen de Zoo-klasse nu de methoden van de Cat-klasse aanroepen.  De kolom aan de rechterkant legt uit waarom (omdat Cat overal wordt vervangen waar een T is)"

"Ja. Als we zeggen dat Cat of een subklasse van Cat wordt doorgegeven als typeargument, dan weten we zeker dat type T altijd de methoden van de Cat-klasse zal hebben."

"Nou, dat is slim."