面向对象高级之 泛型

1.泛型是什么

定义类、接口、方法时，同时声明了一个或者多个类型变量如<E>，称为泛型类、泛型接口、泛型方法，统称为泛型

比如ArrayList就是一个泛型类

public class test {
    public static void main(String[] args) {
        // 目标：认识泛型
        ArrayList list = new ArrayList();// 泛型类型为Object
        list.add("java1");
        list.add("java2");
        list.add("java3");
        //list.add(new Cat());// 编译错误，不能添加Cat类型

        for (int i = 0; i < list.size(); i++) {
            String e = (String) list.get(i);//强制类型转换不能输出cat
            System.out.println(e);// 只能输出java1、java2、java3
        }
    }
}

class Cat {
}

System.out.println("------------------------------");
 ArrayList<String> list1 = new ArrayList<String>();// 泛型类型为String
 list1.add("java1");
 list1.add("java2");
 list1.add("java3");
// list1.add(new Cat()); // 错误，因为列表只能存储字符串

2.泛型接口

新建一个接口，根据传进来的名字进行分类，Student和Teacher分开

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

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

    }

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

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

    }

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

3.泛型方法

public class test {
    public static void main(String[] args) {
        // 目标：掌握泛型方法的定义和使用。
        test("java");
        dog d = test(new dog());
        System.out.println(d);
    }

    // 泛型方法,返回值为T类型，所以上边test方法可以输入任何类型的参数，并返回该参数。
    public static <T> T test(T t) {
        return t;
    }
}

案例

package com.lzk.test;

import java.util.ArrayList;

public class test {
    public void main(String[] args) {
        // 需求：所有的汽车可以一起参加比赛。
    }

    class Car {
        // Car 类的定义
    }

    class BMW  extends Car{
        // BMW 类的定义
    }

    class BENZ extends Car {
        // BENZ 类的定义
    }

    class Dog {
        // Dog 类的定义
    }

    public class Test {
        public 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);

            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); // 错误，因为 Dog 不是 Car 的子类
        }
       //        public static <Car> void go(ArrayList<Car> cars) {
//
//        }
        public static void go(ArrayList<? extends Car> cars) {// ?代表通配符，可以接收任何Car的子类
                            // ? super Car 代表可以接收任何Car的父类，下限
            //?extends Car 代表可以接收任何Car的子类，上限
        }

//        public static <T extends Car> void go(ArrayList<T> cars) {
//            // 比赛逻辑，这里暂时不做具体实现
//            System.out.println("比赛开始，车辆数量：" + cars.size());
//        }


    }

}

4.泛型的注意事项，擦除问题，基本数据类型问题

public class test {
    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);

        // 2. 泛型不支持基本数据类型，只能支持对象类型（引用数据类型）。
        // ArrayList<int> list1 = new ArrayList<>(); // 错误：不能使用基本数据类型
        // ArrayList<double> list2 = new ArrayList<>(); // 错误：不能使用基本数据类型

        ArrayList<Integer> list1 = new ArrayList<>();
        list1.add(12);

        ArrayList<Double> list2 = new ArrayList<>();//这两个以后再说
        list2.add(23.3);
    }
}