Java_泛型_15

泛型

概述

1. 什么是泛型？
   泛型就是一个标签：<数据类型>
   泛型可以在编译阶段约束只能操作某种数据类型。
   注意：JDK 1.7开始之后，泛型后面的申明可以省略不写!!
   泛型和集合都只能支持引用数据类型，不支持基本数据类型。

2. 小结：
   泛型可以在编译阶段约束只能操作某种数据类型。
   泛型和集合都只能支持引用数据类型，不支持基本数据类型。
   JDK 1.7开始之后，泛型后面的申明可以省略不写!!

public class GenericityDemo {
    public static void main(String[] args) {
        //ArrayList<String> lists = new ArrayList<String>();
        ArrayList<String> lists = new ArrayList<>(); // JDK 1.7开始之后，泛型后面的申明可以省略不写!!
        lists.add("Java");
        lists.add("MySQL");
//      lists.add(false);
//      lists.add(99.9);
//      lists.add('a');
        System.out.println(lists);

        ArrayList<Integer> lists1 = new ArrayList<>();
        lists1.add(10);
        lists1.add(20);
        System.out.println(lists1);
    }
}

优势

这泛型在编译阶段约束了操作的数据类型，从而不会出现类型转换异常。
体现的是Java的严谨性和规范性，数据类型,经常需要进行统一！

	public class GenericityDemo {
    public static void main(String[] args) {
        ArrayList<String> lists = new ArrayList<>();
        lists.add("赵敏");
        lists.add("张无忌");
//        lists.add(false);  //不定义<>打印会报错
//        lists.add(99.9);

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

自定义泛型类

1. 引入：
   我们之前用的泛型都是别人写好的，接下来我们来自定义泛型类使用。

2. 泛型类的概念：
   使用了泛型定义的类就是泛型类。

3. 泛型类的格式：
   修饰符 class 类名<泛型变量>{

   }
   泛型变量建议使用 E , T , K , V

4. 需求：模拟ArrayList集合自定义一个集合MyArrayList集合。
   泛型类的核心思想：是把出现泛型变量的地方全部替换成传输的真实数据类型。

5. 小结：
   自定义泛型的核心思想：是把出现泛型变量的地方全部替换成传输的真实数据类型。

public class GenericDemo {
    public static void main(String[] args) {
        MyArrayList<String> lists = new MyArrayList<String>();

        MyArrayList<String> lists1 = new MyArrayList<>();
        lists1.add("java");
        lists1.add("mysql");
        lists1.remove("java");
        System.out.println(lists1);
    }
}

class MyArrayList<E>{  //自定义泛型类  需要的类型全为E!!!!

    private ArrayList lists = new ArrayList();

    public void add(E e){
        lists.add(e);
    }

    public void remove(E e){
        lists.remove(e);
    }
    @Override
    public String toString() {
        return lists.toString();
    }
}

自定义泛型方法

1. 什么是泛型方法？
   定义了泛型的方法就是泛型方法。

2. 泛型方法的定义格式:
   修饰符 <泛型变量> 返回值类型 方法名称(形参列表){ }
   注意：方法定义了是什么泛型变量，后面就只能用什么泛型变量。

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

4. 需求：给你任何一个类型的数组，都能返回它的内容。

5. 小结：
   泛型方法和泛型类可以做通用技术架构。

public class GenericDemo {
    public static void main(String[] args) {
        Integer[] nums = {10 , 20 , 30 , 40 , 50};
        String rs1  = arrToString(nums);
        System.out.println(rs1);

        String[] names = {"贾乃亮","王宝绿","陈羽凡"};
        String rs2  = arrToString(names);
        System.out.println(rs2);
    }
//T可以传任何类型，即实现了通用性。
    public static <T> String arrToString(T[] nums){
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        if(nums!=null && nums.length > 0){
            for(int i = 0 ; i < nums.length ; i++ ){
                T ele = nums[i];
                sb.append(i == nums.length-1 ? ele : ele+", ");
            }
        }
        sb.append("]");
        return sb.toString();
    }
}

泛型接口的使用

1. 什么是泛型接口？
   使用了泛型定义的接口就是泛型接口。

2. 泛型接口的格式：
   修饰符 interface 接口名称<泛型变量>{ }

3. 需求:教务系统，提供一个接口可约束一定要完成数据（学生，老师）的增删改查操作

4. 小结：
   泛型接口的核心思想，在实现接口的时候传入真实的数据类型
   这样重写的方法就是对该数据类型进行操作!

1.创建Data泛型接口

public interface Data<E> {
    void add(E stu);
    void delete(E stu);
    void update(E stu);
    E query(int id);
}

2.Teacher类继承泛型接口并重写方法

public class TeacherData implements Data<Teacher> {
    @Override
    public void add(Teacher stu) {
        System.out.println("添加老师！");
    }
    @Override
    public void delete(Teacher stu) {
        System.out.println("删除老师！");
    }
    @Override
    public void update(Teacher stu) {
    }
    @Override
    public Teacher query(int id) {
        return null;
    }
}

3.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;
    }
}

4.main调用

public class GenericDemo {
    public static void main(String[] args) {
        StudentData data = new StudentData();
        data.add(new Student());
        data.delete(new Student());

        TeacherData data1 = new TeacherData();
        data1.add(new Teacher());
        data1.delete(new Teacher());
    }
}

通配符和上下限

1. 需求：开发一个极品飞车的游戏，所有的汽车都能一起参与比赛。

2. 注意：
   虽然BMW和BENZ都继承了Car
   但是ArrayList和ArrayList与ArrayList没有关系的！泛型没有继承关系！

3. 通配符：？
   ?可以用在使用泛型的时候代表一切类型。
   E , T , K , V是在定义泛型的时候使用代表一切类型。

4. 泛型的上下限：
   ? extends Car : 那么?必须是Car或者其子类。(泛型的上限)
   ? super Car :那么?必须是Car或者其父类。（泛型的下限。不是很常见）

5. 小结：
   通配符：?可以用在使用泛型的时候代表一切类型。
   ? extends Car : 那么?必须是Car或者其子类。(泛型的上限)

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{}