สวัสดี! เราดำเนินการต่อชุดบทเรียนของเราเกี่ยวกับยาชื่อสามัญ ก่อนหน้านี้เรามีความคิดทั่วไปว่าพวกเขาคืออะไรและเหตุใดจึงจำเป็น วันนี้เราจะเรียนรู้เพิ่มเติมเกี่ยวกับคุณลักษณะบางอย่างของยาชื่อสามัญและการทำงานกับพวกเขา ไปกันเถอะ! ![ประเภทการลบ - 1]()
ในบทเรียนที่แล้วเราได้พูดถึงความแตกต่างระหว่างประเภททั่วไปและประเภทดิบ ประเภทดิบคือคลาสทั่วไปที่ถูกลบประเภทแล้ว
![ประเภทการลบ - 3]()
เอกสารระบุว่า "T - ประเภทของคลาสที่จำลองโดยวัตถุคลาสนี้" การแปลสิ่งนี้จากภาษาของเอกสารเป็นคำพูดธรรมดา เราเข้าใจดีว่าคลาสของ
ในบทเรียนที่แล้วเราได้พูดถึงความแตกต่างระหว่างประเภททั่วไปและประเภทดิบ ประเภทดิบคือคลาสทั่วไปที่ถูกลบประเภทแล้ว
List list = new ArrayList();
List. หากเราพยายามสร้างListและเพิ่มวัตถุเข้าไป เราจะเห็นคำเตือนใน IDEA:
"Unchecked call to add(E) as a member of raw type of java.util.List".
List<String>คอมไพลเลอร์จะสร้างข้อผิดพลาด นี่คือสิ่งที่ผู้สร้างภาษาต้องการให้บรรลุเมื่อพวกเขาสร้างชื่อสามัญ: การตรวจสอบเวลาคอมไพล์ แต่เมื่อโค้ด Java ทั้งหมดของคุณเปลี่ยนเป็น bytecode ก็จะไม่มีข้อมูลเกี่ยวกับพารามิเตอร์ประเภทอีกต่อไป ใน bytecode List<Cat>รายการแมวของคุณไม่แตกต่างจากList<String>สตริง ใน bytecode ไม่มีอะไรบอกว่าcatsเป็นรายการของCatวัตถุ ข้อมูลดังกล่าวจะถูกลบระหว่างการคอมไพล์ — เฉพาะความจริงที่ว่าคุณมีList<Object> catsรายการเท่านั้นที่จะลงเอยด้วยรหัสไบต์ของโปรแกรม มาดูกันว่ามันทำงานอย่างไร:
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คลาส ทั่วไปของเราเอง มันค่อนข้างเรียบง่าย: จริงๆ แล้วมันเป็น "คอลเลกชัน" เล็กๆ ของวัตถุ 2 ชิ้น ซึ่งจะถูกจัดเก็บทันทีเมื่อวัตถุถูกสร้างขึ้น มี 2 Tช่อง เมื่อcreateAndAdd2Values()เมธอดถูกดำเนินการ อ็อบเจกต์ที่ส่งผ่านทั้งสองรายการ ( Object aและObject bต้องแปลงเป็นTประเภท แล้วจึงเพิ่มลงใน ออบเจกต์ TestClassในmain()เมธอด เราสร้าง a TestClass<Integer>นั่นคือIntegerอาร์กิวเมนต์ type จะแทนที่Integerพารามิเตอร์ประเภท นอกจากนี้ เรายังส่ง a Doubleและ a Stringไป ยัง วิธีcreateAndAdd2Values()การ คุณคิดว่าโปรแกรมของเราจะใช้ได้หรือไม่ ท้ายที่สุด เราระบุIntegerเป็นอาร์กิวเมนต์ type แต่Stringไม่สามารถส่งไปยัง an ได้อย่างแน่นอนInteger!main()วิธีการและตรวจสอบ เอาต์พุตคอนโซล:
22.111
Test String
Integerอาร์กิวเมนต์ประเภทที่ใช้ในการยกตัวอย่างTestClass<Integer> testวัตถุของเราถูกลบเมื่อรวบรวมโค้ด สนามกลายเป็นTestClass<Object> test. อาร์กิวเมนต์ ของเราDoubleและStringถูกแปลงเป็นObjectวัตถุอย่างง่ายดาย (ไม่ได้แปลงเป็นIntegerวัตถุอย่างที่เราคาดไว้!) และเพิ่มลงTestClassใน ต่อไปนี้เป็นอีกตัวอย่างง่ายๆ แต่เปิดเผยมากของการลบประเภท:
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ของเราเอง Catแต่ในระหว่างการแปลงเป็น bytecode ทั้งสามรายการจะกลายเป็นList<Object>ดังนั้นเมื่อโปรแกรมทำงาน มันจะบอกเราว่าเราใช้คลาสเดียวกันในทั้งสามกรณี
พิมพ์การลบเมื่อทำงานกับอาร์เรย์และชื่อสามัญ
มีจุดสำคัญที่ต้องเข้าใจอย่างชัดเจนเมื่อทำงานกับอาร์เรย์และคลาสทั่วไป (เช่นList) คุณควรคำนึงถึงสิ่งนี้ด้วยเมื่อเลือกโครงสร้างข้อมูลสำหรับโปรแกรมของคุณ ยาสามัญอาจมีการลบประเภท ไม่มีข้อมูลเกี่ยวกับพารามิเตอร์ประเภทที่รันไทม์ ในทางตรงกันข้าม อาร์เรย์รู้และสามารถใช้ข้อมูลเกี่ยวกับประเภทข้อมูลเมื่อโปรแกรมกำลังทำงาน การพยายามใส่ประเภทที่ไม่ถูกต้องลงในอาร์เรย์จะทำให้เกิดข้อยกเว้น:
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>วัตถุ เราได้รับข้อผิดพลาดในการรวบรวมที่บ่นเกี่ยวกับการสร้างอาร์เรย์ทั่วไป:
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>[] stringListsได้รับอนุญาตและจะไม่สร้างข้อผิดพลาดในการคอมไพล์ หากสิ่งนี้เป็นจริง ต่อไปนี้คือสิ่งที่เราสามารถทำได้: ในบรรทัดที่ 1 เราสร้างอาร์เรย์ของรายการList<String>[] stringLists: อาร์เรย์ของเรามีหนึ่งList<String>. ในบรรทัดที่ 2 เราสร้างรายการตัวเลข: List<Integer>. ในบรรทัดที่ 3 เรากำหนดList<String>[]ตัวแปร ของ Object[] objectsเรา ภาษา Java อนุญาตสิ่งนี้: อาร์เรย์ของXวัตถุสามารถจัดเก็บXวัตถุและวัตถุของคลาสย่อยXทั้งหมด คุณสามารถใส่อะไรก็ได้ในObjectอาร์เรย์ ในบรรทัดที่ 4 เราแทนที่องค์ประกอบเดียวของobjects()อาร์เรย์ (a List<String>) ด้วยList<Integer>a ดังนั้นเราจึงใส่List<Integer>อาร์เรย์ที่มีไว้เพื่อจัดเก็บเท่านั้นList<String>วัตถุ! เราจะพบข้อผิดพลาดเมื่อเรารันบรรทัดที่ 5 เท่านั้น A ClassCastExceptionจะถูกส่งไปที่รันไทม์ ด้วยเหตุนี้ จึงมีการเพิ่มข้อห้ามในการสร้างอาร์เรย์ดังกล่าวใน Java สิ่งนี้ช่วยให้เราหลีกเลี่ยงสถานการณ์ดังกล่าวได้
ฉันจะหลีกเลี่ยงการลบประเภทได้อย่างไร
เราได้เรียนรู้เกี่ยวกับการลบประเภท มาลองหลอกระบบกัน! :) ภารกิจ: เรามีTestClass<T>คลาส ทั่วไป เราต้องการเขียนcreateNewT()เมธอดสำหรับคลาสนี้ซึ่งจะสร้างและส่งคืนTวัตถุ ใหม่ แต่มันเป็นไปไม่ได้ใช่ไหม? ข้อมูลทั้งหมดเกี่ยวกับTประเภทจะถูกลบระหว่างการคอมไพล์ และในขณะรันไทม์ เราไม่สามารถกำหนดประเภทของวัตถุที่เราต้องการสร้างได้ มีวิธีหนึ่งที่ยุ่งยากในการทำเช่นนี้ คุณคงจำได้ว่า Java มีClassคลาส เราสามารถใช้มันเพื่อกำหนดคลาสของวัตถุใดๆ ของเรา:
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.classออบเจกต์ไม่ใช่แค่Classแต่แทนที่จะClass<Integer>เป็น ประเภทของString.classวัตถุไม่ใช่แค่Classแต่แทนที่จะเป็นClass<String>ฯลฯ หากยังไม่ชัดเจน ให้ลองเพิ่มพารามิเตอร์ประเภทในตัวอย่างก่อนหน้า:
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);
Tวัตถุ! :) ด้วยเหตุนี้ บทเรียนของวันนี้ก็จบลง คุณต้องจำการลบประเภทเสมอเมื่อทำงานกับยาชื่อสามัญ วิธีแก้ไขปัญหานี้ดูไม่ค่อยสะดวกนัก แต่คุณควรเข้าใจว่ายาสามัญไม่ได้เป็นส่วนหนึ่งของภาษา Java เมื่อสร้างขึ้น ฟีเจอร์นี้ซึ่งช่วยให้เราสร้างคอลเล็กชันที่กำหนดพารามิเตอร์และตรวจจับข้อผิดพลาดระหว่างการคอมไพล์ได้ถูกนำมาใช้ในภายหลัง ในภาษาอื่นบางภาษาที่รวมชื่อสามัญจากเวอร์ชันแรก จะไม่มีการลบประเภท (เช่น ใน C#) อย่างไรก็ตาม เรายังศึกษายาชื่อสามัญไม่จบสิ้น! ในบทเรียนถัดไป คุณจะได้ทำความคุ้นเคยกับคุณสมบัติเพิ่มเติมของยาชื่อสามัญ สำหรับตอนนี้ จะเป็นการดีที่จะแก้ปัญหาสองอย่าง! :)
GO TO FULL VERSION