The Generics Java W J2SE 5 wprowadzono programowanie umożliwiające obsługę obiektów bezpiecznych pod względem typu. Sprawia, że ​​kod jest stabilny, wykrywając błędy w czasie kompilacji.

jak przekonwertować ciąg na liczbę całkowitą Java

Przed obiektami generycznymi możemy przechowywać w kolekcji obiekty dowolnego typu, tj. obiekty nieogólne. Teraz typy generyczne zmuszają programistę Java do przechowywania określonego typu obiektów.

Zaleta rozwiązań generycznych Java

Generyki mają głównie 3 zalety. Są one następujące:

1) Bezpieczeństwo typu: W nazwach rodzajowych możemy przechowywać tylko jeden typ obiektów. Nie pozwala na przechowywanie innych obiektów.

Bez Generics możemy przechowywać dowolny typ obiektów.

 List list = new ArrayList(); list.add(10); list.add('10'); With Generics, it is required to specify the type of object we need to store. List list = new ArrayList(); list.add(10); list.add('10');// compile-time error 

2) Odlewanie typu nie jest wymagane: Nie ma potrzeby typowania obiektu.

Przed Generics musimy wpisać cast.

 List list = new ArrayList(); list.add('hello'); String s = (String) list.get(0);//typecasting After Generics, we don't need to typecast the object. List list = new ArrayList(); list.add('hello'); String s = list.get(0); 

3) Sprawdzanie czasu kompilacji: Jest sprawdzany w czasie kompilacji, więc problem nie wystąpi w czasie wykonywania. Dobra strategia programowania mówi, że znacznie lepiej jest poradzić sobie z problemem w czasie kompilacji niż w czasie wykonywania.

 List list = new ArrayList(); list.add('hello'); list.add(32);//Compile Time Error 

Składnia aby użyć kolekcji ogólnej

 ClassOrInterface 

Przykład używać Generics w Javie

 ArrayList 

Pełny przykład typów ogólnych w Javie

Tutaj używamy klasy ArrayList, ale możesz użyć dowolnej klasy kolekcji, takiej jak ArrayList, LinkedList, HashSet, TreeSet, HashMap, Comparator itp.

