Java泛型

泛型<>：
 * 1、泛型只能使用引用数据类型，不能使用基本数据类型
 * 2、常用参数 T-type、K-key、V-value、E-element 和？(表示类型不定，使用时确定类型)
 *     ? extends  <= 子类或自身
 *     ? super  >= 自身或父类
 *     此处的对比指的是前面的?
 * 3、泛型类和泛型变量不能使用static修饰  因为static是在编译时处理 而泛型是在使用时处理
 * 4、泛型方法可以使用static修饰，泛型方法只能访问不能修改
 * 5、泛型抽象类，子类继承泛型抽象类时
 *     泛型擦除后默认为Object类型
 * （1）当父类擦除泛型时，子类随意
 * （2）当父类没有擦除时，子类泛型范围要大于等于父类定义的泛型范围
 * （3）父类有多个泛型或子类定义多个泛型时，子类泛型的顺序不必与父类相同
 * 属性类型（泛型）  父类随父类而定，子类随子类而定
 * 重写方法（泛型）  随父类而定
 * 6、泛型接口的用法同5

泛型方法的例子：

/**
 * 类没有定义泛型，只是方法定义泛型
 */
public class Test {

    public <T> void test1(T t) {

    }

    public <T> String test2(T t) {
        return "有返回值的泛型方法。";
    }

}

/**
 * 类定义的泛型与方法中的泛型相同
 */
public class Test<T> {

    public void test1(T t) {

    }

    public String test2(T t) {
        return "有返回值的泛型方法。";
    }

}

泛型抽象类的例子：

/**
 * 抽象泛型类
 * 泛型个数
 */
public abstract class Father<T> {

    T t;

    public abstract void getT(T t);

}

/**
 * 父类擦除，子类也擦除 
 * 父类擦除后，类型默认为Object
 */
public class ChildOne extends Father {
    @Override
    public void getT(Object t) {
        System.out.println(t);
    }
}

/**
 * 父类擦除，子类重新定义泛型(泛型个数任意) 
 * 父类擦除后，类型默认为Object
 */
public class ChildTwo<T, T1> extends Father {

    T t;
    T1 t1;

    public void getT1(T1 t1) {
        System.out.println(t1);
    }

    @Override
    public void getT(Object t) {

    }

}

/**
 * 子类指定泛型类型
 */
public class ChildThree extends Father<String> {

    @Override
    public void getT(String t) {
        System.out.println(t);
    }

}

/**
 * 子类指定泛型类型且定义新的泛型
 */
public class ChildFour<T> extends Father<String>{

    public T t;
    @Override
    public void getT(String t) {
        System.out.println(t);
    }

}

/**
 * 子类未指定泛型类型，则必须定义与父类相同的泛型
 */
public class ChildFive<T> extends Father<T>{

    @Override
    public void getT(T t) {
        System.out.println(t);
    }

}

/**
 * 子类未指定泛型类型，则必须定义与父类相同的泛型,可以再定义其他泛型且顺序随意
 */
public class ChildSix<T1,T> extends Father<T>{

    T1 t1;
    
    @Override
    public void getT(T t) {
        System.out.println(t);
    }

}

测试如下：

public class Test {

    public static void main(String[] args) {
        ChildOne childOne = new ChildOne();
        childOne.getT("父类擦除，子类也擦除。继承父类变量、方法中的泛型类型默认为Object");
        ChildTwo<Integer, String> childTwo = new ChildTwo<>();
        childTwo.getT1("父类擦除，子类擦除后重新定义新的泛型(泛型个数任意)类型。此处定义了两个泛型，为Integer和String");
        ChildThree childThree = new ChildThree();
        childThree.getT("父类未擦除，子类指定泛型类型。此处指定为String");
        ChildFour<Integer> childFour = new ChildFour<>();
        childFour.t=123;
        childFour.getT("父类未擦除，子类指定泛型类型且定义新的泛型(泛型个数任意)。此处指定为String");
        ChildFive<String> childFive=new ChildFive<>();
        childFive.getT("父类未擦除，子类未指定泛型类型，则子类必须定义与父类相同的泛型。");
        ChildSix<Integer,String> childSix=new ChildSix<>();
        childSix.getT("父类未擦除，子类未指定泛型类型，则必须定义与父类相同的泛型,可以再定义其他泛型且顺序随意。");
    }
}