泛型深入--java泛型的继承和实现、泛型擦除

泛型实现类：

package generic;
/**
 * 泛型父类：子类为“富二代”：子类的泛型要比父类多
 * 1，保留父类的泛型-->子类为泛型类
 * 2，不保留父类泛型-->子类按需实现
 * 
 * 
 * 子类【重写方法】的参数类型 -->随父类而定
 *     子类新增的方法，参数类型随子类而定
 * 子类中使用父类的【属性】 -->随父类而定
 *         子类使用自己的属性-->随子类而定
 * @author Administrator
 *
 */
public abstract  class Father<T1,T2> {
        T1 age ;
        public abstract void test(T2 name);
}

//当继承Father类时，T1、T2的处理方式：

//保留 -->父类保留，子类必须保留，所以子类是泛型子类     
//1) 全部保留
class C1<T2,T1,A> extends Father<T1,T2>{
    
    @Override
    public void test(T2 name) {//子类重写方法的参数类型 -->随父类而定：T2    
        System.out.println("name : "+name);
    }
    
    //子类自定义属性，类型随子类
    A a ;
    String str ;
    /**
     * 子类新增的方法，参数类型随子类而定
     * @param a
     */
    public void test2(A a){
        System.out.println(a);
//        this.a --> A类型，随子类
    }
}

//2) 部分保留
class C2<T2> extends Father<Integer,T2>{

    @Override
    public void test(T2 name) {//子类重写方法的参数类型 -->随父类而定：T2    
        this.age = 23; //Integer类型，子类使用父类的【属性】，类型随父类而定
    }
}

//不保留，把T1、T2替换成具体的类型 
//---》按需实现:子类 可以扩展泛型
//1) 具体类型
class C3<A,B> extends Father<String,Integer>{

    @Override
    public void test(Integer name) {//子类重写方法的参数类型 -->随父类而定：Integer
        this.age = "24";//String 类型，子类使用父类的【属性】，类型随父类而定
    }
}

//2) 没有类型 擦除 --》Object
class C4<A,B> extends Father{

    @Override
    public void test(Object name) {//子类重写方法的参数类型 -->随父类而定：Object
        this.age = new Object();//Object 类型，子类使用父类的【属性】，类型随父类而定
    }
}

泛型接口：

package generic;
/**
 * 泛型接口：与泛型类 同理
 * @author Administrator
 *
 * @param <T>
 */
public interface Comparator2<T> {
    //全局常量
    public static final int MAX_VALUE =100;
    //公共抽象方法
    public abstract void test(T t);
}
//实现
class InterC1<A> implements Comparator2{
    @Override
    public void test(Object t) {//类型是父类的
        System.out.println(this.MAX_VALUE); //父类的  
　　}
}
class InterC2<Integer> implements Comparator2<Integer>{
    @Override
    public void test(Integer t) { //类型是父类的
        
    }
}

class InterC3<T,A> implements Comparator2<T>{
    @Override
    public void test(T t) {//类型是父类的
        
    }
}

 泛型擦除：

package generic;
/**
 * 泛型的擦除：使用时 实现|继承  没有指定具体的类型
 * 类似于Object 不等同于Object
 * @author Administrator
 *
 */
public class MyStuApp {

    public static void main(String[] args) {
        //擦除：没有指定泛型的具体类型
        //泛型擦除，但是存在警告
        MyStudent student = new MyStudent();
        student.setJavase(100); //int-->Object,以Object处理
        Object javase = student.getJavase();
        
        //2、消除警告 使用 Object
        MyStudent<Object> student2 = new MyStudent<Object>();
        
        //正确:  擦除，编译通过，不会类型检查
        test(student);
        
        //编译失败：MyStudent<Object> 不等同于Object
        //错误 ，Object 编译检查
        //test(student2);
    }
    
    public static void test(MyStudent<Integer> stu){
        
    }
}

附MyStudent类：

package generic;
/**
 * 自定义泛型类：
 * 1，<> -->单个字母，尽可能见名知意
 * 2，T   Type
 *    K V  Key Value
 *    E  Element
 * 3，注意泛型不能使用在静态属性上
 */
//T  type ，类型
public class MyStudent<T> {
    private T javase;
//    private static T test;//静态编译错误

    public MyStudent(){}
    public MyStudent(T javase) {
        super();
        this.javase = javase;
    }

    public T getJavase() {
        return javase;
    }

    public void setJavase(T javase) {
        this.javase = javase;
    }
}

总结：

1. 继承|实现 

             a) 保留：泛型子类

             b) 不保留：按需实现，可以泛型子类，也可以是非泛型子类。属性|方法 ：随声明的位置而定。

　　2.擦除：使用  继承|实现  没有指定类型，类似于Object