Java 泛型

定义：使用泛型可以指代任意对象类型；

定义一个C1类：里面有个Integer属性  给出构造方法 以及打印类型 和get set方法。

package com.xuyigang1234.chp05.sec02;

public class C1 {
    private Integer a;
    
    
    //构造方法
    public C1(Integer a) {
        super();
        this.a = a;
    }

    public Integer getA() {
        return a;
    }

    public void setA(Integer a) {
        this.a = a;
    }
    public void print() {
        System.out.println("a的类型是"+a.getClass().getName());
    }

}

定义一个C2类，里面定义一个String类型属性：

package com.xuyigang1234.chp05.sec02;

public class C2 {
    private String a;
    
    
    //构造方法
    public C2(String a) {
        super();
        this.a = a;
    }

    public String getA() {
        return a;
    }

    public void setA(String a) {
        this.a = a;
    }
    public void print() {
        System.out.println("a的类型是"+a.getClass().getName());
    }

}

假如有100个类型，类似的我们要写100个类似的类，很麻烦，这时候我们会想到多态，我们改写下试下：

用一个类实现：因为所有类都继承自Object类，所以直接定义成Object类型的属性；

package com.xuyigang1234.chp05.sec02;

public class CC {
    private Object object;
    
    
    public CC(Object object) {
        super();
        this.object = object;
    }

    public Object getObject() {
        return object;
    }

    public void setObject(Object object) {
        this.object = object;
    }
    public void print(){
        System.out.println("object的类型是"+object.getClass().getName());
    }

}

我们发现测试类里需要转型，类简便了，但是测试类复杂了，有没有一种类简单，测试也简单的方式呢，这时候，泛型诞生了；

我们先定义一个泛型类：

package com.xuyigang1234.chp05.sec02;

public class FanXing<T> {
    private T t;
    // 构造方法
    public FanXing(T t) {
        super();
        this.t = t;
    }

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
    //打印类型
    public void print() {
        System.out.println("t的类型是："+ t.getClass().getName());
    }

}

写个测试类：

package com.xuyigang1234.chp05.sec02;

public class Test {
    public static void main(String[] args) {
        //test begin C1
        C1 c1= new C1(1);
        c1.print();
        Integer i1= c1.getA();
        System.out.println("i1="+i1);
        //end C1
        //test begin C2
        C2 c2= new C2("Java");
        c2.print();
        String s1= c2.getA();
        System.out.println("s1="+s1);
        //end C2
        
        //test begin CC   多态类
        CC cc= new CC(1);  //向上转型
        cc.print();
        Integer i2=(Integer) cc.getObject(); //向下转型，强制类型转换
        System.out.println("i2="+i2);
        
        CC ccs= new CC("Java");  //向上转型
        ccs.print();
        String s2=(String) ccs.getObject(); //向下转型，强制类型转换
        System.out.println("s2="+s2);                
        //end CC
        
        //test FanXing
        FanXing<Integer> fx = new FanXing<Integer>(1);
        fx.print();
        Integer i3 = fx.getT();
        System.out.println("i3="+i3);
        
        FanXing<String> fxStr = new FanXing<String>("Java");
        fxStr.print();
        String s3 = fxStr.getT();
        System.out.println("s3="+s3);
        
        // end FanXing
    }
}

输出：
a的类型是java.lang.Integer
i1=1
a的类型是java.lang.String
s1=Java
object的类型是java.lang.Integer
i2=1
object的类型是java.lang.String
s2=Java
t的类型是：java.lang.Integer
i3=1
t的类型是：java.lang.String
s3=Java