Szia! Folytatjuk a generikumok leckesorozatát. Korábban általános képet kaptunk arról, hogy mik ezek, és miért van rájuk szükség. Ma többet megtudunk a generikumok egyes jellemzőiről és a velük való együttműködésről. Gyerünk! Az utolsó leckében![Típustörlés – 1]()
az általános típusok és a nyers típusok közötti különbségről beszéltünk . A nyers típus egy általános osztály, amelynek típusát eltávolították.
![Típustörlés – 3]()
A dokumentáció ezt írja: "T - az osztály objektum által modellezett osztály típusa." Ha ezt a dokumentáció nyelvéről egyszerű beszédre fordítjuk, megértjük, hogy az
az általános típusok és a nyers típusok közötti különbségről beszéltünk . A nyers típus egy általános osztály, amelynek típusát eltávolították.
List list = new ArrayList();
List. Ha megpróbálunk létrehozni egy ilyet, Listés néhány objektumot hozzáadunk hozzá, akkor egy figyelmeztetést fogunk látni az IDEA-ban:
"Unchecked call to add(E) as a member of raw type of java.util.List".
List<String>, a fordító hibát fog generálni. Pontosan ezt akarják elérni a nyelv készítői, amikor generikus termékeket készítettek: fordítási idő ellenőrzéseket. De amikor az összes Java-kód bájtkóddá változik, már nem tartalmaz információkat a típusparaméterekről. A bájtkódban a List<Cat>macskák listája nem különbözik List<String>a karakterláncoktól. A bájtkódban semmi sem mondja, hogy az objektumok catslistája Cat. Az ilyen információk törlődnek a fordítás során – csak az a tény, hogy van listája, List<Object> catsa program bájtkódjába kerül. Lássuk, hogyan működik ez:
public class TestClass<T> {
private T value1;
private T value2;
public void printValues() {
System.out.println(value1);
System.out.println(value2);
}
public static <T> TestClass<T> createAndAdd2Values(Object o1, Object o2) {
TestClass<T> result = new TestClass<>();
result.value1 = (T) o1;
result.value2 = (T) o2;
return result;
}
public static void main(String[] args) {
Double d = 22.111;
String s = "Test String";
TestClass<Integer> test = createAndAdd2Values(d, s);
test.printValues();
}
}
TestClass. Ez nagyon egyszerű: valójában egy kis "gyűjtemény" 2 objektumból, amelyek azonnal eltárolódnak az objektum létrehozásakor. 2 mezője van T. A createAndAdd2Values()metódus végrehajtásakor a két átadott objektumot ( Object aés Object ba típusba kell önteni T, majd hozzá kell adni az TestClassobjektumhoz. A metódusban main()létrehozunk egy TestClass<Integer>, azaz a Integertype argumentum helyettesíti a type paramétert. A-t és a- t Integeris átadunk a metódus. Gondolod, hogy a programunk működni fog? Végül is típus argumentumként adtuk meg, de az a-t biztosan nem lehet egy -re leadni ! Futtassuk aDoubleStringcreateAndAdd2Values()IntegerStringIntegermain()módszert és ellenőrzést. Konzol kimenet:
22.111
Test String
IntegerAz objektumunk példányosításához használt type argumentum információi TestClass<Integer> testtörlésre kerültek a kód lefordításakor. A mező válik TestClass<Object> test. A mi Doubleés Stringargumentumaink könnyen objektumokká konvertáltak Object(nem úgy alakulnak objektummá, Integerahogy vártuk!), és csendesen hozzáadtuk a -hoz TestClass. Íme egy másik egyszerű, de nagyon leleplező példa a típustörlésre:
import java.util.ArrayList;
import java.util.List;
public class Main {
private class Cat {
}
public static void main(String[] args) {
List<String> strings = new ArrayList<>();
List<Integer> numbers = new ArrayList<>();
List<Cat> cats = new ArrayList<>();
System.out.println(strings.getClass() == numbers.getClass());
System.out.println(numbers.getClass() == cats.getClass());
}
}
true
true
String, Integer, és a saját Catosztályunkkal. Ám a bájtkódra való átalakítás során mindhárom lista - lesz List<Object>, így a program futása során azt mondja, hogy mindhárom esetben ugyanazt az osztályt használjuk.
Írja be az erasing parancsot, ha tömbökkel és általánosokkal dolgozik
Van egy nagyon fontos pont, amelyet egyértelműen meg kell érteni, amikor tömbökkel és általános osztályokkal (példáulList) dolgozik. Ezt is figyelembe kell vennie a program adatstruktúráinak kiválasztásakor. A generikus termékek típustörlés hatálya alá tartoznak. A típusparaméterekre vonatkozó információ futás közben nem érhető el. Ezzel szemben a tömbök ismerik és felhasználhatják az adattípusukat, amikor a program fut. Ha egy tömbbe érvénytelen típust próbálnak bevinni, az kivételt eredményez:
public class Main2 {
public static void main(String[] args) {
Object x[] = new String[3];
x[0] = new Integer(222);
}
}
Exception in thread "main" java.lang.ArrayStoreException: java.lang.Integer
new List<T>[]
new List<String>[]
new T[]
List<String>, fordítási hibát kapunk, amely az általános tömb létrehozására panaszkodik:
import java.util.List;
public class Main2 {
public static void main(String[] args) {
// Compilation error! Generic array creation
List<String>[] stringLists = new List<String>[1];
}
}
public static void main(String[] args) {
List<String>[] stringLists = new List<String>[1]; // (1)
List<Integer> intList = Arrays.asList(42, 65, 44); // (2)
Object[] objects = stringLists; // (3)
objects[0] = intList; // (4)
String s = stringLists[0].get(0); // (5)
}
List<String>[] stringListsmegengedett, és nem generál fordítási hibát. Ha ez igaz lenne, itt van néhány dolog, amit tehetünk: Az 1. sorban létrehozunk egy listák tömbjét: List<String>[] stringLists. Tömbünk tartalmaz egyet List<String>. A 2. sorban számlistát készítünk: List<Integer>. A 3. sorban List<String>[]egy Object[] objectsváltozóhoz rendeljük a miünket. A Java nyelv ezt lehetővé teszi: egy objektumtömb Xtárolhat Xobjektumokat és objektumokat az összes alosztályból X. Ennek megfelelően bármit elhelyezhetsz egy tömbben Object. objects()A 4. sorban a tömb egyetlen elemét (a ) helyettesítjük List<String>egy -re List<Integer>. List<Integer>Így a csak tárolásra szánt tömbbe tettünk egy-tList<String>tárgyakat! Csak az 5. sor végrehajtásakor fogunk találkozni hibával. A ClassCastExceptionprogram futás közben fog dobni. Ennek megfelelően a Java-t betiltották az ilyen tömbök létrehozására. Ezzel elkerülhetjük az ilyen helyzeteket.
Hogyan kerülhetem meg a típustörlést?
Nos, megtanultuk a típustörlést. Próbáljuk meg becsapni a rendszert! :) Feladat: Van egy általánosTestClass<T>osztályunk. createNewT()Ehhez az osztályhoz egy metódust akarunk írni , amely egy új Tobjektumot hoz létre és ad vissza. De ez lehetetlen, igaz? TA fordítás során minden információ törlődik a típusról, és futás közben nem tudjuk meghatározni, hogy milyen típusú objektumot kell létrehoznunk. Valójában van ennek egy trükkös módja. Valószínűleg emlékszel arra, hogy a Java-nak van egy Classosztálya. Használhatjuk bármely objektumunk osztályának meghatározására:
public class Main2 {
public static void main(String[] args) {
Class classInt = Integer.class;
Class classString = String.class;
System.out.println(classInt);
System.out.println(classString);
}
}
class java.lang.Integer
class java.lang.String
https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html
Integer.classobjektum osztálya nem csak Class, hanem Class<Integer>. Az String.classobjektum típusa nem csak Class, hanem Class<String>stb. Ha még mindig nem világos, próbáljon meg egy type paramétert hozzáadni az előző példához:
public class Main2 {
public static void main(String[] args) {
Class<Integer> classInt = Integer.class;
// Compilation error!
Class<String> classInt2 = Integer.class;
Class<String> classString = String.class;
// Compilation error!
Class<Double> classString2 = String.class;
}
}
MySecretClass:
public class MySecretClass {
public MySecretClass() {
System.out.println("A MySecretClass object was created successfully!");
}
}
public class TestClass<T> {
Class<T> typeParameterClass;
public TestClass(Class<T> typeParameterClass) {
this.typeParameterClass = typeParameterClass;
}
public T createNewT() throws IllegalAccessException, InstantiationException {
T t = typeParameterClass.newInstance();
return t;
}
public static void main(String[] args) throws InstantiationException, IllegalAccessException {
TestClass<MySecretClass> testString = new TestClass<>(MySecretClass.class);
MySecretClass secret = testString.createNewT();
}
}
A MySecretClass object was created successfully!
TestClass<MySecretClass> testString = new TestClass<>(MySecretClass.class);
Ttárgy! :) Ezzel a mai lecke véget is ér. Mindig emlékeznie kell a típustörlésre, amikor általános gyógyszerekkel dolgozik. Ez a megoldás nem tűnik túl kényelmesnek, de meg kell értenie, hogy a generikus kifejezések nem voltak a Java nyelv részei annak létrehozásakor. Ezt a funkciót, amely segít nekünk paraméterezett gyűjtemények létrehozásában és a fordítás során előforduló hibák észlelésében, később alkalmaztuk. Néhány más nyelven, amely az első verzió általános kifejezéseit tartalmazza, nincs típustörlés (például C#-ban). Egyébként még nem végeztünk a generikumok tanulmányozásával! A következő leckében a generikumok néhány további jellemzőjével ismerkedhet meg. Egyelőre jó lenne megoldani pár feladatot! :)
GO TO FULL VERSION