ทำไม Java enum ตัวอักษรไม่สามารถมีพารามิเตอร์ประเภททั่วไปได้?

Java enums ยอดเยี่ยม ดังนั้นยาชื่อสามัญ แน่นอนว่าเราทุกคนรู้ถึงข้อ จำกัด ของอันหลังเนื่องจากการลบประเภท แต่มีสิ่งหนึ่งที่ฉันไม่เข้าใจว่าทำไมฉันไม่สามารถสร้าง enum เช่นนี้:

public enum MyEnum<T> {
    LITERAL1<String>,
    LITERAL2<Integer>,
    LITERAL3<Object>;
}

พารามิเตอร์ประเภททั่วไป<T>ในทางกลับกันนั้นจะมีประโยชน์ในสถานที่ต่าง ๆ ลองนึกภาพพารามิเตอร์ประเภททั่วไปกับวิธีการ:

public <T> T getValue(MyEnum<T> param);

หรือแม้แต่ในชั้นเรียน Enum เอง:

public T convert(Object o);

ตัวอย่างที่ชัดเจนยิ่งขึ้น # 1

เนื่องจากตัวอย่างด้านบนอาจดูเป็นนามธรรมเกินไปสำหรับบางคนนี่เป็นตัวอย่างในชีวิตจริงมากขึ้นว่าทำไมฉันถึงต้องการทำสิ่งนี้ ในตัวอย่างนี้ฉันต้องการใช้

• Enums เพราะจากนั้นฉันสามารถระบุชุดของคีย์คุณสมบัติที่ จำกัด ได้
• ยาสามัญเพราะฉันสามารถมีความปลอดภัยประเภทระดับวิธีการสำหรับการจัดเก็บคุณสมบัติ

public interface MyProperties {
     public <T> void put(MyEnum<T> key, T value);
     public <T> T get(MyEnum<T> key);
}

ตัวอย่างที่ชัดเจนยิ่งขึ้น # 2

ฉันมีการแจกแจงของชนิดข้อมูล:

public interface DataType<T> {}

public enum SQLDataType<T> implements DataType<T> {
    TINYINT<Byte>,
    SMALLINT<Short>,
    INT<Integer>,
    BIGINT<Long>,
    CLOB<String>,
    VARCHAR<String>,
    ...
}

แต่ละตัวอักษร enum จะเห็นได้ชัดว่ามีคุณสมบัติเพิ่มเติมตามประเภททั่วไป<T>ในขณะที่ในเวลาเดียวกันเป็น enum (ไม่เปลี่ยนรูปซิงเกิลตันนับ ฯลฯ ฯลฯ )

คำถาม:

ไม่มีใครคิดเรื่องนี้บ้าง? นี่เป็นข้อ จำกัด ที่เกี่ยวข้องกับคอมไพเลอร์หรือไม่? พิจารณาข้อเท็จจริงที่ว่าคำหลัก " enum " นั้นถูกนำไปใช้เป็นน้ำตาล syntactic ซึ่งเป็นตัวแทนของรหัสที่สร้างขึ้นเพื่อ JVM ฉันไม่เข้าใจข้อ จำกัด นี้

ใครสามารถอธิบายสิ่งนี้ให้ฉันได้บ้าง ก่อนที่คุณจะตอบให้พิจารณาสิ่งนี้:

