自定义泛型_无多态_通配符无泛型数组_jdk7泛型使用

Posted 2020-09-07 豆子

• 通配符

• T, K, V, E 等泛型字母为有类型, 类型参数赋予具体的值

• ? 未知类型 类型参数赋予不确定值, 任意类型

• 只能用在 声明类型上，方法参数上， 不能用在定义泛型类上

• 上限 extends, 指定类型必须是继承某个子类. 或者实现某个接口

  (不是用 implements), 即 <= 如

  ? extends Fruit

  ? extends List

• 不能添加信息

• 存在以下规则, 如

  List<Fruit> 满足 List<? extends Fruit>

  List<? extends Apple> 满足 List<? extends Fruit>

• 下限 supper >=

• 泛型嵌套

• 泛型没有多态

• 实例1 (通配符)

package cn.Douzi.Test03;

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

/*
 * ? --> 通配符，类型不确定, 用于声明变量  | 形参上
 * 不能用在
 * 1. 创建对象
 * 2. 创建泛型类  泛型方法  泛型接口上
 * 
 */
public class WildcardsTest {
    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 test3(List<?> list) {
    }*/
    
    class Test<T> {
        
    }
    
    /* ? 不能创建泛型类上
    class Test2<?> {
    }*/
}

• 实例2 (extends 上限)

package cn.Douzi.Test03;

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>
 * 
 */
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> list1 = new ArrayList<Fruit>();
        test(list1);
        
        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<Object>();
        List<? extends Object> list6 = new ArrayList<Object>();
//        test(list5);
//        test(list6);
        
        List<FujiApple> app = new ArrayList<FujiApple>();
        test(app);
    }
    
    // ? extends Fruit
    public static void test(List<? extends Fruit> list) {
        //不能添加对象
//        list.add(new Apple());
//        list.add(new FujiApple());
        
        list.add(null);
    }
    
    //泛型类
    static class Test<T> extends Fruit {
        
    }
}

• 实例(下限)

package cn.Douzi.Test03;

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

/***
 * supper : 泛型的下限 >= 即父类或自身
 * 1. 一般用于  下限制操作
 * 2. 能够添加数据    一般都是都是   子对象和自己,  不能添加父对象
 * 3. 规则
 *       List<Fruit> ---> List<? supper Fruit>
 *       List<Apple> ---> List<? super Fruit>
 *       List<? Fruit> --> List<? super Fruit>
 *    不能存放
 *    List<?>
 *    List<? super FujiApple> --> List<? super Apple>
 *
 */
public class Supper {
    public static void main(String[] args) {
        List<Apple> apple = new ArrayList<Apple>();
        test(apple);
        
        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<Object>();
        test(list5);
        
        //编译错误
//        List<? super FujiApple> list6 = new ArrayList<FujiApple>();
//        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());
    }
}

• 实例(泛型嵌套)

package cn.Douzi.Test03;

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

/***
 * 泛型嵌套 --> 由外到内拆分
 * @author Administrator
 *
 */

public class StudentApp {
    public static void main(String[] args) {
        
        Student<String> stu = new Student<String>();
        
        stu.setScore("优秀");
        System.out.println(stu.getScore());
        
        Douzi<Student<String>> douzi = new Douzi<Student<String>>();
        douzi.setStu(stu);
        
        stu = douzi.getStu();
        String score = stu.getScore();
        System.out.println(score);
        
        //HashMap
        Map<String, String> map = new HashMap<String, String>();
        
        map.put("a", "Douzi");
        map.put("b", "DouDou");
        
        Set<Entry<String,String>> entrySet = map.entrySet();
        //增强for循环
        for (Entry<String, String> entry : entrySet) {
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key + "-->" + value);
        }
        
    }
}

• 实例(泛型没有多态)

package cn.Douzi.Test03;

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

/***
 * 1. 泛型没有多态
 * 2. 泛型没有数组
 * @author Douzi
 * 
 */
public class Polymorphism {
    
    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>[100];
//        Fruit[] arr = new Fruit[100];  //可以
        
        //JDK1.7 泛型简化
        List<Fruit> list2 = new ArrayList<>();
        
    }    
}

• 总结

1. 通配符 ? --> 类型不定, 声明变量上
2. 上限 extends <= 不能添加信息
   下限 super   >= 不能添加父信息
3. 泛型嵌套, 由外到内获取即可
4. 泛型没有多态, 泛型没有数组
5. jdk1.7泛型简化, 创建对象不用指定类型