Java高级Day26-自定义泛型

80.自定义泛型

基本语法：

class  类名<T,R...>{
    成员
}

注意细节：

1. 普通成员可以使用泛型（属性、方法）

2. 使用泛型的数组，不能初始化（因为数组new无法确定泛型类型，无法在内存开辟空间）

3. 静态方法中不能使用类的泛型

4. 泛型类的类型，是在创建对象时确定的（因为创建对象时，需要指定确定类型）

5. 如果在创建对象时，没有指定类型，默认为Object

//1.Tiger后面泛型，所以我们把Tiger就称为自定义泛型类
//2.T,R,M泛型是标识，一般是单个大写字母
//3.泛型标识可以有多个
​
class Tiger<T,R,M>{
    String name;
    R r;
    T t;
    M m;
    
    public Tiger(String name,R r,M m,T t){//构造器使用泛型
        this.name = name;
        this.r = r;
        this.m = m;
        this.t = t;
    }
    //方法使用泛型
    public void setR(R r){//方法使用泛型
        this.r = r
    }
}

自定义泛型接口

//基本语法
interface 接口名<T,R...>{
}

注意细节：

1. 接口中，静态成员也不能使用泛型

2. 泛型接口的类型，在继承接口或者实现接口时确定

3. 没有指定类型，默认为Object

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);
    
    //在JDK8中，可以在接口中，使用默认方法，也是可以使用泛型
    default R method(U u){
        return null;
    }
}
//在继承接口时 指定泛型接口类型
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;
    }
    @Ovrride
    public void hi(Double aDouble){
        
    }
    @Ovrride
    public void run(Double r1,Double r2,String u1,String u2){
        
    }
}
​
//实现接口时，直接指定泛型接口的类型
class BB implements IUsb<Integer,Float>{
     @Override
    public Float get(Integer integer){
        return null;
    }
    @Ovrride
    public void hi(Float aFloat){
        
    }
    @Ovrride
    public void run(Float r1,Float r2,Integer u1,Integer u2){
        
    }
}

自定义泛型方法：

//基本语法
修饰符<T,R...>返回类型 方法名(参数列表){
}

注意细节：

1. 泛型方法，可以定义在普通类中，也可以定义在泛型类中

2. 当泛型方法被调用时，类型会确定

3. public void eat(E e){}，修饰符后没有<T,R...>eat 方法不是泛型方法，而是使用了泛型

public class CustomMethodGeneric{
    public static void main(String[] args){
        Car car = new Car();
        car.fly("宝马",100);//当调用方法时，传入参数，编译器，就会确定类型
    }
}
//泛型方法，可以定义在普通类中，也可以定义在泛型类中
class Car{//普通类
    public vodi run(){//普通方法
    }
    //<T,R>就是泛型，是提供给fly使用的
    public<T,R> void fly(T t,R r){//泛型方法
    }
}
class Fish<T,R>{//泛型类
    public void run(){//普通方法
    }
    public<U,M> void eat(U u,M m){//泛型方法
    }
}
​
//下面hi方法不是泛型方法,只是使用了类声明的泛型
public void hi(T t){
}
//泛型方法，可以使用类声明的泛型，也可以使用自己声明泛型
public<K> void hello(R r,K k){
}

81.泛型的继承和通配符

1. 泛型不具备继承性

2. <?>：支持任意泛型类型

3. <? extend A>：支持A类以及A类的子类，规定了泛型的上限

4. <? super A>：支持A类以及A类的父类，不限于直接父类，规定了泛型的下限