Generika

„Hallo, Amigo!“

„Hallo, Ellie!“

„Heute werden Rishi und ich Ihnen alles über Generika erzählen.“

„Warte, ich glaube, ich weiß schon fast alles.“

„Fast alles, aber nicht alles.“

„Wirklich? Okay, ich bin bereit zuzuhören.“

„Dann fangen wir an.“

„In Java sind Generika Klassen, die Typparameter haben.“

„Warum Generika erfunden wurden, erfahren Sie in den Kommentaren im 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
}

So lösen Sie das Problem mit 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;
}

„Dieser Code lässt sich einfach nicht kompilieren und der Fehler, der durch das Hinzufügen des falschen Datentyps verursacht wird, wird während der Kompilierung bemerkt.“

„Ja, das weiß ich schon.“

„Okay, gut. Wiederholung ist die Mutter des Lernens.“

„Aber die Java-Entwickler waren ein wenig faul, als sie Generics erstellten. Anstatt vollwertige Typen mit Parametern zu erstellen, haben sie eine raffinierte Optimierung eingebaut. In Wirklichkeit haben sie den Generics keine Informationen über Typparameter hinzugefügt. Stattdessen haben sie alle Beim Kompilieren entsteht Magie.“

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);
}

„Das ist schick.“

„Ja, aber dieser Ansatz hat einen Nebeneffekt.  In einer generischen Klasse werden keine Informationen über Typparameter gespeichert.  Dieser Ansatz wurde später als Typlöschung bekannt .“

„Mit anderen Worten: Wenn Sie eine eigene Klasse mit Typparametern haben, können Sie keine Informationen darüber innerhalb der Klasse verwenden.“

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;
 }
}

„Während der Kompilierung werden alle Parametertypen durch Object ersetzt. Und innerhalb der Klasse gibt es keine Informationen über den an sie übergebenen Typ.“

„Ja, da stimme ich zu, das ist nicht das Beste.“

„Es ist nicht so beängstigend. Ich werde dir später sagen, wie du dieses Problem umgehen kannst.“

Aber es gibt noch mehr. In Java können Sie einen übergeordneten Typ für Typparameter angeben. Hierzu wird das Schlüsselwort „extends“ verwendet. Zum Beispiel:

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();
 }
}

„Beachten Sie zwei Tatsachen:“

„Erstens können Sie nicht irgendeinen Typ als Parameter übergeben – Sie können nur eine Cat oder eine Klasse übergeben, die Cat erbt.“

„Zweitens können Variablen vom Typ T innerhalb der Zoo-Klasse jetzt die Methoden der Cat-Klasse aufrufen.  Die Spalte rechts erklärt warum (da Cat überall dort ersetzt wird, wo ein T steht)“

„Ja. Wenn wir sagen, dass Cat oder eine Unterklasse von Cat als Typargument übergeben wird, dann sind wir sicher, dass Typ T immer über die Methoden der Cat-Klasse verfügt.“

„Nun, das ist klug.“