Java基础（十七）：泛型Generic

一、泛型

1. 泛型介绍：
   1）在类声明或者实例化指明类型即可
   2）泛型的作用是：类声明时通过一个标识表示类中属性的类型、某个方法的返回值类型或者参数类型
2. 泛型的语法：
   1）泛型的声明：其中T、K、V只能是引用类型
   interface 接口< T >{}
   class 类<K,V,…>{}
   2）泛型的实例化：类名后指明类型
3. 使用泛型的好处？
   1）编译时，检查添加元素的类型，提高安全性
   2）减少了类型转换的次数，提高效率

public class Generic01 {
    public static void main(String[] args) {
        //1.使用方式
        HashMap<String, Student> map = new HashMap<>();
        map.put("计算机",new Student("li",18));
        map.put("音乐",new Student("wang",18));
        Set entrySet = map.entrySet();
        Iterator<Map.Entry<String,Student>> iterator = entrySet.iterator();
        while(iterator.hasNext()){
            Map.Entry<String,Student> next = iterator.next();
            System.out.println(next.getKey()+ next.getValue());

        }
        //2.使用细节：
        //1）指定泛型类型后，也可传入该类型或其子类型
        Dog<A> aDog = new Dog<A>(new A());
        Dog<A> aDog1 = new Dog<A>(new B());

        //2)只能是引用类型,不能是基本类型
        //Dog<int> intDog = new Dog<int>(12);

        //3）泛型的使用形式
        //正常
        Dog<String> stringDog = new Dog<String>("名字");
        Dog<Integer> integerDog = new Dog<Integer>(12);
        //开发常用简写
        Dog<Integer> integerDog2 = new Dog<>(12);
        stringDog.show();
        integerDog.show();
        integerDog2.show();
    }
}
class A{}
class B extends A{}
class Dog<E>{
    E s;
    public Dog(E e){
        this.s = e;
    }
    public E f(){ return s;}
    public void show(){
        System.out.println(s.getClass());
    }
}
class Student{
    private String name;
    private int age;
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

二、自定义泛型

1. 自定义泛型类
   1）普通成员/属性/方法可以使用泛型
   2）使用泛型的数组，不能初始化
   3）静态方法/属性中不能使用类的泛型
   4）泛型类的类型，是在创建对象时确定的(因为创建对象时需要指定确定类型)
   5）如果在创建对象时，没有指定类型，默认为Object
2. 自定义泛型接口：泛型接口的的类型在继承或实现接口时确定
3. 自定义泛型方法
   1）泛型方法，可以定义在普通类中,也可以定义在泛型类中
   2）当泛型方法被调用时，类型会确定
   3）public void eat(E e)，修饰符后没有<T,R…> eat方法不是泛型方法，而是使用了泛型
   4）泛型方法不仅可以使用自己泛型，还可以类声明的泛型

public class Genegric03 {
    public static void main(String[] args) {
        //调用方法传入参数时，编译器就会确定类型
        new Genegric03().run("宝马",12);
    }
    //三、自定义泛型方法
    public <T,R>void run(T t,R r){
        System.out.println(t + " " + r);
    }
}
//一、自定义泛型类
class Tiger<T,R,M>{
    String name;
    T t;
    R r;
    M m;
    //1.泛型数组不能初始化：因为new不能确定T的类型就无法开辟内存
    //T[] ts = new T[8];
    //2.静态方法/属性不能使用泛型，因为静态在类加载时创建，无法开辟
    //public static void f1(M m){}
    //static R r1;
    public Tiger(String name, T t, R r, M m) {
        this.name = name;
        this.t = t;
        this.r = r;
        this.m = m;
    }
}
//二、自定义泛型接口
interface IUsb<U,R>{
    //U name;不能这样使用，静态成员
    R get(U u);
    void hi(R r);
    void run(R r1,R r2,U u1,U u2);
    default R method(U u){
        return null;
    }
}
//1.继承接口
interface IA extends IUsb<String,Double>{}
class AA implements IA{
    @Override
    public Double get(String s) {
        return null;
    }
    @Override
    public void hi(Double aDouble) {}
    @Override
    public void run(Double r1, Double r2, String u1, String u2) {}
}
//2.实现接口
class BB implements IUsb<Integer,Float>{
    @Override
    public Float get(Integer integer) {
        return null;
    }
    @Override
    public void hi(Float aFloat) {}
    @Override
    public void run(Float r1, Float r2, Integer u1, Integer u2) {}
}

三、泛型的继承和通配符

1）泛型不具备继承性 List list = new ArrayList< String >(): // 错
2）<?> : 支持任意泛型类型
3）<? extends A>: 支持A类以及A类的子类，规定了泛型的上限
4）<? super A>: 支持A类以及A类的父类，不限于直接父类，规定了泛型的下限

特别说明
本文章是个人整理的学习笔记，参考b站韩顺平老师的课程（【零基础 快速学Java】韩顺平 零基础30天学会Java）。老师讲的非常好，有兴趣的可以去看一下。