【数据结构】泛型

1.什么是泛型

一般的类和方法，使用的要不是具体的类型，或者是自定义的类型，这会使代码变得十分”固化“。

而泛型是JDK1.5引用的新的语法，它可以适用于许多的类型。

2.引出泛型

所有类的父亲都是Object类，是否可以用Object类数组实现承载多个类型的目的

class MyArray {
    public Object[] array = new Object[10];
    
    public Object getPos(int pos) {
        return this.array[pos];
   }
    public void setVal(int pos,Object val) {
        this.array[pos] = val;
   }
}
 
public class TestDemo {
    public static void main(String[] args) {
        MyArray myArray = new MyArray();
        myArray.setVal(0,10);
        myArray.setVal(1,"hello");//字符串也可以存放
        String ret = myArray.getPos(1);//编译报错
        System.out.println(ret);
   }
}

通过上面代码发现Object类型数组确实能存储多类型数据，但是在原本存放在1号下标的字符串却编译报错，必须进行强制类型转换。

虽然当前任何数据都能存放，但是，更多情况下它只能够持有一种数据类型，而不是同时持有这么多类型，所以，泛型的主要目的：就是指定当前的容器，要持有什么类型的对象。让编译器去做检查，需要什么类型就传什么类型就行。

2.1语法

class MyArray<T> {
    public Object[] array =  new Object[10];
 
    public T getPos(int pos) {
        return (T)this.array[pos];
   }
    public void setVal(int pos,T val) {
        this.array[pos] = val;
   }
}
public class TestDemo {
    public static void main(String[] args) {
        MyArray<Integer> myArray = new MyArray<>();//1
        myArray.setVal(0,10);
        myArray.setVal(1,12);
        int ret = myArray.getPos(1);//2
        System.out.println(ret);
        myArray.setVal(2,"bit");//3
   }
}

1. 类名后的 代表占位符，表示当前类是一个泛型类

2. 注释1处，类型后加入 指定当前类型

3. 注释2处，不需要进行强制类型转换

4. 注释3处，代码编译报错，此时因为在注释2处指定类当前的类型，此时在注释3处，编译器会在存放元素的时 候帮助我们进行类型检查。

了解： 【规范】类型形参一般使用一个大写字母表示，常用的名称有：

• E 表示 Element

• K 表示 Key

• V 表示 Value

• N 表示 Number

• T 表示 Type

• S, U, V 等等 - 第二、第三、第四个类型

3.泛型类的使用

3.1语法

MyArray<Integer> list = new MyArray<Integer>();

注意：泛型只能接受类，所有的基本数据类型必须使用包装类！

MyArray<Integer> list = new MyArray<>(); 

注意：当编译器可以根据上下文推导出类型实参时，可以省略类型实参的填写

3.2优点

• 数据类型参数化

• 编译时自动进行类型检查和转换

4.裸类型

就是一个泛型类没有带着类型实参

MyArray list = new MyArray();

注意：不要使用裸类型

5.泛型如何编译的

擦除机制：Java的泛型机制是在编译级别实现的。编译器生成的字节码在运行期间并不包含泛型的类型信息。

（在编译的过程当中，将所有的T替换为Object这种机制，我们称为：擦除机制。）

6.泛型的上界

用继承对传入的类型变量做的约束。

6.1语法

public class MyArray<E extends Number> {
}
​

传入的数据类型只能是Number本身或者是其子类

MyArray<Integer> l1; // 正常，因为 Integer 是 Number 的子类型
MyArray<String> l2; // 编译错误，因为 String 不是 Number 的子类型

6.2示例

public class MyArra<E extends Comparable<E>>{
}

E必 须 是 实 现 了 C o m p a r a ble 接 口 的

7.泛型方法

7.1定义语法

//静态的泛型方法 需要在static后用<>声明泛型类型参数
public static <E> void swap(E[] array,int i,int j){
}

8.通配符

 class Message<T> {
    private T message ;
 
    public T getMessage() {
    return message;
 }
 
    public void setMessage(T message) {
    this.message = message;
    } 
 
}
 
public class TestDemo {
    public static void main(String[] args) {
    Message<String> message = new Message<>() ; 
    message.setMessage("比特就业课欢迎您");
    fun(message);
 }
public static void fun(Message<String> temp){
     System.out.println(temp.getMessage());
    }
}
​

如果泛型的类型不是String，而是Integer，fun方法将无法通过编译。

我们需要的解决方案：可以接收所有的泛型类型，但是又不能够让用户随意修改。这种情况就需要使用通配符"?"来处理

// 此时使用通配符"?"描述的是它可以接收任意类型，但是由于不确定类型，所以无法修改
public static void fun(Message<?> temp){
    //temp.setMessage(100); 无法修改！
    System.out.println(temp.getMessage());
    }
}
​

8.2通配符上界

语法

<? extends 上界>
<? extends Number>//可以传入的实参类型是Number或者Number的子类

class Food {
 
}
class Fruit extends Food {
​
}
class Apple extends Fruit {
 
}
class Banana extends Fruit {
 
}
class Message<T> { // 设置泛型
    private T message ;
 
public T getMessage() {
     return message;
}
 
public void setMessage(T message) {
     this.message = message;
    }
}
 
public class TestDemo {
    public static void main(String[] args) {
        Message<Apple> message = new Message<>() ;
        message.setMessage(new Apple());
        fun(message);
 
        Message<Banana> message2 = new Message<>() ;
        message2.setMessage(new Banana());
        fun(message2);
}
 // 此时使用通配符"?"描述的是它可以接收任意类型，但是由于不确定类型，所以无法修改
public static void fun(Message<? extends Fruit> temp){
    //temp.setMessage(new Banana()); //仍然无法修改！
    //temp.setMessage(new Apple()); //仍然无法修改！
     Fruit fruit = message3.getMessage();
    }
}

<? extends Fruit>表示泛型的类型为Fruit或其子类，因为不知道类型所以不能修改，但通配符上界为Fruit，所以接受可以统一为Fruit类型。

通配符的上界，不能进行写入数据，只能进行读取数据。

8.3通配符下界

语法：

<? super 下界>
<? super Integer>//代表 可以传入的实参的类型是Integer或者Integer的父类类型

public static void fun(Plate<? super Fruit> temp){
    // 此时可以修改！！添加的是Fruit 或者Fruit的子类
    temp.setPlate(new Apple());//这个是Fruit的子类
    temp.setPlate(new Fruit());//这个是Fruit的本身
    //Fruit fruit = temp.getPlate(); 不能接收，这里无法确定是哪个父类
    System.out.println(temp.getPlate());//只能直接输出
    }
}

<? super Fruit>表示泛型的类型为Fruit或其父类，所以可以修改Fruit或其子类类型的数据，相反不知到类型上界无法接收。

通配符的下界，不能进行读取数据，只能写入数据。