nazwa produktów do makijażu

 import java.util.*; class TestGenerics1{ public static void main(String args[]){ ArrayList list=new ArrayList(); list.add('rahul'); list.add('jai'); //list.add(32);//compile time error String s=list.get(1);//type casting is not required System.out.println('element is: '+s); Iterator itr=list.iterator(); while(itr.hasNext()){ System.out.println(itr.next()); } } } 

 import java.util.*; class TestGenerics1{ public static void main(String args[]){ ArrayList list=new ArrayList(); list.add('rahul'); list.add('jai'); //list.add(32);//compile time error String s=list.get(1);//type casting is not required System.out.println('element is: '+s); Iterator itr=list.iterator(); while(itr.hasNext()){ System.out.println(itr.next()); } } } 

Wyjście:

 element is: jai rahul jai 

Przykład Java Generics przy użyciu Map

Teraz będziemy używać elementów mapy przy użyciu typów ogólnych. Tutaj musimy przekazać klucz i wartość. Wyjaśnijmy to na prostym przykładzie:

 import java.util.*; class TestGenerics2{ public static void main(String args[]){ Map map=new HashMap(); map.put(1,&apos;vijay&apos;); map.put(4,&apos;umesh&apos;); map.put(2,&apos;ankit&apos;); //Now use Map.Entry for Set and Iterator Set<map.entry> set=map.entrySet(); Iterator<map.entry> itr=set.iterator(); while(itr.hasNext()){ Map.Entry e=itr.next();//no need to typecast System.out.println(e.getKey()+&apos; &apos;+e.getValue()); } }} </map.entry></map.entry>

Wyjście

 1 vijay 2 ankit 4 umesh 

Klasa ogólna

Klasa, która może odwoływać się do dowolnego typu, nazywana jest klasą ogólną. Tutaj używamy parametru typu T, aby utworzyć klasę ogólną określonego typu.

Zobaczmy prosty przykład tworzenia i używania klasy ogólnej.

Tworzenie klasy ogólnej:

 class MyGen{ T obj; void add(T obj){this.obj=obj;} T get(){return obj;} } 

Typ T wskazuje, że może odnosić się do dowolnego typu (takiego jak String, Integer i Employee). Typ określony dla klasy będzie używany do przechowywania i pobierania danych.

Używanie klasy ogólnej:

Zobaczmy kod umożliwiający użycie klasy ogólnej.

 class TestGenerics3{ public static void main(String args[]){ MyGen m=new MyGen(); m.add(2); //m.add('vivek');//Compile time error System.out.println(m.get()); }} 

Wyjście

 2 

Parametry typu

Konwencje nazewnictwa parametrów typu są ważne, aby dokładnie poznać parametry generyczne. Typowe parametry typu są następujące:

lista ciągów Java

1. T - Typ
2. E – Element
3. K - Klucz
4. N - Liczba
5. V - Wartość

Metoda ogólna

Podobnie jak klasa generyczna, możemy stworzyć metodę generyczną, która akceptuje dowolny typ argumentów. W tym przypadku zakres argumentów jest ograniczony do metody, w której są one zadeklarowane. Umożliwia stosowanie metod statycznych i niestatycznych.

Zobaczmy prosty przykład ogólnej metody Java do drukowania elementów tablicy. Używamy tutaj I do oznaczenia elementu.

 public class TestGenerics4{ public static void printArray(E[] elements) { for ( E element : elements){ System.out.println(element ); } System.out.println(); } public static void main( String args[] ) { Integer[] intArray = { 10, 20, 30, 40, 50 }; Character[] charArray = { 'J', 'A', 'V', 'A', 'T','P','O','I','N','T' }; System.out.println( 'Printing Integer Array' ); printArray( intArray ); System.out.println( 'Printing Character Array' ); printArray( charArray ); } } 

Wyjście

 Printing Integer Array 10 20 30 40 50 Printing Character Array J A V A T P O I N T 

Symbol wieloznaczny w języku generycznym Java

? Symbol (znak zapytania) reprezentuje element wieloznaczny. Oznacza to dowolny typ. Jeśli piszemy , oznacza to dowolną klasę potomną Number, np. Integer, Float i double. Teraz możemy wywołać metodę klasy Number poprzez dowolny obiekt klasy potomnej.

Możemy użyć symbolu wieloznacznego jako typ parametru, pola, typ zwracany lub zmienna lokalna. Niedozwolone jest jednak używanie symboli wieloznacznych jako argumentu typu w przypadku wywołania metody ogólnej, utworzenia instancji klasy ogólnej lub nadtypu .

Rozumiemy to na przykładzie podanym poniżej:

 import java.util.*; abstract class Shape{ abstract void draw(); } class Rectangle extends Shape{ void draw(){System.out.println('drawing rectangle');} } class Circle extends Shape{ void draw(){System.out.println('drawing circle');} } class GenericTest{ //creating a method that accepts only child class of Shape public static void drawShapes(List lists){ for(Shape s:lists){ s.draw();//calling method of Shape class by child class instance } } public static void main(String args[]){ List list1=new ArrayList(); list1.add(new Rectangle()); List list2=new ArrayList(); list2.add(new Circle()); list2.add(new Circle()); drawShapes(list1); drawShapes(list2); }} 

Wyjście

 drawing rectangle drawing circle drawing circle 

Symbole wieloznaczne z górnym ograniczeniem

Celem symboli wieloznacznych z górnym ograniczeniem jest zmniejszenie ograniczeń zmiennej. Ogranicza nieznany typ do określonego typu lub podtypu tego typu. Używa się go poprzez zadeklarowanie znaku wieloznacznego („?”), po którym następuje słowo kluczowe „expets” (w przypadku klasy) lub implements (w przypadku „interfejsu”), po którym następuje górna granica.

Składnia

 List 

Tutaj,

lista Javy

? jest znakiem wieloznacznym.

rozciąga się , to słowo kluczowe.

Numer , to klasa obecna w pakiecie java.lang

Załóżmy, że chcemy napisać metodę dla listy Number i jej podtypów (np. Integer, Double). Za pomocą Lista jest odpowiedni dla listy typu Number lub dowolnej jej podklasy, natomiast Lista działa tylko z listą typu Number. Więc, Lista jest mniej restrykcyjny niż Lista .

Przykład górnego symbolu wieloznacznego

W tym przykładzie używamy górnych symboli wieloznacznych do napisania metody dla List i List.

 import java.util.ArrayList; public class UpperBoundWildcard { private static Double add(ArrayList num) { double sum=0.0; for(Number n:num) { sum = sum+n.doubleValue(); } return sum; } public static void main(String[] args) { ArrayList l1=new ArrayList(); l1.add(10); l1.add(20); System.out.println('displaying the sum= '+add(l1)); ArrayList l2=new ArrayList(); l2.add(30.0); l2.add(40.0); System.out.println('displaying the sum= '+add(l2)); } } 

Wyjście

 displaying the sum= 30.0 displaying the sum= 70.0 

Nieograniczone symbole wieloznaczne

Nieograniczony typ wieloznaczny reprezentuje listę nieznanego typu, takiego jak Lista. To podejście może być przydatne w następujących scenariuszach:

• Gdy dana metoda jest zaimplementowana przy wykorzystaniu funkcjonalności udostępnianej w klasie Object.
• Gdy klasa ogólna zawiera metody, które nie zależą od parametru typu.

Przykład nieograniczonej liczby symboli wieloznacznych

 import java.util.Arrays; import java.util.List; public class UnboundedWildcard { public static void display(List list) { for(Object o:list) { System.out.println(o); } } public static void main(String[] args) { List l1=Arrays.asList(1,2,3); System.out.println('displaying the Integer values'); display(l1); List l2=Arrays.asList('One','Two','Three'); System.out.println('displaying the String values'); display(l2); } } 

Wyjście

 displaying the Integer values 1 2 3 displaying the String values One Two Three 

Symbole wieloznaczne z dolną granicą

Celem symboli wieloznacznych z dolną granicą jest ograniczenie nieznanego typu do określonego typu lub nadtypu tego typu. Używa się go poprzez zadeklarowanie znaku wieloznacznego („?”), po którym następuje słowo kluczowe super i jego dolna granica.

Składnia

 List 

Tutaj,

? jest znakiem wieloznacznym.

Super , to słowo kluczowe.

Liczba całkowita , jest klasą opakowania.

matryca lateksowa

Załóżmy, że chcemy napisać metodę dla listy Integer i jej nadtypu (np. Number, Object). Za pomocą Lista jest odpowiedni dla listy typu Integer lub dowolnej z jego nadklas, natomiast Lista działa tylko z listą typu Integer. Więc, Lista jest mniej restrykcyjny niż Lista .

Przykład symbolu wieloznacznego z dolną granicą

W tym przykładzie używamy dolnych symboli wieloznacznych do napisania metody dla List i List.

 import java.util.Arrays; import java.util.List; public class LowerBoundWildcard { public static void addNumbers(List list) { for(Object n:list) { System.out.println(n); } } public static void main(String[] args) { List l1=Arrays.asList(1,2,3); System.out.println('displaying the Integer values'); addNumbers(l1); List l2=Arrays.asList(1.0,2.0,3.0); System.out.println('displaying the Number values'); addNumbers(l2); } } 

Wyjście

 displaying the Integer values 1 2 3 displaying the Number values 1.0 2.0 3.0