Co jest fajnego w produktach generycznych, po co ich używać?

Pomyślałem, że zaoferuję tę softball każdemu, kto chciałby ją uderzyć z parku. Co to są leki generyczne, jakie są zalety leków generycznych, dlaczego, gdzie, jak ich używać? Proszę, niech to będzie dość podstawowe. Dzięki.

• Umożliwia pisanie kodu / korzystanie z metod bibliotecznych, które są bezpieczne dla typów, tj. List <string> gwarantuje, że jest to lista ciągów.
• W wyniku użycia typów generycznych kompilator może przeprowadzić kontrolę kodu w czasie kompilacji pod kątem bezpieczeństwa typów, tj. Czy próbujesz umieścić int na tej liście ciągów? Użycie ArrayList spowodowałoby, że byłby to mniej przejrzysty błąd w czasie wykonywania.
• Szybsze niż używanie obiektów, ponieważ pozwala uniknąć pakowania / rozpakowywania (gdzie .net musi konwertować typy wartości na typy referencyjne lub odwrotnie ) lub rzutowania z obiektów na wymagany typ odniesienia.
• Umożliwia pisanie kodu, który ma zastosowanie do wielu typów o tym samym zachowaniu, tj. Dictionary <string, int> używa tego samego kodu źródłowego co Dictionary <DateTime, double>; używając typów generycznych, zespół frameworka musiał napisać tylko jeden fragment kodu, aby osiągnąć oba wyniki z wyżej wymienionymi zaletami.

Naprawdę nienawidzę się powtarzać. Nienawidzę pisać tego samego częściej niż muszę. Nie lubię powtarzać rzeczy wielokrotnie z niewielkimi różnicami.

Zamiast tworzyć:

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

Mogę zbudować jedną klasę wielokrotnego użytku ... (w przypadku, gdy z jakiegoś powodu nie chcesz używać kolekcji surowej)

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

Jestem teraz 3 razy wydajniejszy i muszę zachować tylko jedną kopię. Dlaczego NIE chcesz utrzymywać mniej kodu?

Dotyczy to również klas niebędących kolekcjami, takich jak a Callable<T>lub a, Reference<T>które muszą współdziałać z innymi klasami. Czy naprawdę chcesz rozszerzyć Callable<T>i Future<T>każdą inną skojarzoną klasę, aby utworzyć wersje bezpieczne dla typów?

Ja nie.

Brak konieczności rzutowania jest jedną z największych zalet generycznych języków Java , ponieważ sprawdza typ w czasie kompilacji. Zmniejszy to prawdopodobieństwo, że ClassCastExceptions, które mogą zostać wyrzucone w czasie wykonywania, i może prowadzić do bardziej niezawodnego kodu.

Ale podejrzewam, że jesteś tego w pełni świadomy.

Za każdym razem, gdy patrzę na leki generyczne, boli mnie głowa. Uważam, że najlepszą częścią Javy jest prostota i minimalna składnia, a typy generyczne nie są proste i dodają znaczną ilość nowej składni.

Na początku też nie widziałem korzyści ze stosowania leków generycznych. Zacząłem uczyć się Javy od składni 1.4 (mimo że Java 5 była wtedy niedostępna) i kiedy napotkałem generics, poczułem, że pisanie wymaga więcej kodu i naprawdę nie rozumiałem korzyści.

Nowoczesne IDE ułatwiają pisanie kodu za pomocą typów ogólnych.

Większość nowoczesnych, przyzwoitych IDE jest wystarczająco inteligentnych, aby pomagać w pisaniu kodu za pomocą typów ogólnych, zwłaszcza w uzupełnianiu kodu.

Oto przykład tworzenia pliku Map<String, Integer>z rozszerzeniem HashMap. Kod, który musiałbym wpisać, to:

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

I rzeczywiście, to dużo pisać tylko po to, by stworzyć nowy HashMap. Jednak w rzeczywistości musiałem wpisać tylko tyle, zanim Eclipse wiedział, czego potrzebuję:

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

To prawda, musiałem dokonać wyboru HashMapz listy kandydatów, ale w zasadzie IDE wiedziało, co dodać, w tym typy ogólne. Dzięki odpowiednim narzędziom używanie leków generycznych nie jest takie złe.

