Java泛型

泛型的理解和好处：

1.不能对加入到集合ArrayList中的数据类型进行约束（不安全）

2.遍历的时候，需要进行类型转换，如果集合中的数据量较大，对效率有影响

3.在类型声明或实例化时只要指定好需要的具体类型即可

4.泛型的作用是：可以在类型声明是通过一个标识类型中某个属性的类型，或者是某个方法的返回值的类型，或者是差数类型。

public class Application {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        Nerson<String> person = new Nerson<String>("100");
        System.out.println(person.getS());
    }
}
class Nerson<E>{
    E s;
    public Nerson(E s) {
        this.s = s;
    }

    public E getS() {
        return s;
    }

    public void setS(E s) {
        this.s = s;
    }
}

public class Application {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        //再给泛型指定具体类型后，可以传入该类型或者其子类类型
        Pig<A> aPig = new Pig<A>(new A());
        //因为我给定的泛型是A这里却用了B类的对象
        //Pig<A> aPig1 = new Pig<A>(new B());
        Pig<A> pig = new Pig<>(new B());
    }
}

class A {};

class B extends A{};

class Pig<E> {
    E e;

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

自定义泛型
普通泛型的数组，不能初始化
静态方法中不能使用类型泛型
泛型类的类型，实在创建对象是确定的（因为创建对象时，需要指定确定类型）
如果在创建对象时，没有指定类型，默认为Object
/*
    基本语法：
    class 类名<T,R....>{//...表示可以有多个泛型
        成员
    }
*/

public class Application {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
    
    }
}

class Tiger<T, R, M>{
    String name;
    R r;
    M m;
    T t;


    public Tiger(String name, R r, M m, T t) {
        this.name = name;
        this.r = r;
        this.m = m;
        this.t = t;
        //因为数组在new不能确定T的类型，就无法在内存开空间
        T[] ts = new T[8];
    }

    //静态方法中不能使用类型泛型
    public static void m1(M m){}

    public String getName() {
        return name;
    }

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

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

    public T getT() {
        return t;
    }

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

    @Override
    public String toString() {
        return "Tiger{" +
                "name='" + name + '/'' +
                ", r=" + r +
                ", m=" + m +
                ", t=" + t +
                '}';
    }
}

自定义泛型接口
在接口中静态成员不能使用泛型（这个和泛型类规定一样）
泛型接口的类型，在继承接口或者实现接口时确定
没有指定类型，默认为Object
基本语法
   interface 接口名<T,R..>{
}

public class Application {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
     
    }
}
//泛型接口的类型，在继承接口或者实现接口时确定
class aa implements IUsb<String,String>{


    @Override
    public String get(String i) {
        return null;
    }

    @Override
    public void hi(String s) {

    }

    @Override
    public void run(String r1, String r2, String u1, String u2) {

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

    }
}

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){
        U name;
        return null;
    }
}

//让IA接口去继承TUsb接口
interface IA extends IUsb<String,Double>{

}