Java学习中关于泛型2

叁歲伎倆 2022-06-11 08:09 189阅读 0赞

父类为泛型时，子类继承时：父类擦除指定类型，子类按需编写。

父类存在泛型时，子类必须>=

属性及方法类型：随位置而定

接口为泛型接口

与继承同理，重写方法随接口而定。

泛型擦除：

定义：泛型擦除是指在继承（实现）或使用时没有指定具体的类型

特点：一旦擦除之后按Object处理

依然存在警告，加上object可以出去，但是也有些画蛇添足。

不完全等同于object，编译不会类型检查。  
1、继承|实现（extends是一个下限，super是一个上限）

package gen03;
    /**
     * 继承链
     *       Fruit
     *       /  \
     *   Apple  Pear
     *    |
     * FujiApple 
     * @author hanjiangbo
     *
     */
    public class Fruit {
    	
    }
    class Apple extends Fruit{
    	
    }
    class Pear extends Fruit{
    	
    }
    class FujiApple extends Apple{
    	
    }

//下面用到上面的类

//关于extends

package gen03;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * extends:表示泛型的上限 <= 即子类
     * 1、一般用于限制操作
     * 2、不能使用在添加数据上，一般都是读取操作
     * 3、规则
     * List<Fruit>-->List<? extends Fruit>
     * List<Apple>-->List<? extends Fruit>
     * List<? extends Apple>-->List<? extends Fruit>
     * 不能存放的
     * List<?>
     * List<? extends Object>
     * @author hanjiangbo
     *
     */
    public class ExtendsTest {
    	public static void main(String[] args) {
    		//extends为上限
    		Test<Fruit> t1 = new Test<Fruit>();
    		Test<Apple> t2 = new Test<Apple>();
    		Test<Pear> t3 = new Test<Pear>();
    		
    		
    		//规则
    		List<? extends Fruit> list = new ArrayList<Fruit>();
    		test(list);
    		List<Fruit> list2 = new ArrayList<Fruit>();
    		test(list2);
    		List<Apple> list3 = new ArrayList<Apple>();
    		test(list3);
    		//? extends Apple
    		List<? extends Apple> list4 = new ArrayList<FujiApple>();
    		test(list4);
    		//？为什么错误			因为？等同于？extends Object
    		List<?> list5 = new ArrayList<Fruit>();
    		//test(list5);
    	}
    	//? extends Fruit
    	public static void test(List < ? extends Fruit> list){
    		//不能用于添加数据
    		//1list.add(new Apple());
    	}
    	//泛型类
    	static class Test<T extends Fruit>{
    		
    	}
    }

//关于super

package gen03;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * super: 泛型的上限 >= 即父类或自身
     * 1、一般用于上限操作
     * 2、能够添加数据上，不能添加父对象
     * 3、规则
     * List<Fruit>-->List<? super Apple>
     * List<Apple>-->List<? super Apple>
     * 
     * 不能存放
     * List<? super FujiApple>-->List<? super Apple>
     * 不能存放的
     * List<?>
     * List<? extends Object>
     * @author hanjiangbo
     *
     */
    public class SuperTest {
    
    	public static void main(String[] args) {
    		// >= 即父类或自身
    		List<Apple> list = new ArrayList<Apple>();
    		test(list);
    		List<Fruit> list2 = new ArrayList<Fruit>();
    		test(list2);
    		List<Object> list3 = new ArrayList<Object>();
    		test(list3);
    		
    		//规则
    		List<? super Apple> list4 = new ArrayList<Apple>();
    		test(list4);
    		List<? super Fruit> list5 = new ArrayList<Fruit>();
    		test(list5);
    		List<? super FujiApple> list6 = new ArrayList<Object>();
    		//test(list6);
    		List<?> list7 = new ArrayList<Object>();
    		//test(list7);
    	}	
    	public static void test(List <? super Apple> list) {
    		//不能添加父类信息
    		list.add(new Apple());
    		list.add(new FujiApple());
    		//list.add(new Fruit());
    	}	
    	
    
    }

未完待续。。。