面向对象-类库-泛型

//此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型 
//在实例化泛型类时，必须指定T的具体类型
public class ClassName<T>{
　　//data这个成员变量的类型为T,T的类型由外部指定
　　//泛型类中的成员变量不能用static修饰，因为静态变量无需创建类即可调用，无法确定是那种类型，编译不能通过
　　//即 public static T t; 会编译报错
    private T data;

　　public ClassName(T data) {//泛型构造方法的形参data类型为T
　　　　this.data = data;
　　}

    public T getData() {//此方法返回值类型为T
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }
}

ClassName className= new ClassName ("111111");
ClassName className1 = new ClassName(true);
ClassName className2 = new ClassName(333.3);
ClassName className3 = new ClassName(000000);

//定义一个泛型接口
public interface InterfaceName<T> {
    T value();
}

public class Name implements InterfaceName<String> {
    @Override
    public String value() {
        return null;
    }
}

public class Name<T> implements InterfaceName<T> {
    @Override
    public T value() {
        return null;
    }
}

public class ClassName {
    //public 与 返回值中间<T>非常重要，可以理解为声明此方法为泛型方法。
    //只有声明了<T>的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
    //<T>表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。
    public <T>T say(T t) {
        System.out.println("111");
    }

    public static <E> test(E e) {
         System.out.println("111");
    }
}

    //虽然在方法中使用了泛型，但是这并不是一个泛型方法。
    //这只是类中一个普通的成员方法，只不过他的返回值是在声明泛型类已经声明过的泛型。
    //所以在这个方法中才可以继续使用 T 这个泛型。
    public T getKey(){
        return key;
    }    

    //泛型的数量也可以为任意多个, 如：
    public <T,K> K show(TestClass<T> testClass){
        ...
    }

    //这个方法是有问题的，编译器会为我们提示错误信息："UnKnown class ‘E‘ "
     //虽然我们声明了<T>,也表明了这是一个可以处理泛型的类型的泛型方法。
     //但是只声明了泛型类型T，并未声明泛型类型E，因此编译器并不知道该如何处理E这个类型。
    public <T> T test01(ClassName<E> className){
        ...
    }  

    //这个方法也有问题的，编译器会为我们提示错误信息："UnKnown class ‘T‘ "
     //对于编译器来说T这个类型并未项目中声明过，因此编译也不知道该如何编译这个类。
     //所以这也不是一个正确的泛型方法声明。
    public void test02(T t){
　　　　
    }