Bagaimanakah Saya Boleh Merujuk Jenis Semasa Menggunakan Pembolehubah Jenis dalam Java?

Bagaimana untuk Merujuk Jenis Semasa dengan Pembolehubah Jenis

Bolehkah anda merujuk kepada jenis semasa dengan pembolehubah jenis?

Andaikan anda mencipta fungsi untuk mengembalikan contoh jenis semasa. Adakah terdapat cara untuk menjadikan pembolehubah jenis T merujuk kepada subjenis yang tepat (jadi T harus merujuk kepada B dalam kelas B)?

class A {
    <t extends a> void foo();
}

class B extends A {
    @Override
    T foo();
}</t>

Penyelesaian

Untuk membina tindak balas StriplingWarrior, reka bentuk berikut diperlukan (formula untuk API pembina fasih berhierarki):

Pertama, kelas asas abstrak (atau antara muka) yang menetapkan kontrak untuk mendapatkan semula jenis masa jalan bagi contoh yang memanjangkan kelas:

/**
 * @param <self> The runtime type of the implementer.
 */
abstract class SelfTyped<self extends selftyped>> {

   /**
    * @return This instance.
    */
   abstract SELF self();
}</self></self>

Kelas lanjutan perantaraan mestilah abstrak dan mengekalkan parameter jenis rekursif SENDIRI:

public abstract class MyBaseClass<self extends mybaseclass>>
extends SelfTyped<self> {

    MyBaseClass() { }

    public SELF baseMethod() {

        //logic

        return self();
    }
}</self></self>

Kelas yang diperoleh lebih lanjut boleh ikut corak yang sama. Walau bagaimanapun, tiada satu pun daripada kelas ini boleh digunakan secara langsung sebagai jenis pembolehubah tanpa menggunakan jenis mentah atau kad bebas (yang menjejaskan tujuan corak). Contohnya (jika MyClass bukan abstrak):

//wrong: raw type warning
MyBaseClass mbc = new MyBaseClass().baseMethod();

//wrong: type argument is not within the bounds of SELF
MyBaseClass<mybaseclass> mbc2 = new MyBaseClass<mybaseclass>().baseMethod();

//wrong: no way to correctly declare the type, as its parameter is recursive!
MyBaseClass<mybaseclass>> mbc3 =
        new MyBaseClass<mybaseclass>>().baseMethod();</mybaseclass></mybaseclass></mybaseclass></mybaseclass>

Itulah sebabnya kelas ini dirujuk sebagai "perantaraan", dan mengapa mereka semua harus diisytiharkan abstrak. Kelas "Daun" diperlukan untuk melengkapkan gelung dan menggunakan corak, yang menyelesaikan parameter jenis yang diwarisi SELF dengan jenisnya dan melaksanakan self(). Untuk mengelakkan pelanggaran kontrak, mereka juga harus ditandakan sebagai muktamad:

public final class MyLeafClass extends MyBaseClass<myleafclass> {

    @Override
    MyLeafClass self() {
        return this;
    }

    public MyLeafClass leafMethod() {

        //logic

        return self(); //could also just return this
    }
}</myleafclass>

Menggunakan kelas sedemikian menjadikan corak boleh digunakan:

MyLeafClass mlc = new MyLeafClass().baseMethod().leafMethod();
AnotherLeafClass alc = new AnotherLeafClass().baseMethod().anotherLeafMethod();

Kelebihan utama ini ialah panggilan kaedah boleh dirantai ke atas dan ke bawah hierarki kelas sambil mengekalkan jenis pulangan khusus yang sama.

Atas ialah kandungan terperinci Bagaimanakah Saya Boleh Merujuk Jenis Semasa Menggunakan Pembolehubah Jenis dalam Java?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!