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

时间：2023-01-10 12:42:32

泛型深入--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) {//类型是父类的

    }

}

泛型擦除：

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

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

相关文章