<T> (วงเล็บเหลี่ยม) หมายถึงอะไรใน Java

ขณะนี้ฉันกำลังศึกษา Java และเพิ่งถูกนิ่งงันด้วยวงเล็บมุม (<>) พวกเขาหมายถึงอะไรกันแน่?

public class Pool<T>{
    public interface PoolFactory<T>{
        public T createObject();
    }
    this.freeObjects = new ArrayList<T>(maxsize)
}

อะไร<T>หมายถึง? มันหมายความว่าฉันสามารถสร้างวัตถุประเภทT?

<T>เป็นแบบทั่วไปและสามารถอ่านได้ในชื่อ "ของประเภท T" ขึ้นอยู่กับประเภททางด้านซ้ายของ <> ความหมายที่แท้จริง

ฉันไม่รู้ว่าอะไรPoolหรือPoolFactoryอะไร แต่คุณก็พูดถึงArrayList<T>เช่นกันซึ่งเป็นคลาส Java มาตรฐานดังนั้นฉันจะพูดกับสิ่งนั้น

โดยปกติแล้วคุณจะไม่เห็น "T" ในนั้นคุณจะเห็นประเภทอื่น ดังนั้นหากคุณเห็นArrayList<Integer>ตัวอย่างนั่นหมายความว่า "An ArrayListof Integers" คลาสจำนวนมากใช้ generics เพื่อ จำกัด ชนิดของอิลิเมนต์ในคอนเทนเนอร์ตัวอย่างเช่น อีกตัวอย่างหนึ่งคือHashMap<String, Integer>ซึ่งหมายถึง "แผนที่ที่มีStringคีย์และIntegerค่า"

ตัวอย่าง Pool ของคุณแตกต่างกันเล็กน้อยเนื่องจากคุณมีการกำหนดชั้นเรียน ดังนั้นในกรณีนี้คุณกำลังสร้างคลาสที่คนอื่นสามารถสร้างอินสแตนซ์กับประเภทเฉพาะแทนที่ T ตัวอย่างเช่นฉันสามารถสร้างวัตถุประเภทPool<String>โดยใช้คำจำกัดความของคลาสของคุณ นั่นหมายถึงสองสิ่ง:

• ฉันPool<String>จะมีอินเตอร์เฟซที่PoolFactory<String>มีcreateObjectวิธีการส่งกลับStrings
• ภายในPool<String>จะประกอบด้วยArrayListของสายอักขระ

นี่เป็นข่าวดีเพราะอีกครั้งฉันสามารถเข้ามาและสร้างรหัสPool<Integer>ที่จะใช้รหัสเดียวกัน แต่มีIntegerทุกที่ที่คุณเห็นTในแหล่งที่มา

มันง่ายจริงๆ มันเป็นคุณสมบัติใหม่ที่นำมาใช้ในJ2SE 5 การระบุวงเล็บเหลี่ยมหลังชื่อคลาสหมายความว่าคุณกำลังสร้างชนิดข้อมูลชั่วคราวซึ่งสามารถเก็บข้อมูลประเภทใดก็ได้

ตัวอย่าง:

class A<T>{
    T obj;
    void add(T obj){
        this.obj=obj;
    }
    T get(){
        return obj;
    }
}
public class generics {
    static<E> void print(E[] elements){
        for(E element:elements){
            System.out.println(element);
        }
    }

    public static void main(String[] args) {
        A<String> obj=new A<String>();
        A<Integer> obj1=new A<Integer>();
        obj.add("hello");
        obj1.add(6);
        System.out.println(obj.get());
        System.out.println(obj1.get());

        Integer[] arr={1,3,5,7};
        print(arr);
    }
}

แทนที่จะเป็นเช่น<T>นั้นคุณสามารถเขียนอะไรก็ได้จริง ๆ และมันจะทำงานในลักษณะเดียวกัน ลองเขียนในสถานที่ของ<ABC><T>

นี่เป็นเพียงเพื่อความสะดวก:

• <T> ถูกเรียกว่าประเภทใดก็ได้
• <E> เป็นประเภทองค์ประกอบ
• <N> เป็นประเภทตัวเลข
• <V> เป็นค่า
• <K> เป็นกุญแจสำคัญ

แต่คุณสามารถตั้งชื่อทุกอย่างที่คุณต้องการมันไม่สำคัญ

นอกจากนี้Integer, String, Booleanฯลฯ เป็นเสื้อคลุมชั้นเรียนของ Java ซึ่งช่วยในการตรวจสอบประเภทในระหว่างการรวบรวม ตัวอย่างเช่นในโค้ดด้านบนobjเป็นประเภทStringดังนั้นคุณไม่สามารถเพิ่มประเภทอื่น ๆ ได้ (ลองobj.add(1)มันจะทำให้เกิดข้อผิดพลาด) ในทำนองเดียวกันobj1เป็นIntegerประเภทที่คุณไม่สามารถเพิ่มประเภทอื่น ๆ (ลองobj1.add("hello")ข้อผิดพลาดจะมี)

มันเกี่ยวข้องกับยาชื่อสามัญในจาวา ถ้าฉันพูดถึงArrayList<String>นั่นหมายความว่าฉันสามารถเพิ่มเฉพาะ String type object ใน ArrayList นั้น

ประโยชน์หลักที่สองของ generics ใน Java คือ:

1. การลดจำนวนการร่ายในโปรแกรมของคุณซึ่งเป็นการลดจำนวนข้อบกพร่องที่อาจเกิดขึ้นในโปรแกรมของคุณ
2. การปรับปรุงความชัดเจนของรหัส

เรียกว่าประเภททั่วไป คุณสามารถยกตัวอย่างวัตถุประเภทนี้:

PoolFactory<Integer> pool = new Pool<Integer>();

พารามิเตอร์ทั่วไปสามารถเป็นประเภทการอ้างอิงได้เท่านั้น ดังนั้นคุณไม่สามารถใช้ประเภทดั้งเดิมเช่น int หรือ double หรือ char หรือประเภทดั้งเดิมอื่น ๆ

<>ใช้เพื่อระบุข้อมูลทั่วไปใน Java

Tเป็นพารามิเตอร์ประเภทในตัวอย่างนี้ และไม่มี: instantiating เป็นหนึ่งในไม่กี่สิ่งที่คุณไม่สามารถTทำอะไรกับ

นอกเหนือจากการสอนที่เชื่อมโยงกับคำถามที่พบบ่อยของ Angelika Langers Genericsเป็นแหล่งข้อมูลที่ดีในหัวข้อนี้

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

ArrayList<Employee> employees = new ArrayList<Employee>();
ArrayList<Company> companies = new ArrayList<Company>();

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