• ฉันรู้ว่าประเภททั่วไปถูกลบ :-)
• ฉันรู้ว่ามีวิธีแก้ปัญหาโดยใช้คลาสวัตถุ พวกเขากำลังแก้ไขปัญหา
• ประเภททั่วไปส่งผลให้เกิดประเภทคอมไพเลอร์สร้างมันได้ทุกที่ (เช่นเมื่อเรียกวิธีการแปลง ()
• ประเภททั่วไป <T> จะอยู่ใน enum ดังนั้นมันจึงผูกพันตามตัวอักษรของ enum แต่ละตัว ดังนั้นคอมไพเลอร์จะได้รู้ว่าประเภทใดที่จะนำไปใช้เมื่อเขียนบางอย่างString string = LITERAL1.convert(myObject); Integer integer = LITERAL2.convert(myObject);
• เช่นเดียวกับพารามิเตอร์ประเภททั่วไปในT getvalue()วิธีการ คอมไพเลอร์สามารถใช้การหล่อประเภทเมื่อโทรString string = someClass.getValue(LITERAL1)

นี้ขณะนี้ถูกกล่าวถึงในฐานะของJEP-301 Enums ตัวอย่างที่ให้ไว้ใน JEP คือซึ่งเป็นสิ่งที่ฉันกำลังมองหา:

enum Argument<X> { // declares generic enum
   STRING<String>(String.class), 
   INTEGER<Integer>(Integer.class), ... ;

   Class<X> clazz;

   Argument(Class<X> clazz) { this.clazz = clazz; }

   Class<X> getClazz() { return clazz; }
}

Class<String> cs = Argument.STRING.getClazz(); //uses sharper typing of enum constant

น่าเสียดายที่ JEP ยังคงดิ้นรนกับปัญหาที่สำคัญ: http://mail.openjdk.java.net/pipermail/amber-spec-experts/2017-May/000041.html

คำตอบอยู่ในคำถาม:

เนื่องจากการลบประเภท

ไม่มีวิธีใดในสองวิธีนี้ที่เป็นไปได้เนื่องจากประเภทอาร์กิวเมนต์จะถูกลบ

public <T> T getValue(MyEnum<T> param);
public T convert(Object);

เมื่อต้องการตระหนักถึงวิธีการเหล่านั้นคุณสามารถสร้าง enum ของคุณเป็น:

public enum MyEnum {
    LITERAL1(String.class),
    LITERAL2(Integer.class),
    LITERAL3(Object.class);

    private Class<?> clazz;

    private MyEnum(Class<?> clazz) {
      this.clazz = clazz;
    }

    ...

}

เพราะคุณทำไม่ได้ อย่างจริงจัง. สามารถเพิ่มลงในข้อมูลจำเพาะภาษาได้ มันยังไม่เคย มันจะเพิ่มความซับซ้อนบางอย่าง ประโยชน์ที่ได้รับจากต้นทุนหมายความว่าไม่ใช่ลำดับความสำคัญสูง

ปรับปรุง: ปัจจุบันการเพิ่มภาษาภายใต้JEP 301: ปรับปรุง Enums

มีวิธีอื่นใน ENUM ที่ไม่สามารถใช้งานได้ สิ่งที่จะMyEnum.values()กลับมา?

เกี่ยวกับอะไร MyEnum.valueOf(String name)อะไร

สำหรับ valueOf หากคุณคิดว่าคอมไพเลอร์สามารถสร้างวิธีการทั่วไปเช่น

ค่าคง MyEnum สาธารณะคงที่ (ชื่อสตริง);

เพื่อที่จะเรียกมันว่ามันMyEnum<String> myStringEnum = MyEnum.value("some string property")ไม่ทำงานเช่นกัน ตัวอย่างเช่นถ้าคุณโทรMyEnum<Int> myIntEnum = MyEnum.<Int>value("some string property")? มันเป็นไปไม่ได้ที่จะใช้วิธีการนั้นให้ทำงานอย่างถูกต้องตัวอย่างเช่นการโยน exception หรือ return null เมื่อคุณเรียกมันว่าเป็นMyEnum.<Int>value("some double property")เพราะการลบประเภท

ตรงไปตรงนี้ดูเหมือนจะเป็นทางออกในการค้นหาปัญหามากกว่าสิ่งใด

จุดประสงค์ทั้งหมดของ java enum คือสร้างแบบจำลองการแจกแจงชนิดอินสแตนซ์ที่แบ่งปันคุณสมบัติที่คล้ายกันในลักษณะที่ให้ความสม่ำเสมอและความมีชีวิตชีวาเหนือกว่าการเป็นตัวแทนของสตริงหรือจำนวนเต็มเปรียบเทียบกัน

นำตัวอย่างของ enum หนังสือเรียน สิ่งนี้ไม่มีประโยชน์หรือสอดคล้องกันมาก:

public enum Planet<T>{
    Earth<Planet>,
    Venus<String>,
    Mars<Long>
    ...etc.
}

เหตุใดฉันจึงต้องการให้ดาวเคราะห์ที่แตกต่างของฉันมีการแปลงประเภททั่วไปต่างกัน มันแก้ปัญหาอะไรได้บ้าง? มันแสดงให้เห็นถึงความซับซ้อนของความหมายภาษา? หากฉันต้องการพฤติกรรมนี้เป็นเครื่องมือที่ดีที่สุดในการบรรลุเป้าหมาย

นอกจากนี้คุณจะจัดการกับการแปลงที่ซับซ้อนได้อย่างไร

สำหรับอินสแตนซ์

public enum BadIdea<T>{
   INSTANCE1<Long>,
   INSTANCE2<MyComplexClass>;
}

มันง่ายพอที่String Integerจะให้ชื่อหรือลำดับ แต่ยาชื่อสามัญจะอนุญาตให้คุณจัดหาประเภทใดก็ได้ คุณจะจัดการการแปลงเป็นMyComplexClassอย่างไร ทีนี้คุณสร้างโครงสร้างสองอย่างด้วยการบังคับให้คอมไพเลอร์รู้ว่ามีเซตย่อยจำนวนหนึ่งที่สามารถจัดให้กับ enums ทั่วไปและแนะนำความสับสนเพิ่มเติมให้กับแนวคิด (Generics) ที่ดูเหมือนจะหลบหลีกโปรแกรมเมอร์จำนวนมาก

กลายเป็น "enum" เป็นตัวย่อสำหรับการแจงนับ มันเป็นแค่ชุดของค่าคงที่ที่มีชื่อที่ยืนแทนเลขลำดับเพื่อให้โค้ดอ่านง่ายขึ้น

ฉันไม่เห็นความหมายที่ตั้งใจไว้ของค่าคงที่ที่กำหนดพารามิเตอร์ชนิดอาจเป็นได้

ฉันคิดว่าเพราะโดยทั่วไปแล้ว Enums ไม่สามารถเข้าร่วมได้

คุณจะตั้งค่าคลาส T ที่ใดถ้า JVM อนุญาตให้คุณทำเช่นนั้น

การแจงนับเป็นข้อมูลที่ควรจะเหมือนกันเสมอหรืออย่างน้อยที่สุดก็จะไม่เปลี่ยนแปลงแบบ dinamically

ใหม่ MyEnum <> ()?

วิธีการต่อไปนี้อาจมีประโยชน์

public enum MyEnum{

    LITERAL1("s"),
    LITERAL2("a"),
    LITERAL3(2);

    private Object o;

    private MyEnum(Object o) {
        this.o = o;
    }

    public Object getO() {
        return o;
    }

    public void setO(Object o) {
        this.o = o;
    }   
}