Ponadto, ponieważ typy są znane, podczas pobierania elementów z kolekcji generycznej IDE będzie działało tak, jakby ten obiekt był już obiektem zadeklarowanego typu - nie ma potrzeby rzutowania, aby IDE wiedział, jaki jest typ obiektu jest.

Główną zaletą leków generycznych jest ich dobre współdziałanie z nowymi funkcjami Java 5. Oto przykład podrzucania liczb całkowitych do a Seti obliczania jego sumy:

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

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

W tym fragmencie kodu są obecne trzy nowe funkcje Java 5:

• Generics
• Autoboxing i unboxing
• Pętla For-each

Po pierwsze, typy generyczne i autoboxing prymitywów pozwalają na następujące wiersze:

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

Liczba całkowita 10jest automatycznie umieszczana w ankiecie o Integerwartości 10. (I to samo dla 42). Następnie Integerjest wrzucany do tego, o Setktórym wiadomo, że ma Integers. Próba dodania a Stringspowodowałaby błąd kompilacji.

Następnie pętla for-each przyjmuje wszystkie trzy z nich:

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

Po pierwsze, Setzawierające Integers są używane w pętli for-each. Każdy element jest zadeklarowany jako inti jest dozwolony, ponieważ Integerjest rozpakowywany z powrotem do prymitywu int. Fakt, że następuje rozpakowanie, jest znany, ponieważ używano leków generycznych do określenia, że ​​były one Integerprzechowywane w Set.

Generics mogą być spoiwem łączącym nowe funkcje wprowadzone w Javie 5 i po prostu sprawiają, że kodowanie jest prostsze i bezpieczniejsze. W większości przypadków IDE są wystarczająco sprytne, aby pomóc Ci z dobrymi sugestiami, więc ogólnie nie będzie to o wiele więcej pisanie.

I szczerze mówiąc, jak widać na Setprzykładzie, uważam, że wykorzystanie funkcji Java 5 może uczynić kod bardziej zwięzłym i solidnym.

Edycja - przykład bez typów ogólnych

Poniżej znajduje się ilustracja powyższego Setprzykładu bez użycia typów ogólnych. Jest to możliwe, ale niezbyt przyjemne:

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

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

(Uwaga: powyższy kod wygeneruje ostrzeżenie o niezaznaczonej konwersji w czasie kompilacji).

W przypadku korzystania z kolekcji innych niż ogólne typy, które są wprowadzane do kolekcji, są obiektami typu Object. Dlatego w tym przykładzie a Objectjest tym, co jest addwstawiane do zestawu.

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

W powyższych liniach w grę wchodzi autoboxing - prymitywna intwartość 10i 42są automatycznie dodawane do Integerobiektów, które są dodawane do Set. Należy jednak pamiętać, że Integerobiekty są obsługiwane jako Objects, ponieważ nie ma informacji o typie, które pomogłyby kompilatorowi dowiedzieć się, jakiego typu Setpowinien się spodziewać.

