Java基础之泛型

泛型介绍

灵感不过是顽强的劳动而获得的奖赏！

1.泛型又称参数化类型，是jdk5.0出现的新特性，解决数据类型安全性的问题。
2.在类声明或实例化时只要指定好需要的具体的类型即可
3.Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会发出ClassCastException异常。同时代码更加简洁，健壮。
4.泛型的作用是：可以在类声明时通过一个标识表示类中某个属性的类型，或者是某个方法的返回值类型，或者是参数类型

泛型语法和使用细节

1.interface list{} public class HashSet{}…等等
说明：T,E只能是引用类型
看看下面语句是否正确？：
List list = new ArrayList();//ok
List list = new ArrayList();//错误
2.在给泛型指定具体类型后，可以传入该类型或者其子类类型

 package com.hspedu.generic;

import java.util.ArrayList;
import java.util.List;

/**
 * @author 山河与you皆无恙
 */
@SuppressWarnings({"all"})
public class GenericDetail {
    public static void main(String[] args) {
        //1.给泛型指向数据类型时，要求是引用数据类型，不能是基本数据类型
        List<Integer> list = new ArrayList<Integer>();//ok
        //List<int> list = new ArrayList<int>();//错误

        //2.因为 E 指定了 A 类型，构造器传入了 new A()
        Pig<A> aPig = new Pig<>(new A());
        aPig.f();
        Pig<A> bPig = new Pig<>(new B());
        bPig.f();

        //3.泛型的使用形式
        ArrayList<Integer> list1 = new ArrayList<Integer>();
        List<Integer> list2 = new ArrayList<Integer>();
        //实际开发中，我们往往简写
        //编译器会进行类型推断
        ArrayList<Integer> list3 = new ArrayList<>();
        ArrayList<Integer> list4 = new ArrayList<>();

        ArrayList<Pig> pigs = new ArrayList<>();
        //4.如果是这样写 泛型默认是Object
        ArrayList arrayList = new ArrayList();//等价ArrayList<> arrayList = new ArrayList<>();

    }
}
class A{}
class B extends A{}

class Pig<E>{
    E e;

    public Pig(E e) {
        this.e = e;
    }

    public void f(){
        System.out.println(e.getClass());
    }
}
class Tiger<E> {
    E e;

    public Tiger(E e) {
        this.e = e;
    }

    public void f() {
        System.out.println(e.getClass());
    }
}

自定义泛型类

1.Tiger 后面泛型，所以我们把 Tiger 就称为自定义泛型类
2.T,R,M 泛型的标识符，一般是单个的的大写字母
3.泛型标识符可以有多个
4.普通成员可以使用泛型（属性，方法）
5.使用泛型的数组，不能初始化
6.静态方法中不能使用类的泛型

  package com.hspedu.customgeneric;

/**
 * @author 山河与you皆无恙
 */
public class CustomGeneric_ {
    public static void main(String[] args) {
       // T =Double M=Integer R=String
        Tiger<Double,String,Integer> g = new Tiger<>("john");
        g.setT(10.9);//ok
        //g.setT("yy");//错误 类型不对
        System.out.println(g);
        Tiger g2 = new Tiger("john");//ok,T=object,R=object,M=object
        g2.setT("yy");//ok,因为T=Object "yy"=String是Object子类
        System.out.println("g2"+g2);

    }
}
//1.Tiger 后面泛型，所以我们把 Tiger 就称为自定义泛型类
//2.T,R,M 泛型的标识符，一般是单个的的大写字母
//3.泛型标识符可以有多个
//4.普通成员可以使用泛型（属性，方法）
//5.使用泛型的数组，不能初始化
//6.静态方法中不能使用类的泛型
class Tiger<T,R,M>{
    String name;
    T t;
    R r;
    M m;
    //因为数组在new 不能确定T的类型，就无法在内存中开空间
    //T[] ts = new T[8];

    public Tiger(String name) {
        this.name = name;
    }

    public Tiger(T t, R r, M m) {
        this.t = t;
        this.r = r;
        this.m = m;
    }

    public Tiger(String name, T t, R r, M m) {//构造器使用泛型
        this.name = name;
        this.t = t;
        this.r = r;
        this.m = m;
    }
    //静态是和类相关的，在类加载时，对象还未创建
    //所以，如果是静态方法和静态属性使用了泛型，jvm 就无法完成初始化
//    String R r2;
//    public static void m1(M m){
//    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }

    public R getR() {
        return r;
    }

    public void setR(R r) {
        this.r = r;
    }

    public M getM() {
        return m;
    }

    public void setM(M m) {
        this.m = m;
    }
    @Override
    public String toString() {
        return "Tiger{" +
                "name='" + name + '\'' +
                ", t=" + t +
                ", r=" + r +
                ", m=" + m +
                '}';
    }
}

自定义泛型接口

• 注意细节
  1.接口中，静态成员也不能使用泛型(这个和泛型类规定一样)
  2.泛型接口的类型，在继承接口或者实现接口时确定
  3.没有指定类型，默认为Object

  package com.hspedu.customgeneric;

/**
 * @author 山河与you皆无恙
 */
