Was ist cool an Generika, warum sie verwenden?

Ich dachte, ich würde diesen Softball jedem anbieten, der ihn aus dem Park schlagen möchte. Was sind Generika, was sind die Vorteile von Generika, warum, wo, wie soll ich sie verwenden? Bitte halten Sie es ziemlich einfach. Vielen Dank.

• Ermöglicht das Schreiben von Code / die Verwendung typsicherer Bibliotheksmethoden, dh eine Liste <Zeichenfolge> ist garantiert eine Liste von Zeichenfolgen.
• Aufgrund der Verwendung von Generika kann der Compiler Code zur Kompilierungszeit aus Gründen der Typensicherheit überprüfen. Versuchen Sie also, ein int in diese Liste von Zeichenfolgen einzufügen? Die Verwendung einer ArrayList würde dazu führen, dass dies ein weniger transparenter Laufzeitfehler ist.
• Schneller als die Verwendung von Objekten, da entweder das Boxen / Entpacken (bei dem .net Werttypen in Referenztypen konvertieren muss oder umgekehrt ) oder das Umwandeln von Objekten in den erforderlichen Referenztyp vermieden wird.
• Ermöglicht das Schreiben von Code, der auf viele Typen mit demselben zugrunde liegenden Verhalten anwendbar ist, dh ein Dictionary <string, int> verwendet denselben zugrunde liegenden Code wie ein Dictionary <DateTime, double>; Mit Generika musste das Framework-Team nur einen Code schreiben, um beide Ergebnisse mit den oben genannten Vorteilen zu erzielen.

Ich hasse es wirklich, mich zu wiederholen. Ich hasse es, öfter dasselbe zu tippen, als ich muss. Ich mag es nicht, Dinge mehrmals mit kleinen Unterschieden zu wiederholen.

Anstatt zu erstellen:

class MyObjectList  {
   MyObject get(int index) {...}
}
class MyOtherObjectList  {
   MyOtherObject get(int index) {...}
}
class AnotherObjectList  {
   AnotherObject get(int index) {...}
}

Ich kann eine wiederverwendbare Klasse erstellen ... (für den Fall, dass Sie die Raw-Sammlung aus irgendeinem Grund nicht verwenden möchten)

class MyList<T> {
   T get(int index) { ... }
}

Ich bin jetzt 3x effizienter und muss nur noch eine Kopie pflegen. Warum möchten Sie nicht weniger Code pflegen?

Dies gilt auch für Nicht-Sammlungsklassen wie a Callable<T>oder a Reference<T>, die mit anderen Klassen interagieren müssen. Wollen Sie wirklich erweitern Callable<T>und Future<T>und alle anderen zugehörigen Klasse typsichere Versionen zu erstellen?

Ich nicht.

Die Notwendigkeit einer Typumwandlung ist einer der größten Vorteile von Java-Generika , da sie zur Kompilierungszeit eine Typprüfung durchführen. Dies verringert die Möglichkeit von ClassCastExceptions, die zur Laufzeit ausgelöst werden können, und kann zu robusterem Code führen.

Aber ich vermute, dass Sie sich dessen voll bewusst sind.

Jedes Mal, wenn ich Generika anschaue, bekomme ich Kopfschmerzen. Ich finde, das Beste an Java ist seine Einfachheit und minimale Syntax, und Generika sind nicht einfach und fügen eine erhebliche Menge neuer Syntax hinzu.

Anfangs habe ich auch den Nutzen von Generika nicht gesehen. Ich fing an, Java aus der 1.4-Syntax zu lernen (obwohl Java 5 zu diesem Zeitpunkt nicht verfügbar war), und als ich auf Generika stieß, hatte ich das Gefühl, dass es mehr Code zum Schreiben war, und ich verstand die Vorteile wirklich nicht.

Moderne IDEs erleichtern das Schreiben von Code mit Generika.

Die meisten modernen, anständigen IDEs sind intelligent genug, um das Schreiben von Code mit Generika zu unterstützen, insbesondere bei der Code-Vervollständigung.

Hier ist ein Beispiel für das Erstellen eines Map<String, Integer>mit a HashMap. Der Code, den ich eingeben müsste, lautet:

Map<String, Integer> m = new HashMap<String, Integer>();

Und in der Tat ist das eine Menge zu tippen, nur um eine neue zu machen HashMap. In Wirklichkeit musste ich jedoch nur so viel tippen, bevor Eclipse wusste, was ich brauchte:

Map<String, Integer> m = new Ha Ctrl+Space

Zwar musste ich HashMapaus einer Liste von Kandidaten auswählen , aber im Grunde wusste die IDE, was sie hinzufügen sollte, einschließlich der generischen Typen. Mit den richtigen Tools ist die Verwendung von Generika nicht schlecht.