for (Object o : set) {

To jest ta część, która jest kluczowa. Powodem, dla którego pętla for-each działa, jest to, że Setimplementuje Iterableinterfejs, który zwraca Iteratorinformację o typie, jeśli występuje. ( Iterator<T>to znaczy.)

Ponieważ jednak nie ma informacji o typie, Setzwróci an, Iteratorktóry zwróci wartości w Setas Objects, dlatego element pobierany w pętli for-each musi być typu Object.

Teraz, gdy plik Objectjest pobierany z Setpliku, należy go Integerręcznie rzutować na plik, aby wykonać dodanie:

  total += (Integer)o;

Tutaj, typecast jest wykonywany od an Objectdo an Integer. W tym przypadku wiemy, że to zawsze zadziała, ale ręczne rzutowanie zawsze sprawia, że ​​czuję, że jest to delikatny kod, który może zostać uszkodzony, jeśli wprowadzona zostanie niewielka zmiana w innym miejscu. (Czuję, że każda seria ClassCastExceptionczeka na to, aby się wydarzyć, ale dygresję ...)

IntegerObecnie opakowania, w produkt inti pozostawiono do przeprowadzenia dodanie do tej intzmiennej total.

Mam nadzieję, że mógłbym zilustrować, że nowe funkcje Java 5 są możliwe do użycia z kodem nieogólnym, ale po prostu nie jest to tak przejrzyste i proste, jak pisanie kodu za pomocą typów generycznych. Moim zdaniem, aby w pełni wykorzystać nowe funkcje w Javie 5, należy przyjrzeć się rodzajom generycznym, jeśli przynajmniej zezwala na sprawdzanie czasu kompilacji, aby zapobiec rzucaniu wyjątków w czasie wykonywania przez nieprawidłowe typy typów.

Gdybyś przeszukał bazę błędów Javy tuż przed wydaniem wersji 1.5, znalazłbyś siedem razy więcej błędów z NullPointerExceptionniż ClassCastException. Nie wydaje się więc, aby znajdowanie błędów lub przynajmniej błędów, które utrzymują się po krótkich testach z dymem, jest świetną funkcją.

Dla mnie ogromną zaletą typów generycznych jest to, że dokumentują w kodzie ważne informacje o typach. Gdybym nie chciał, aby te informacje o typie były udokumentowane w kodzie, użyłbym języka dynamicznie wpisywanego lub przynajmniej języka z bardziej niejawnym wnioskiem o typie.

Utrzymywanie kolekcji obiektu dla siebie nie jest złym stylem (ale typowym stylem jest skuteczne ignorowanie hermetyzacji). Raczej zależy to od tego, co robisz. Przekazywanie kolekcji do „algorytmów” jest nieco łatwiejsze do sprawdzenia (w czasie kompilacji lub przed nią) za pomocą typów ogólnych.

Generics w Javie ułatwiają parametryczny polimorfizm . Za pomocą parametrów typu można przekazywać argumenty do typów. Podobnie jak metoda String foo(String s)modeluje pewne zachowanie, nie tylko dla określonego ciągu, ale dla dowolnego ciągu s, tak typ taki jak List<T>modeluje pewne zachowanie, nie tylko dla określonego typu, ale dla dowolnego typu . List<T>mówi, że dla każdego typu Tistnieje typ, Listktórego elementy to Ts . Więc Listjest to właściwie konstruktor typu . Przyjmuje typ jako argument i konstruuje inny typ jako wynik.

Oto kilka przykładów typów ogólnych, których używam na co dzień. Po pierwsze, bardzo przydatny interfejs ogólny:

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

Ten interfejs mówi, że dla niektórych dwóch typów Ai Bistnieje funkcja (nazywana f), która przyjmuje Ai zwraca B. Po zaimplementowaniu tego interfejsu Ai Bmogą być dowolne typy, o ile zapewnisz funkcję, fktóra przyjmuje pierwszy i zwraca drugi. Oto przykładowa implementacja interfejsu:

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

Przed odmianami generycznymi polimorfizm był uzyskiwany przez tworzenie podklas za pomocą extendssłowa kluczowego. Dzięki rodzajom generycznym możemy w rzeczywistości pozbyć się podklas i zamiast tego użyć parametrycznego polimorfizmu. Na przykład rozważmy sparametryzowaną (ogólną) klasę używaną do obliczania kodów skrótów dla dowolnego typu. Zamiast przesłonić Object.hashCode (), użylibyśmy klasy ogólnej takiej jak ta:

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

Jest to znacznie bardziej elastyczne niż stosowanie dziedziczenia, ponieważ możemy pozostać przy motywie stosowania kompozycji i polimorfizmu parametrycznego bez blokowania kruchych hierarchii.

Jednak typy generyczne Javy nie są doskonałe. Możesz abstrahować od typów, ale nie możesz na przykład abstrahować od konstruktorów typów. Oznacza to, że możesz powiedzieć „dla dowolnego typu T”, ale nie możesz powiedzieć „dla dowolnego typu T, który przyjmuje parametr typu A”.

Napisałem tutaj artykuł o tych ograniczeniach generycznych Java.

Ogromną zaletą w przypadku leków generycznych jest to, że pozwalają uniknąć podklas. Tworzenie podklas prowadzi zwykle do kruchych hierarchii klas, których rozszerzenie jest niewygodne, oraz klas, które są trudne do zrozumienia indywidualnie bez patrzenia na całą hierarchię.

Wereas przed generycznych może mieć zajęcia jak Widgetprzedłużony o FooWidget, BarWidgeti BazWidget, z rodzajowych można mieć jedną klasę ogólną Widget<A>, która trwa Foo, Barlub Bazw jego konstruktora, aby dać Ci Widget<Foo>, Widget<Bar>i Widget<Baz>.

Leki generyczne unikają uderzenia w wydajność boksu i rozpakowywania. Zasadniczo spójrz na ArrayList vs List <T>. Oba robią te same podstawowe rzeczy, ale List <T> będzie znacznie szybszy, ponieważ nie musisz boksować do / z obiektu.

Największą korzyścią ze stosowania Generics jest ponowne wykorzystanie kodu. Powiedzmy, że masz wiele obiektów biznesowych i zamierzasz napisać BARDZO podobny kod dla każdej jednostki, aby wykonywać te same czynności. (Operacje IE z Linq do SQL).

Dzięki rodzajom możesz stworzyć klasę, która będzie w stanie działać na dowolnym typie dziedziczącym z danej klasy bazowej lub zaimplementować dany interfejs w następujący sposób:

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

    }
}