public class CustomInterfaceGeneric {
    public static void main(String[] args) {

    }
}
//继承接口，指定泛型接口的类型
interface IA extends IUsb<String,Double>{

}
//当我们在实现IA接口时，因为IA在继承IUsb接口时，指定了 U为String,R为Double
//在实现IUsb接口的方法时，使用String替换U,Double替换R
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) {

    }
}
//实现接口时，直接指定泛型接口的类型
//给U指定Integer 给R指定Float
//所以，所以当我们实现IUsb方法时，会使用Integer替换U,使用Float替换R
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) {

    }
}
//没有指定类型，默认为Object
class CC implements IUsb{//等价class CC implements IUsb<Object,Object>{}

    @Override
    public Object get(Object o) {
        return null;
    }

    @Override
    public void hi(Object o) {

    }

    @Override
    public void run(Object r1, Object r2, Object u1, Object u2) {
   
  }
}
 interface IUsb<U,R>{
    //普通方法可以使用接口泛型
     int n = 10;
     R get(U u);
     void hi(R r);
     void run(R r1,R r2,U u1,U u2);
     //在jdk1.8中，可以在接口中可以使用默认方法,也是可以使用泛型
     default R method(U u){
         return null;
     }
 }

自定义泛型方法

1.泛型方法，可以定义在普通类中，也可以定义在泛型类中
2.泛型方法被调用时，类型会确定
3.public void Eat(E e){},修饰符后没有<T,R…>eat方法不是泛型方法，二十个使用了泛型

  package com.hspedu.customgeneric;

import java.util.ArrayList;

/**
 * @author 山河与you皆无恙
 * 泛型方法的使用
 */
@SuppressWarnings({"all"})
public class CustomMethodGeneric {
    public static void main(String[] args) {
        Car car  = new Car();
        car.fly("宝马",200);//当调用方法时，传入参数，编译器，就会确定类型
        System.out.println("====================");
        car.fly(300,100.1);//当调用方法时，传入参数，编译器，就会确定类型
        //测试
        //T->String R->ArrayList
        Fish<String, ArrayList> fish = new Fish<>();
        fish.hello(new ArrayList(),11.3f);
    }
}
//泛型方法，可以定义在普通类中，也可以定义在泛型类中
class Car{
    public  void run(){
    }
    //说明
    //1.<T,R>就是泛型
    //2.是提供给fly使用的
    public<T,R> void fly(T t,R r){//泛型方法
        System.out.println(t.getClass());//String
        System.out.println(r.getClass());//Integer
    }
}
class Fish<T,R>{//泛型类
    public  void run(){//普通方法
    }
    public<U,M> void eat(U u,M m){//泛型方法
    }
    //1.下面hi方法不是泛型方法
    //2.是hi方法使用了类声明的 泛型
    public void hi(T t){
    }
    //泛型方法可以类声明的泛型，也可以使用自己声明泛型
    public<K> void hello(R r,K k){
        System.out.println(r.getClass());//ArrayList
        System.out.println(k.getClass());//Float
    }
}

泛型的继承和通配符

1.泛型不具备继承性
2.<?>:支持任意泛型类型
3.<? extends A>:支持A类以及A类的子类，规定了泛型的上限
4.<? super A>:支持A类以及A类的父类，不限于直接父类，规定了泛型的下限

package com.hspedu;

import java.util.ArrayList;
import java.util.List;

/**
 * @author 山河与you皆无恙
 */
@SuppressWarnings({"all"})
public class GenericExtends {
    public static void main(String[] args) {
        Object o = new String("xx");
        //泛型没有继承性
        // List<Object> list = new ArrayList<String>();
        // 举例说明下面三个方法的使用
        List<Object> list1 = new ArrayList<>();
        List<String> list2 = new ArrayList<>();
        List<AA> list3 = new ArrayList<>();
        List<BB> list4 = new ArrayList<>();
        List<CC> list5 = new ArrayList<>();
        //如果是 List<?> c ，可以接受任意的泛型类型
        printCollection1(list1);
        printCollection1(list2);
        printCollection1(list3);
        printCollection1(list4);
        printCollection1(list5);
        //List<? extends AA> c： 表示 上限，可以接受 AA 或者 AA 子类
        // printCollection2(list1);//×
        // printCollection2(list2);//×
        printCollection2(list3);//√
        printCollection2(list4);//√
        printCollection2(list5);//√

        //List<? super AA> c: 支持 AA 类以及 AA 类的父类，不限于直接父类
        printCollection3(list1);//√
        //printCollection3(list2);//×
        printCollection3(list3);//√
        // printCollection3(list4);//×
        // printCollection3(list5);//×
    }
    // ? extends AA 表示 上限，可以接受 AA 或者 AA 子类
    public static void printCollection2(List<? extends AA> c) {
        for (Object object : c) {
            System.out.println(object);
        }
    }
    //说明: List<?> 表示 任意的泛型类型都可以接受
    public static void printCollection1(List<?> c) {
        for (Object object : c) {
            // 通配符，取出时，就是 Object
            System.out.println(object);
        }
    }
    // ? super 子类类名 AA:支持 AA 类以及 AA 类的父类，不限于直接父类， //规定了泛型的下限
    public static void printCollection3(List<? super AA> c) {
        for (Object object : c) {
            System.out.println(object);
        }
    }
}
class AA {
}
class BB extends AA {
}
class CC extends BB {
}

视频链接：
https://www.bilibili.com/video/BV1fh411y7R8?p=567&spm_id_from=pageDrive