Da die Typen bekannt sind, verhält sich die IDE beim Abrufen von Elementen aus der generischen Auflistung so, als ob dieses Objekt bereits ein Objekt des deklarierten Typs ist. Es ist kein Casting erforderlich, damit die IDE den Typ des Objekts kennt ist.

Ein wesentlicher Vorteil von Generika besteht darin, dass sie mit neuen Java 5-Funktionen gut funktionieren. Hier ist ein Beispiel für das Werfen von ganzen Zahlen in a Setund das Berechnen der Summe:

Set<Integer> set = new HashSet<Integer>();
set.add(10);
set.add(42);

int total = 0;
for (int i : set) {
  total += i;
}

In diesem Code sind drei neue Java 5-Funktionen enthalten:

• Generika
• Autoboxing und Unboxing
• Für jede Schleife

Erstens erlauben Generika und Autoboxing von Grundelementen die folgenden Zeilen:

set.add(10);
set.add(42);

Die Ganzzahl 10wird automatisch in eine Integermit dem Wert von geschrieben 10. (Und das gleiche für 42). Dann Integerwird das in das geworfen, von dem Setbekannt ist, dass es Integers hält. Der Versuch, ein zu werfen, Stringwürde einen Kompilierungsfehler verursachen.

Als nächstes werden für jede Schleife alle drei verwendet:

for (int i : set) {
  total += i;
}

Zunächst werden die Setenthaltenden Integers in einer for-each-Schleife verwendet. Jedes Element wird als ein deklariert intund dies ist zulässig, da das IntegerElement nicht in das Grundelement zurückgeführt wird int. Und die Tatsache, dass dieses Unboxing auftritt, ist bekannt, da Generika verwendet wurden, um anzugeben, dass Integers in der gehalten wurden Set.

Generika können der Klebstoff sein, der die in Java 5 eingeführten neuen Funktionen zusammenbringt, und sie machen das Codieren einfach und sicherer. Und die meiste Zeit sind IDEs klug genug, um Ihnen mit guten Vorschlägen zu helfen. Im Allgemeinen wird es also nicht viel mehr tippen.

Und ehrlich gesagt, wie aus dem SetBeispiel hervorgeht, kann die Verwendung von Java 5-Funktionen den Code präziser und robuster machen.

Bearbeiten - Ein Beispiel ohne Generika

Das Folgende ist eine Illustration des obigen SetBeispiels ohne die Verwendung von Generika. Es ist möglich, aber nicht gerade angenehm:

Set set = new HashSet();
set.add(10);
set.add(42);

int total = 0;
for (Object o : set) {
  total += (Integer)o;
}

(Hinweis: Der obige Code generiert beim Kompilieren eine ungeprüfte Konvertierungswarnung.)

Wenn Sie nicht generische Sammlungen verwenden, sind die Typen, die in die Sammlung eingegeben werden, Objekte vom Typ Object. Daher wird in diesem Beispiel eine Objectist , was wird addin die Menge ed.

set.add(10);
set.add(42);

In den obigen Zeilen ist Autoboxing im Spiel - der primitive intWert 10und 42wird in IntegerObjekte autoboxed , die dem hinzugefügt werden Set. Beachten Sie jedoch, dass die IntegerObjekte als Objects behandelt werden, da es keine Typinformationen gibt, die dem Compiler helfen, zu wissen, welchen Typ der Seterwarten sollte.