Zwróć uwagę na ponowne użycie tej samej usługi z różnymi typami w metodzie DoSomething powyżej. Naprawdę eleganckie!

Jest wiele innych wspaniałych powodów, dla których warto używać leków generycznych w swojej pracy, to mój ulubiony.

Po prostu je lubię, ponieważ pozwalają szybko zdefiniować typ niestandardowy (ponieważ i tak ich używam).

Na przykład zamiast definiować strukturę składającą się z ciągu znaków i liczby całkowitej, a następnie zaimplementować cały zestaw obiektów i metod w celu uzyskania dostępu do tablicy tych struktur i tak dalej, możesz po prostu utworzyć słownik

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

A kompilator / IDE wykonuje resztę ciężkiej pracy. W szczególności Słownik pozwala na użycie pierwszego typu jako klucza (bez powtarzających się wartości).

• Kolekcje typowane - nawet jeśli nie chcesz ich używać, prawdopodobnie będziesz musiał się nimi zajmować z innych bibliotek lub z innych źródeł.

• Ogólne wpisywanie w tworzeniu klas:

  public class Foo <T> {public T get () ...

• Unikanie castingu - zawsze nie lubiłem takich rzeczy

  nowy komparator {public int compareTo (Object o) {if (o instanceof classIcareAbout) ...

Gdzie zasadniczo sprawdzasz warunek, który powinien istnieć tylko dlatego, że interfejs jest wyrażony w postaci obiektów.

Moja początkowa reakcja na leki generyczne była podobna do Twojej - „zbyt niechlujna, zbyt skomplikowana”. Z mojego doświadczenia wynika, że ​​po pewnym czasie przyzwyczajasz się do nich, a kod bez nich wydaje się mniej jasno określony i po prostu mniej wygodny. Poza tym reszta świata java używa ich, więc w końcu będziesz musiał zabrać się za program, prawda?

Generics daje również możliwość tworzenia obiektów / metod wielokrotnego użytku, jednocześnie zapewniając obsługę specyficzną dla typu. W niektórych przypadkach zyskujesz również dużą wydajność. Nie znam pełnej specyfikacji Java Generics, ale w .NET mogę określić ograniczenia dla parametru Type, takie jak Implements a Interface, Constructor i Derivation.

1. Umożliwienie programistom implementowania algorytmów ogólnych - używając typów ogólnych programiści mogą implementować algorytmy ogólne, które działają na kolekcjach różnych typów, można je dostosowywać, są bezpieczne dla typów i łatwiejsze do odczytania.

2. Silniejsze sprawdzanie typów w czasie kompilacji - kompilator Java stosuje silne sprawdzanie typów w kodzie ogólnym i generuje błędy, jeśli kod narusza bezpieczeństwo typów. Naprawianie błędów w czasie kompilacji jest łatwiejsze niż naprawianie błędów czasu wykonania, które mogą być trudne do znalezienia.

3. Eliminacja odlewów.