自定义泛型

自定义泛型类(难度)

基本语法
class 类名 <T, R...> { //...表示可以有多个泛型

成员
}

注意细节

1. 普通成员可以使用泛型(属性、方法)
2. 使用泛型的数组，不能初始化
3. 静态方法中不能使用类的泛型
4. 泛型类的类型，是在创建对象时确定的(因为创建对象时，需要指定确定类型)
5. 如果在创建对象时，没有指定类型，默认为Object

举例说明

public class Exercise04 {
    public static void main(String[] args) {
    }
}
//1、Tiger后面泛型，所以我们把Tiger就称为自定义泛型类
//2、T，R，M 泛型的标识符，一般是单个大写字母
//3、泛型标识符可以有多个·
//4、普通成员可以使用泛型(属性、方法)
//5、使用泛型的数组，不能初始化
class Tiger <T,R,M>{
    String name;
    T t; //属性使用泛型
    R r; //属性使用泛型
    M m; //属性使用泛型
    T[] ts; //可以使用泛型定义
    //T[] a = new T[8]; //错误，不能初始化，因为数组在new不能确定 T 的类型，就无法在内存开空间
    // 构造器使用泛型
    public Tiger(String name, T t, R r, M m) { // 构造器使用泛型
        this.name = name;
        this.t = t;
        this.r = r;
        this.m = m;
    }

    //方法使用泛型
    public T getT() {
        return t;
    }

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

    //因为静态是和类相关的，在类加载时，对象还没有创建
    //所以，如果静态方法和静态属性使用了泛型，JVM就无法完成初始化static Rr2;
    //static R r2; //错误
    //public static void m1(M m) { //错误

   // }
}

小练习

说明自定义泛型代码是否正确,，并说明原因。
MyGeneric <Double,String,Integer> g = newMyGeneric<>("john");
g.setT(10.9);
g.setT("yy");
System.out.println(g);
MyGeneric g2 =new MyGeneric("john~~");

g2.setT("yy");
System.out.println("g2=" +g2);

public class Exercise05 {
    public static void main(String[] args) {
        //T=Double,R=String,M=Integer
        MyGeneric <Double,String,Integer> g = new MyGeneric<>("john");
        g.setT(10.9); //正确
        //g.setT("yy"); 错误，类型不对，这里应该是 double类，不是 String类
        System.out.println(g);
        //正确，但这里没有指定类型，默认为Object类，所以 T=Object,R=Object,M=Object
        MyGeneric g2 =new MyGeneric("john~~");
        g2.setT("yy"); //正确，因为 T=Object,而"yy"是String类，是Object的子类
        System.out.println("g2=" +g2);
    }
}
class MyGeneric <T,R,M>{
    T t; //属性使用泛型
    R r; //属性使用泛型
    M m; //属性使用泛型
    String name;

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

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

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

输出：

MyGeneric{t=10.9, r=null, m=null, name='john'}
g2=MyGeneric{t=yy, r=null, m=null, name='john~~'}