泛型實現類：

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){
        
    }
}

總結：

1. 繼承|實現

a) 保留：泛型子類

b) 不保留：按需實現，可以泛型子類，也可以是非泛型子類。屬性|方法 ：隨聲明的位置而定。

　　2.擦除：使用 繼承|實現 沒有指定類型，類似於Object

泛型深入--java泛型的繼承和實現、泛型擦除