Generik Java dan analisis contoh kelas pembalut

1. Apakah itu generik?

Intipati generik adalah untuk membuat parameter jenis (tanpa mencipta jenis baharu, untuk mengawal jenis sekatan parameter tertentu melalui jenis yang ditentukan oleh generik) ).

Pertama lihat contoh berikut:

Tatasusunan yang kami pelajari sebelum ini hanya boleh menyimpan elemen jenis tertentu. Contohnya: int[] array=new int[10];String[] array=new String[10];Kelas Objek ialah kelas induk bagi semua kelas, jadi bolehkah kita mencipta tatasusunan Obj?

class Myarray{
    public Object[] array=new Object[10];
    public void setVal(int pos,Object val){
        this.array[pos]=val;
    }
    public Object getPos(int pos){
        return this.array[pos];
    }
}
public class TestDemo{
    public static void main(String[] args) {
        Myarray myarray=new Myarray();
        myarray.setVal(1,0);
        myarray.setVal(2,"shduie");//字符串也可以存放
        String ret=(String)myarray.getPos(2);//虽然我们知道它是字符串类型，但是还是要强制类型转换
        System.out.println(ret);
    }
}

Selepas melaksanakan kod di atas, kami mendapati:

• Sebarang jenis data boleh disimpan

• Tidak . 2 Objek yang dimuat turun pada asalnya adalah rentetan, tetapi penukaran jenis paksa

diperlukan untuk memperkenalkan generik Tujuan generik adalah untuk menentukan jenis objek yang sepatutnya disimpan oleh bekas semasa Pengkompil menyemaknya sendiri.

2. Sintaks generik

nama kelas generik kelas{

//Parameter jenis boleh digunakan di sini

}

Penggunaan generik:

Kelas generik nama pembolehubah=kelas generik baharu(parameter sebenar kaedah pembina)

MyArray list=new MyArray();

[Nota]

selepas 🎜>
• mewakili pemegang tempat, menunjukkan bahawa kelas semasa ialah kelas generik

• Apabila membuat instantiat generik, tidak boleh Ia adalah jenis yang mudah dan perlu menjadi kelas pembalut

• komposisi jenis yang tidak mengambil bahagian dalam generik

• tidak boleh Tatasusunan jenis generik baharu

• Menggunakan generik tidak memerlukan pemutus

Generik mudah:

//此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
//在实例化泛型类时，必须指定T的具体类型
public class Test<T>{ 
    //key这个成员变量的类型为T,T的类型由外部指定  
   private T key;
 
    public Test(T key) { //泛型构造方法形参key的类型也为T，T的类型由外部指定
        this.key = key;
    }
 
    public T getKey(){ //泛型方法getKey的返回值类型为T，T的类型由外部指定
        return key;
    }
}

memadamkan Mekanisme penyingkiran: Jenis dalam akan dipadamkan semasa penyusunan, jadi perkara dalam tidak akan mengambil bahagian dalam komposisi jenis. Akan memadamkan T sebagai Objek.

Mengapa tatasusunan jenis generik tidak boleh dijadikan instantiated?

Perbezaan penting antara tatasusunan dan generik ialah cara mereka menguatkuasakan semakan jenis. Tatasusunan menyimpan dan menyemak maklumat jenis semasa runtime, manakala generik menyemak ralat jenis pada masa penyusunan.

Tatasusunan Objek yang dikembalikan boleh menyimpan sebarang jenis data, seperti rentetan, yang diterima melalui tatasusunan jenis int Pengkompil menganggapnya tidak selamat.

3. Sempadan atas generik

Sintaks:

nama kelas generik kelas{

}

Contoh:

kelas awam MyArray{} //E hanya boleh menjadi Nombor atau subkelas Nombor

kelas awam MyArray>{}

//E mestilah kelas yang melaksanakan antara muka Sebanding

[Nota] E tanpa sempadan tertentu boleh dilihat Jadikan E melanjutkan Objek

4. Watak kad bebas

? Untuk kegunaan dalam generik, ia adalah kad bebas. Kad bebas digunakan untuk menyelesaikan masalah bahawa jenis anti-generik tidak boleh menjadi kovarian.

