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

時間 2019-11-09

標籤深刻 java 繼承實現擦除欄目 Java 简体版

原文原文鏈接

泛型實現類：

package generic;
/**
 * 泛型父類：子類爲「富二代」：子類的泛型要比父類多
 * 1，保留父類的泛型-->子類爲泛型類
 * 2，不保留父類泛型-->子類按需實現
 * 
 * 
 * 子類【重寫方法】的參數類型 -->隨父類而定
 *     子類新增的方法，參數類型隨子類而定
 * 子類中使用父類的【屬性】 -->隨父類而定
 *         子類使用本身的屬性-->隨子類而定
 * @author Administrator
 *
 */
public abstract  class Father<T1,T2> {
        T1 age ;
        public abstract void test(T2 name);
}

//當繼承Father類時，T一、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類型，子類使用父類的【屬性】，類型隨父類而定
    }
}

//不保留，把T一、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();
        
        //二、消除警告 使用 Object
        MyStudent<Object> student2 = new MyStudent<Object>();
        
        //正確:  擦除，編譯經過，不會類型檢查
        test(student);
        
        //編譯失敗：MyStudent<Object> 不等同於Object
        //錯誤 ，Object 編譯檢查
        //test(student2);
    }
    
    public static void test(MyStudent<Integer> stu){
        
    }
}

附MyStudent類：java

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;
    }
}