Java开发从入门到精通（二十）：Java的面向对象编程OOP：泛型

（一）Java的泛型

1.1 泛型的认识

泛型的概念

• 定义类、接口、方法时，同时声明了一个或者多个类型变量(如:) 称为泛型类、泛型接口，泛型方法、它们统称为泛型。

泛型的作用:

• 泛型提供了在编译阶段约束所能操作的数据类型，并自动进行检查的能力!这样可以避免强制类型转换，及其可能出现的异常。

泛型的本质:

• 把具体的数据类型作为参数传给类型变量。

import java.util.ArrayList;

public class Test1 {
    public static void main(String[] args) {
        // 目标:认识泛型
        ArrayList list = new ArrayList();
        list.add("java1");
        list.add("java2");
        list.add("java3");
        list.add(new Cat());

        for(int i=0;i<list.size();i++) {
            String e = (String) list.get(i);
            System.out.println(e);
        }
		//声明泛型
        //ArrayList<String> list1 =new ArrayList<String>();
        ArrayList<String> list1 = new ArrayList<>();// JDK 1.7开始，后面的数据类型可以不声明List1.add("java1");
        list1.add("java2");
        list1.add("java3");
        // list1.add(new Cat());

        for(int i=0;i<list1.size();i++){
            String e= list1.get(i);
            System.out.println(e);
        }

    }
}

class Cat{}

1.2 自定义泛型类

泛型类

public class Test1 {
    public static void main(String[] args) {
        // 目标:掌握泛型类的定义和使用
        MyArrayList<String> list = new MyArrayList<>();
        list.add("java1");
        list.add("java2");
        String ele = list.get(1);
        System.out.println(ele);

        MyClass2<Cat,String>c2=new MyClass2<>();
        MyClass3<Animal> c3 =new MyClass3<>();
        MyClass3<Dog> c4 = new MyClass3<>();
    }


}

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

}

public class MyClass3<E extends Animal>{

}

1.2 自定义泛型接口

• 注意:类型变量建议用大写的英文字母，常用的有: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;
    }
}

import java.util.ArrayList;

public class StudentData implements Data<Student>{
    @Override
    public void add(Student student) {
        
    }

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

public interface Data<T extends Anmial>{
    void add(T t);

    ArrayList<T> getByName(String name);
}

public class StudentData implements Data<Anmial>{
    @Override
    public void add(Cat Cat) {
        
    }

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

1.2 自定义泛型方法

图中的E是类给它的，不是自己声明的所以是X，只有自己声明的才是泛型方法

import java.util.ArrayList;

public class Test1 {
    public static void main(String[] args) {

        // 目标:掌握泛型方法的定义和使用。
        String rs= test( "java");
        System.out.println(rs);
        Dog d=test(new Dog());
        System.out.println(d);

        // 需求:所有的汽车可以一起参加比赛。
        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);

        ArrayList<BENZ> benzs = new ArrayList<>();
        benzs.add(new BENZ());
        benzs.add(new BENZ());
        go(benzs);

        ArrayList<Dog> dogs = new ArrayList<>();
        dogs.add(new Dog());
        dogs.add(new Dog());
        go(dogs);
    }
    //!?通配符，在使用泛型的时候可以代表一切类型
    public static void go(ArrayList<? extends Car> cars){

    }
//    public static <T extends Car> void go(ArrayList<T> cars) {
//
//    }
    // 泛型方法
    public static <T> T test(T t){
        return t;
    }
}

public class Car {

}

public class BMW extends Car{
}

public class BENZ extends Car{
}

1.5 泛型通配符

通配符，在使用泛型的时候可以代表一切类型
通配符
就是“?”，可以在“使用泛型”的时候代表一切类型; ETKV是在定义泛型的时候使用。

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

1.6 上下限

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

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

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

1.7 泛型的擦除问题和注意事项

泛型是工作在编译阶段的，一旦程序编译成class文件，class文件中就不存在泛型了，这就是泛型擦除。
泛型不支持基本数据类型，只能支持对象类型(引用数据类型)。

import java.util.ArrayList;

public class Test1 {
    public static void main(String[] args) {
        // 目标:理解泛型的注意事项。//1、泛型是工作在编译阶段的，一旦程序编译成class文件，class文件
        ArrayList<String> list = new ArrayList<>();
        list.add("java1");
        list.add("java2");
        list.add("java3");
        String rs = list.get(2);
        System.out.println(rs);
        //泛型不支持基本数据类型，只能支持对象类型(引用数据类型)。
        ArrayList<int> list1 = new ArrayList<>();  //报错
        ArrayList<double> list2 = new Arraylist<>();//报错
    }
}