Dua keping kod berikut:

代码一：
public static<T> void printList1(ArrayList<T> list){
   for(T x:list){
      System.out.println(x);
   }
}
 
代码二：
public static<T> void printList2(ArrayList<?> list){
   for(Object x:list){
      System.out.println(x);
   }
}

Kad liar digunakan dalam kod 2. Berbanding dengan kod 1, kami tidak tahu jenis data khusus yang dihantar ke kod 1 pada masa ini daripada.

(1) Batas atas kad bebas

Sintaks:

/Jenis parameter sebenar yang boleh dihantar ialah Nombor atau subkelas Nombor

Contoh: Untuk perhubungan berikut, kita perlu menulis kaedah untuk mencetak senarai yang menyimpan subkelas Haiwan atau Haiwan.

Haiwan

Kucing memanjangkan Haiwan

Anjing memanjangkan Haiwan

Kod 1:

Pada masa ini jenis T ialah Subkelas haiwan atau diri sendiri.

public static <t extends Animal> void print1(List<T> list>{
    for(T animal:list){
        System.out.println(animal);//调用了T的toString
    }
}

Kod 2: Melaksanakan

melalui kad bebas Perbezaan antara dua kod:

public static void print2(List<? extends Animal> list){
    for(Animal animal:list){
       Syatem.out.println(animal);//调用了子类的toString方法
    }
}

Untuk kaedah pelaksanaan generik, mengenakan sekatan ke atas T, yang hanya boleh menjadi subkelas Haiwan. Masuk Kucing, itu Kucing.

• Untuk kaedah yang dilaksanakan oleh kad bebas, ia bersamaan dengan menetapkan Haiwan dan membenarkan subkelas Haiwan dihantar masuk. Subkategori khusus tidak jelas pada masa ini. Contohnya: apabila Cat dihantar masuk, jenis yang diisytiharkan ialah Haiwan Hanya dengan menggunakan polimorfisme kaedah Cat boleh dipanggil

• hubungan kelas induk-anak & rarr; 🎜>

//Anda perlu menggunakan kad bebas untuk menentukan jenis ibu bapa dan anak

MyArrayList ialah kelas induk MyArrayList >

MyArrayList> adakah MyArrayList< ;? melanjutkan kelas induk Number>

[Nota]

 ArrayList<Integer> arrayList1 = new ArrayList<>();
 ArrayList<Double> arrayList2 = new ArrayList<>();
 List<? extends Number> list = arrayList1;
 //list.add(1,1);//报错，此时list的引用的子类对象有很多，再添加的时候，任何子类型都可以，为了安全，java不让这样进行添加操作。
 Number a = list.get(0);//可以通过
 Integer i = list.get(0);//编译错误，只能确定是Number子类

tidak boleh ditambah , dan senarai yang disimpan mungkin Nombor atau Ia adalah subkelas Nombor dan jenisnya tidak dapat ditentukan.

• Sempadan atas kad bebas sesuai untuk membaca tetapi bukan untuk menulis.

• (2) Sempadan bawah kad bebas
  Sintaks:

< ; ? super Integer>//Jenis parameter yang boleh dihantar ialah Integer atau kelas induk Integer

Hubungan kelas induk-anak bagi sempadan bawah kad bebas:

MyArrayList super Integer>是MyArrayList的父类类型

MyArrayList是MyArrayList super Integer>的父类

通配符下界适合写入元素，不适合读取。

5、包装类

在Java中，由于基本类型不是继承自Object，为了在泛型中可以支持基本类型，每个基本类型都对应了一个包装类。除了Integer和Character，其余基本类型的包装类都是首字母大写。

拆箱和装箱：

int i=10;
 
//装箱操作，新建一个Integer类型对象，将i的值放入对象的某个属性中
Integer ii=i;  //自动装箱
//Integer ii=Integer.valueOf(i);
Integer ij= new Integer(i);//显示装箱
 
//拆箱操作，将Integer对象中的值取出，放到一个基本数据类型中
int j=ii.intValue();//显示的拆箱
int jj=ii;//隐式的拆箱

Atas ialah kandungan terperinci Generik Java dan analisis contoh kelas pembalut. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!