2020-10-20--泛型

1.为什么要使用泛型:
1.1、不用强制类型转换。
1.2、传入类型不对的时候编译时期就会报错。

2.泛型的种类：
2.1、泛型类

class student<T> {
    public T getT() {
        return t;
    }

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

    private T t;
}
public class fanxing {
    public static void main(String[] args) {
        student<String> stringstudent = new student<String>();
        stringstudent.setT("你是谁");
        System.out.println(stringstudent.getT());
    }
}

2.2、泛型接口：

interface student2<T> {
    T getT();

    void setT(T x);
}


public class fanxing implements student2<String> {
    public static void main(String[] args) {
        fanxing f = new fanxing("你是谁");
        System.out.println(f.getT());
    }

    private String x;

    public fanxing(String x) {
        setT(x);

    }

    public String getT() {
        return x;
    }

    public void setT(String x) {
        this.x = x;
    }
}

当你继承接口的类不是泛型类的时候，你需要明确T的类型，不然编译时就会报错。时泛型类的时候就可以不用明确T的类型。

image.png

3.泛型方法：

    public static void main(String[] args) {
        fanxing f = new fanxing("你是谁");
        System.out.println(f.getName("哥特斯"));
    }


    public  static  <T> String getName(T a){
        return  "你是谁"+a.toString();
    }

4.其他类型泛型：
4.1、也可以通过class<T>传递class对象

image.png
image.png

4.2、泛型数组：

    public static void main(String[] args) {
        fanxing f = new fanxing("你是谁");
        String [] b={"1","2","3"};
        Integer [] c={1,2,3};
        for (String s : b) {
            System.out.println(s);
        }
        for (Integer integer : c) {
            System.out.println(integer.toString());
        }
    }


    public  static  <T> T[]  getName(T [] a){
        return a;
    }

5.类型绑定

5.1、可以看出compareTo方法不好使了，因为T其实派生于object这个类的。编译时期不知道compareTo方法来自于哪里。通过类型绑定：

    public static void main(String[] args) {
        Integer[] a = {4, 1, 0};
        System.out.println(min1(a));
    }

    public static <T extends  Comparable> T min1(T [] a) {
        T s=a[0];
        for (T t : a) {
            if (t.compareTo(s)<0){
                s=t;
            }
        }
        return s;
    }

5.2、我们也可以通过&绑定多个类型。

6.通配符
6.1通配符使用：

image.png

通过通配符，你可以填充任何类型的参数。它只能填充泛型变量。
6.2通配符绑定类型：

class A{}
class B extends  A{}
class C extends B{}
public class fanxing  {
    public static void main(String[] args) {
        List<? super B> list;
        list=new ArrayList<B>();
        list.add(new B());
        list.add(new C());
        for (Object o : list) {
            System.out.println(o.toString());
        }
    }

可以看出当将new ArrayList<B>()赋值给list的时候是可以将B包括在内的。

image.png

上面的编译错误可以看出可以存A这个类型，但是不能添加进去。因为编译器无法确定父类是谁只能确定他的子类。