for (Object o : set) {

Dies ist der entscheidende Teil. Der Grund, warum die for-each-Schleife funktioniert, liegt darin, dass Setsie die IterableSchnittstelle implementiert , die Iterator, falls vorhanden , eine mit Typinformationen zurückgibt . ( Iterator<T>das heißt.)

Da es jedoch keine Typinformationen, die Setkehren ein , Iteratordie die Werte in der Rückkehr wird Setals Objects, und deshalb ist das Element in der for-Schleife jeden abgerufen werden muß vom Typ sein Object.

Nachdem das aus dem Objectabgerufen wurde Set, muss es Integermanuell in ein umgewandelt werden, um das Hinzufügen durchzuführen:

  total += (Integer)o;

Hier wird eine Typumwandlung von a Objectnach a durchgeführt Integer. In diesem Fall wissen wir, dass dies immer funktionieren wird, aber bei der manuellen Typisierung habe ich immer das Gefühl, dass es sich um fragilen Code handelt, der beschädigt werden könnte, wenn an anderer Stelle eine geringfügige Änderung vorgenommen wird. (Ich habe das Gefühl, dass jede Typografie darauf ClassCastExceptionwartet, passiert zu werden, aber ich schweife ab ...)

Das Integerist jetzt in eine entpackt intund darf die Addition in die intVariable durchführen total.

Ich hoffe, ich konnte veranschaulichen, dass die neuen Funktionen von Java 5 mit nicht generischem Code verwendet werden können, aber es ist nicht so sauber und unkompliziert wie das Schreiben von Code mit generischem Code. Um die neuen Funktionen in Java 5 optimal nutzen zu können, sollte man sich meiner Meinung nach mit Generika befassen, wenn zumindest Überprüfungen zur Kompilierungszeit möglich sind, um zu verhindern, dass ungültige Typecasts zur Laufzeit Ausnahmen auslösen.

Wenn Sie die Java-Fehlerdatenbank kurz vor der Veröffentlichung von 1.5 durchsuchen würden, würden Sie siebenmal mehr Fehler mit NullPointerExceptionals finden ClassCastException. Es scheint also keine großartige Funktion zu sein, Fehler zu finden, oder zumindest Fehler, die nach einem kleinen Rauchtest bestehen bleiben.

Für mich ist der große Vorteil von Generika, dass sie wichtige Typinformationen im Code dokumentieren . Wenn ich nicht wollte, dass diese Typinformationen im Code dokumentiert werden, würde ich eine dynamisch typisierte Sprache oder zumindest eine Sprache mit impliziterer Typinferenz verwenden.

Die Sammlungen eines Objekts für sich zu behalten, ist kein schlechter Stil (aber der übliche Stil besteht darin, die Kapselung effektiv zu ignorieren). Es kommt eher darauf an, was Sie tun. Das Übergeben von Sammlungen an "Algorithmen" ist mit Generika etwas einfacher (zur oder vor der Kompilierungszeit) zu überprüfen.

Generika in Java erleichtern den parametrischen Polymorphismus . Mithilfe von Typparametern können Sie Argumente an Typen übergeben. So wie eine Methode wie ein String foo(String s)bestimmtes Verhalten modelliert, nicht nur für eine bestimmte Zeichenfolge, sondern für eine beliebige Zeichenfolge s, so List<T>modelliert ein Typ wie ein bestimmtes Verhalten, nicht nur für einen bestimmten Typ, sondern für einen beliebigen Typ . List<T>sagt, dass es für jeden Typ Teinen Typ gibt, Listdessen Elemente Ts sind . Ist Listalso eigentlich ein Typkonstruktor . Es nimmt einen Typ als Argument und erstellt als Ergebnis einen anderen Typ.

Hier sind einige Beispiele für generische Typen, die ich jeden Tag verwende. Erstens eine sehr nützliche generische Schnittstelle:

public interface F<A, B> {
  public B f(A a);
}

Diese Schnittstelle besagt, dass es für zwei Typen Aund Beine Funktion (aufgerufen f) gibt, die a nimmt Aund a zurückgibt B. Wenn Sie diese Schnittstelle implementieren, Aund Bkann jede Art sein , das Sie wollen, solange Sie eine Funktion zur Verfügung stellen f, die die ehemalige nimmt und die letztere. Hier ist eine Beispielimplementierung der Schnittstelle:

F<Integer, String> intToString = new F<Integer, String>() {
  public String f(int i) {
    return String.valueOf(i);
  }
}

Vor Generika wurde Polymorphismus durch Unterklassen mit dem extendsSchlüsselwort erreicht. Mit Generika können wir die Unterklasse tatsächlich beseitigen und stattdessen parametrischen Polymorphismus verwenden. Betrachten Sie beispielsweise eine parametrisierte (generische) Klasse, die zum Berechnen von Hash-Codes für einen beliebigen Typ verwendet wird. Anstatt Object.hashCode () zu überschreiben, würden wir eine generische Klasse wie diese verwenden:

public final class Hash<A> {
  private final F<A, Integer> hashFunction;

  public Hash(final F<A, Integer> f) {
    this.hashFunction = f;
  }

  public int hash(A a) {
    return hashFunction.f(a);
  }
}

Dies ist viel flexibler als die Verwendung von Vererbung, da wir beim Thema der Verwendung von Komposition und parametrischem Polymorphismus bleiben können, ohne spröde Hierarchien zu blockieren.

Javas Generika sind jedoch nicht perfekt. Sie können über Typen abstrahieren, aber Sie können beispielsweise nicht über Typkonstruktoren abstrahieren. Das heißt, Sie können "für jeden Typ T" sagen, aber Sie können nicht "für jeden Typ T sagen, der einen Typparameter A annimmt".

Ich habe hier einen Artikel über diese Grenzen von Java-Generika geschrieben.

Ein großer Gewinn bei Generika ist, dass Sie damit Unterklassen vermeiden können. Unterklassen führen in der Regel zu spröden Klassenhierarchien, deren Erweiterung schwierig ist, und zu Klassen, die einzeln schwer zu verstehen sind, ohne die gesamte Hierarchie zu betrachten.

Wereas vor Generika könnten Sie Klassen wie Widgetdurch erweitert FooWidget, BarWidgetund BazWidgetmit Generika können Sie eine einzelne generische Klasse , Widget<A>die eine nimmt Foo, Baroder Bazin seinem Konstruktor Sie zu geben Widget<Foo>, Widget<Bar>und Widget<Baz>.

Generika vermeiden den Leistungseinbruch beim Boxen und Unboxen. Schauen Sie sich grundsätzlich ArrayList vs List <T> an. Beide erledigen die gleichen Kernaufgaben, aber List <T> ist viel schneller, da Sie nicht zum / vom Objekt boxen müssen.

Der beste Vorteil von Generics ist die Wiederverwendung von Code. Nehmen wir an, Sie haben viele Geschäftsobjekte und schreiben SEHR ähnlichen Code für jede Entität, um dieselben Aktionen auszuführen. (IE Linq to SQL-Operationen).

Mit Generics können Sie eine Klasse erstellen, die mit einem der Typen arbeiten kann, die von einer bestimmten Basisklasse erben, oder eine bestimmte Schnittstelle wie folgt implementieren:

public interface IEntity
{

}

public class Employee : IEntity
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public int EmployeeID { get; set; }
}

