java泛型---通配符,泛型嵌套

Posted 我俩绝配

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了java泛型---通配符,泛型嵌套相关的知识,希望对你有一定的参考价值。

package generic;

import java.util.ArrayList;
import java.util.List;
/**
 * ? -->通配符,类型不确定,用于声明 变量|形参 上
 * 不能用在:
 * 1,创建对象
 * 2,创建泛型类 、泛型方法、泛型接口上
 *
 */
public class WildcardTest {

    public static void main(String[] args) {
        //声明
        List<?> list = new ArrayList<Integer>();
        list = new ArrayList<String>();
        list = new ArrayList<Object>();
        
        test(list);
        //编译错误,不能创建对象
//        list = new ArrayList<?>();
    }
    
    public static void test    (List<?> list){
        
    }
    //?不能用在泛型方法上
    /*public static <?> void test2(List<?> list){
        
    }*/
    //?不能创建泛型类
    /*class Test<?>{
        
    }*/
}

当然这样用是没有什么意义的,它和用Object一样

 泛型上限 extends:

 

几个有继承关系的类:

package generic;
/**
 * 继承链:
 *       Object
 *        /  \\
 *     Apple  Pear
 *     /
 *  FujiApple 
 *          
 * @author Administrator
 *
 */
public class Fruit {

}
class Apple extends Fruit{
    
}
class Pear extends Fruit{
    
}
class FujiApple extends Apple{
    
}

例子程序:

package generic;

import java.util.ArrayList;
import java.util.List;
/**
 * extends:泛型的上限 表示 <= ,即 子类
 * 1,一般用于 限制操作
 * 2,不能用在添加数据上,一般都是读取操作
 * 3,规则:
 *    遇到  List<? extends Fruit> 什么样的数据可以往上放:
 *    List<Fruit>
 *    List<Apple>
 *    List<? extends Apple>
 *    不能存放:
 *    List<?>
 *    List<? extends Object>
 * @author Administrator
 *
 */
public class ExtendsTest {

    public static void main(String[] args) {
        //extends 为上限,List的类型上限是Fruit
        Test<Fruit> t1 = new Test<Fruit>();
        Test<Apple> t2 = new Test<Apple>();
        Test<Pear> t3 = new Test<Pear>();
        
        //调用方法    
        List<? extends Fruit> list1 = new ArrayList<Fruit>();
        test(list1);
        List<Fruit> list2 = new ArrayList<Fruit>();
        test(list2);
        List<Apple> list3 = new ArrayList<Apple>();
        test(list3);
        List<FujiApple> list4 = new ArrayList<FujiApple>();
        test(list4);
        List<? extends Apple> list7 = new ArrayList<FujiApple>();
        test(list7);
        //报错:因为 ? 相当于 ? extends Object,范围超过了Fruit
        List<?> list5 = new ArrayList<Object>();
//        test(list5);
        List<? extends Object> list6 = new ArrayList<Object>();
//        test(list6);
    }
    
    //? extends Fruit
    public static void test(List<? extends Fruit> list){
        
    }
    
    //内部类
    static class Test<T extends Fruit>{
        
    }
    
}

 泛型的下限:Super

 

package generic;

import java.util.ArrayList;
import java.util.List;

/**
 * super: 泛型的下限 >= 父类或者自身
     1,一般用于 下限制操作
 * 2,能够添加数据上,不能添加父对象
 * 3,规则:
 */
public class SuperTest {

    public static void main(String[] args) {
        //传入的List类型必须   >=Apple,即是 Apple类的父类或自身
        List<Apple> list1 = new ArrayList<Apple>();
        test(list1);
        List<Fruit> list2 = new ArrayList<Fruit>();
        test(list2);
        List<Object> list3 = new ArrayList<Object>();
        test(list3);
        
        //规则 Object > Fruit 正确
        List<? super Fruit> list4 = new ArrayList<Object>();
        test(list4);
        //Apple = Apple 正确
        List<? super Apple> list5 = new ArrayList<Apple>();
        test(list5);
        //FujiApple < Apple,编译报错
        List<? super FujiApple> list6 = new ArrayList<Object>();
        //test(list6);
        //? --> ? extends Object ,可能意思是左边声明是Object的子类,右边是Object,不行?
        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());//父类不能添加
        
    }
}

 泛型嵌套:

学生类:

package generic;

public class Stu<T> {

    private T score;

    public T getScore() {
        return score;
    }

    public void setScore(T score) {
        this.score = score;
    }
    
}

学校类:

package generic;

/**
 * @author Administrator
 *
 * @param <T>
 */
public class School<T> {
    private T stu;

    public T getStu() {
        return stu;
    }

    public void setStu(T stu) {
        this.stu = stu;
    }
    
}

测试类:

package generic;

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

/**
 * 泛型嵌套
 * @author Administrator
 *
 */
public class StuApp {

    public static void main(String[] args) {
        
        Stu<String> stu = new Stu<String>();
        stu.setScore("优秀");
        System.out.println(stu.getScore());
        
        //泛型嵌套:
        School<Stu<String>> sch = new School<Stu<String>>();
        sch.setStu(stu);
        stu = sch.getStu();
        String score = stu.getScore();
        System.out.println(score);
        
        //HashMap
        Map<String,String> map = new HashMap<String,String>();
        map.put("a", "老大");
        map.put("b", "老二");
        
        Set<Entry<String, String>> entrySet = map.entrySet();
        for (Entry<String, String> entry : entrySet) {
            System.out.println(entry.getKey() +"--->"+ entry.getValue());
        }
    }
}

 泛型没有多态:

package generic;

import java.util.ArrayList;
import java.util.List;

public class Other {

    public static void main(String[] args) {
        //多态
        Fruit f = new Apple();
        //泛型没有多态:
//        List<Fruit> list = new ArrayList<Apple>();//错误
        List<? extends Fruit> list = new ArrayList<Apple>();
        
        //泛型没有数组
//        Fruit<String>[] arr = new Fruit<String>(); //报错
        
        //JDK1.7泛型简化
        List<String> list2 = new ArrayList<>();
        
    }
}

 

 

欢迎关注个人公众号一起交流学习:

以上是关于java泛型---通配符,泛型嵌套的主要内容,如果未能解决你的问题,请参考以下文章

操作 Java 泛型:泛型在继承方面体现与通配符使用

Java的泛型---(英雄联盟集合嵌套案例)

java泛型之泛型通配符具体是啥作用?

Java 泛型泛型用法 ( 泛型类用法 | 泛型方法用法 | 泛型通配符 ? | 泛型安全检查 )

Java 泛型概述与应用

这个嵌套类构造函数片段可以应用于泛型类吗?