java的泛型-CSDN博客

本文链接：https://blog.csdn.net/nextstation12138/article/details/146417934

定义类、接口、方法时，同时声明了一个或者多个类型变量（如：），称为泛型类、泛型接口，泛型方法、它们统称为泛型
作用：泛型提供了在编译阶段约束所能操作的数据类型，并自动进行检查的能力！这样可以避免强制类型转换，及其可能出现的异常。
泛型的本质：把具体的数据类型作为参数传给类型变量。

1.泛型类

写法

修饰符 class 类名<类型变量，类型变量，…> { 

}

注意：类型变量建议用大写的英文字母，常用的有：E、T、K、V 等

例子

第一种形式：

public class MyArrayList<E> {
    private Object[] arr = new Object[10];
    private int size;

    public boolean add(E e){
        arr[size++] = e;
        return true;
    }

    public E get(int index){
        return (E) arr[index];
    }
}

第二种形式：

public class MyClass2<E, T> {
    public void put(E e, T t){

    }
}

第三种形式：

public class MyClass3<E extends Animal> {

}

2.泛型接口

写法

修饰符 interface 接口名<类型变量，类型变量，…> { 

}

注意：类型变量建议用大写的英文字母，常用的有：E、T、K、V 等

例子

第一种形式：

public interface Data<T> {
    void add(T t);
    ArrayList<T> getByName(String name);
}

public class TeacherData implements Data<Teacher>{
    @Override
    public void add(Teacher teacher) {

    }

    @Override
    public ArrayList<Teacher> getByName(String name) {
        return null;
    }
}

第二种形式：

public interface Data<T extends Animal> {
    void add(T t);
    ArrayList<T> getByName(String name);
}

public class CatData implements Data<Cat>{
    @Override
    public void add(Cat cat) {

    }

    @Override
    public ArrayList<Cat> getByName(String name) {
        return null;
    }
}

3.泛型方法

写法

修饰符 <类型变量，类型变量，…>  返回值类型 方法名(形参列表) { 

}

- 通配符

就是 “?” ，可以在“使用泛型”的时候代表一切类型； E T K V 是在定义泛型的时候使用。

- 泛型的上下限

泛型上限: ? extends Car: ? 能接收的必须是Car或者其子类。
泛型下限： ? super Car ： ? 能接收的必须是Car或者其父类。

例子

自定义泛型的第一种形式：

public class Test {
    public static void main(String[] args) {
        String rs = test("java");
        System.out.println(rs);

        Dog d = test(new Dog());
        System.out.println(d);
    }

    public static <T> T test(T t){
        return t;
    }
}

以下代码，定义了一个静态方法，参数是泛型类且约束了泛型为Car，如果我们传入的参数的泛型不是Car，而是Car的子类，编译会报错。如果要把go方法的参数泛型约束为Car或car的子类，有两种写法。

public class Test {
    public static void main(String[] args) {
        ArrayList<Car> cars= new ArrayList<>();
        cars.add(new BMW());
        cars.add(new BENZ());
        go(cars);
        
        ArrayList<BMW> bmws = new ArrayList<>();
        bmws.add(new BMW());
        bmws.add(new BMW());
        go(bmws);   // 报错
    }
    
    public static void go(ArrayList<Car> cars){

    }
}

第一种解决办法：将go方法改造成泛型方法

public class Test {
    public static void main(String[] args) {
        ArrayList<Car> cars= new ArrayList<>();
        cars.add(new BMW());
        cars.add(new BENZ());
        go(cars);

        ArrayList<BMW> bmws = new ArrayList<>();
        bmws.add(new BMW());
        bmws.add(new BMW());
        go(bmws);  
    }

    public static <T extends Car> void go(ArrayList<T> cars){

    }
}

第二种解决办法：使用泛型类ArrayList时使用泛型通配符“?”

public class Test {
    public static void main(String[] args) {
        ArrayList<Car> cars= new ArrayList<>();
        cars.add(new BMW());
        cars.add(new BENZ());
        go(cars);

        ArrayList<BMW> bmws = new ArrayList<>();
        bmws.add(new BMW());
        bmws.add(new BMW());
        go(bmws);
    }

    public static void go(ArrayList<? extends Car> cars){

    }
}