public class Company : IEntity
{
    public string Name { get; set; }
    public string TaxID { get; set }
}

public class DataService<ENTITY, DATACONTEXT>
    where ENTITY : class, IEntity, new()
    where DATACONTEXT : DataContext, new()
{

    public void Create(List<ENTITY> entities)
    {
        using (DATACONTEXT db = new DATACONTEXT())
        {
            Table<ENTITY> table = db.GetTable<ENTITY>();

            foreach (ENTITY entity in entities)
                table.InsertOnSubmit (entity);

            db.SubmitChanges();
        }
    }
}

public class MyTest
{
    public void DoSomething()
    {
        var dataService = new DataService<Employee, MyDataContext>();
        dataService.Create(new Employee { FirstName = "Bob", LastName = "Smith", EmployeeID = 5 });
        var otherDataService = new DataService<Company, MyDataContext>();
            otherDataService.Create(new Company { Name = "ACME", TaxID = "123-111-2233" });

    }
}

Beachten Sie die Wiederverwendung desselben Dienstes angesichts der verschiedenen Typen in der obigen DoSomething-Methode. Wirklich elegant!

Es gibt viele andere gute Gründe, Generika für Ihre Arbeit zu verwenden. Dies ist mein Favorit.

Ich mag sie nur, weil sie Ihnen eine schnelle Möglichkeit bieten, einen benutzerdefinierten Typ zu definieren (da ich sie sowieso verwende).

Anstatt beispielsweise eine Struktur zu definieren, die aus einer Zeichenfolge und einer Ganzzahl besteht, und dann eine ganze Reihe von Objekten und Methoden für den Zugriff auf ein Array dieser Strukturen usw. implementieren zu müssen, können Sie einfach ein Wörterbuch erstellen

Dictionary<int, string> dictionary = new Dictionary<int, string>();

Und der Compiler / die IDE erledigt den Rest des schweren Hebens. Insbesondere in einem Wörterbuch können Sie den ersten Typ als Schlüssel verwenden (keine wiederholten Werte).

• Typisierte Sammlungen - auch wenn Sie sie nicht verwenden möchten, müssen Sie sie wahrscheinlich aus anderen Bibliotheken und Quellen verarbeiten.

• Generische Eingabe bei der Klassenerstellung:

  öffentliche Klasse Foo <T> {public T get () ...

• Vermeidung von Casting - Ich habe Dinge wie immer nicht gemocht

  neuer Komparator {public int compareTo (Objekt o) {if (o Instanz von classIcareAbout) ...

Wo Sie im Wesentlichen nach einer Bedingung suchen, die nur vorhanden sein sollte, weil die Schnittstelle in Objekten ausgedrückt wird.

Meine anfängliche Reaktion auf Generika war ähnlich wie Ihre - "zu chaotisch, zu kompliziert". Ich habe die Erfahrung gemacht, dass man sich nach einer kurzen Verwendung an sie gewöhnt und sich Code ohne sie weniger klar spezifiziert und einfach weniger komfortabel anfühlt. Abgesehen davon verwendet der Rest der Java-Welt sie, so dass Sie irgendwann mit dem Programm fertig werden müssen, oder?

Generika bieten Ihnen auch die Möglichkeit, wiederverwendbarere Objekte / Methoden zu erstellen und gleichzeitig typspezifische Unterstützung zu bieten. In einigen Fällen erhalten Sie auch viel Leistung. Ich kenne nicht die vollständige Spezifikation für die Java-Generika, aber in .NET kann ich Einschränkungen für den Type-Parameter angeben, z. B. Implementiert eine Schnittstelle, einen Konstruktor und eine Ableitung.