泛型概述

• 泛型就是一个标签：<数据类型>
• 泛型可以在编译阶段结束，只能操作某种数据类型
• 泛型和集合都智能支持引用数据类型，不支持基本数据类型

泛型的好处

• 泛型在编译阶段约束了操作的数据类型，从而不会出现类型转换异常；
• 体现的是Java的严谨性和规范性。

自定义泛型类

• 泛型类的格式

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

      }

• 泛型变量建议使用E、T、K、V
• 需求：模拟ArrayList集合定义一个自己的集合MyArrayList

public class GenericDemo{
    public static void main(String[] args){
        MyArrayList<String> lists = new MyArrayList<>();
        lists.add(1);  //这里会报错
        lists.delete("hello");
    }
}

class MyArrayList<E>{
    public void add(E e){
        
    }
    public void delete(E e){
        
    }
}

自定义泛型方法

• 泛型方法的定义格式:

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

• 泛型类的核心思想：是把出现泛型变量的地方全部替换成传输的真实数据类型

泛型接口

• 泛型接口的格式：

    修饰符  interface  接口名称<泛型变量>{
    }

• 泛型接口的核心思想，在实现接口的时候传入真实的数据类型；
• 这样重写的方法就是对该数据的类型进行操作。

// 泛型接口
public interface Date<E>{
    void add(E stu);
    void delete(E stu);
    void update(E stu);
    E query(int id);
}
// Stuent类
public class Student{
}
// 接口实现
public class StudentData implements Data<Student>{
    @Override
    public void add(Student stu){System.out.println("添加学生");}
    @Override
    public void delete(Student stu) {
        System.out.println("删除学生！");
    }
    @Override
    public void update(Student stu) {
    }
    @Override
    public Student query(int id) {
        return null;
    }
}
// 主方法
public class GenericDemo {
    public static void main(String[] args) {
        StudentData data = new StudentData();
        data.add(new Student());
        data.delete(new Student());
    }
}

泛型的通配符

• 默认情况下，泛型不存在继承关系，例如如下代码

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

        // 这两个类送进去都会报错
        ArrayList<BMW> bmws = new ArrayList<>();
        bmws.add(new BMW());
        bmws.add(new BMW());
        bmws.add(new BMW());
        run(bmws);
        ArrayList<BENZ> benzs = new ArrayList<>();
        benzs.add(new BENZ());
        benzs.add(new BENZ());
        benzs.add(new BENZ());
        run(benzs);
    }

    // 定义一个方法，可以让很多汽车一起进入参加比赛
    public static void run(ArrayList<Car> cars){

    }
}
class Car{
}
class BMW extends Car{
}
class BENZ extends Car{
}

• 本意上，代码编写者认为，既然BMW和BENZ类都继承了Car类。那么，在run方法中，直觉上会完成一个向上转型。但是，由于泛型不存在继承关系，所以这样写法并不成立。
• Java中为了解决这个问题，引入了泛型通配符的概念

通配符: ？

• ？可以在使用泛型的时候代表一切类型，注意这里的措辞是使用泛型的时候
• ? extends class A：？必须是A或者其子类（泛型的上限）
• ？super class A：？必须是A或者其父类（泛型的下限）

public class GenericDemo{
    public static void main(String[] args){
        ArrayList<BMW> bmws = new ArrayList<>();
        bmws.add(new BMW());
        bmws.add(new BMW());
        bmws.add(new BMW());
        run(bmws);

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

        ArrayList<Dog> dogs = new ArrayList<>();
        dogs.add(new Dog());
        dogs.add(new Dog());
        dogs.add(new Dog());
        // run(dogs); // 就进不来了！
    }
    // 定义一个方法，可以让很多汽车一起进入参加比赛
    public static void run(ArrayList<? extends Car> cars){

    }
}
class Car{
}
class BMW extends Car{
}
class BENZ extends Car{
}
class Dog{
}