118_容器_自定义泛型_深入2_无多态_通配符_无泛型数组_jdk7泛型使用

通配符

• 通配符的测试-TestWildcard

package genericity_wildcard;

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

/**
 * ? -->通配符，类型不确定，用于声明变量|形参上
 * 不能用在
 * 1、创建对象
 * 2、创建泛型类 泛型方法 泛型接口上
 */

public class TestWildcard {
    public static void main(String[] args) {
        //声明
        List<?> list =new ArrayList<Integer>();
        list =new ArrayList<String>();
        list =new ArrayList<Object>();  
        /**list =new ArrayList<?>();
          *编译错误 不能创建对象 */

        test(list);
    }
    //可用于泛型方法声明
    public static void test(List<?> list){

    }

    /**不能用于泛型方法声明的返回值
            public static <?> void test2(List<?> list){

            }
     */

    class Test<T>{

    }
    /**不能用在创建泛型类
          class Test2<?>{

          }
    */
}

• 定义一个水果类-Fruit

package genericity_wildcard;
/**
 *  继承链
 *   Object
 *     | 
 *   Fruit
 *    /  \
 * Apple Pear
 *   |
 * FujiApple
 */
public class Fruit {
}
class Apple extends Fruit{
}
class Pear extends Fruit{
}
class FujiApple extends Apple{
}

• extends泛型的上限-Wildcard_Extends

package genericity_wildcard;

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 Wildcard_Extends {
    //泛型类
    static class Test<T extends Fruit>{
    }
    //? extends Fruit
    public static void test(List<? extends Fruit> list){
       /*
        *不能用于添加数据
        list.add(new Apple());
        list.add(new FujiApple());
        list.add(new Pear());
        list.add(new Fruit());
        */
        list.add(null);
    }

    public static void main(String[] args) {
        //extends 为上限
        @SuppressWarnings("unused")
        Test<Fruit> t1 =new Test<Fruit>();

        @SuppressWarnings("unused")
        Test<Apple> t2 =new Test<Apple>();

        @SuppressWarnings("unused")
        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
        @SuppressWarnings({ "unused", "rawtypes" })
        List<?> list5=new ArrayList();
        //test(list5);

        @SuppressWarnings("unused")
        List<? extends Object> list6=new ArrayList<Object>();
        //test(list6);

        List<FujiApple> app =new ArrayList<FujiApple>();        
        test(app);
    }
}

• super,泛型的下限-Wildcard_Super

package genericity_wildcard;



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

/**
 * super : 泛型的下限  >= 即父类或自身
 * 1、一般用于下限操作
 * 2、能够添加数据上面，不能添加父对象
 * 3、规则
 *  List<Fruit> -->List<? super Apple>
 *  List<Apple> -->List<? super Apple>
 *  List<? super Fruit> -->List<? super Apple>
 *  不能存放
 *  List<? super FujiApple> -->List<?super Apple>
 */

public class Wildcard_Super {
    public static void test(List<? super Apple> list){
        list.add(new Apple());
        list.add(new FujiApple());
        /**list.add(new Fruit());
         * 不能添加 父类对象*/

    }
    public static void main(String[] args) {
        // >= 即父类或自身
        List<Apple> list1 =new ArrayList<Apple>();
        test(list1);

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

        @SuppressWarnings("unused")
        List<? super FujiApple> list6 =new ArrayList<Object>();
        //test(list6);

        @SuppressWarnings("unused")
        List<?> list7 =new ArrayList<Object>();
        //test(list7);
    }
}

泛型的嵌套

• 学生类-Student

package genericity_nest;

public class Student<T> {
    private T score;
    public T getScore() {
        return score;
    }
    public void setScore(T score) {
        this.score = score;
    }
}

• 尚学堂学生类-BjsxtStudent

package genericity_nest;

public class BjsxtStudent<T> {
    private T stu;
    public T getStu() {
        return stu;
    }
    public void setStu(T stu) {
        this.stu = stu;
    }
}

• 嵌套测试类-TestNest

package genericity_nest;

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

public class TestNest {
    /** 泛型嵌套 -->由外到内拆分*/
    public static void main(String[] args) {
        Student<String> stu =new Student<String>();     
        stu.setScore("优秀");
        System.out.println(stu.getScore());

        //泛型嵌套
        BjsxtStudent<Student<String>> bjsxtstu =new BjsxtStudent<Student<String>>();
        bjsxtstu.setStu(stu);

        stu=bjsxtstu.getStu();
        String score =stu.getScore();
        System.out.println(score);


        //HashMap -->使用泛型嵌套
        Map<String,String> map =new HashMap<String,String>();
        map.put("a", "java300");
        map.put("b", "马士兵javase");

        Set<Entry<String,String>> entrySet= map.entrySet();
        for(Entry<String,String> entry:entrySet){
            String key =entry.getKey();
            String value =entry.getValue();
            System.out.println(key+"-->"+value);
        }
    }
}

泛型没有数组，没有多态

• 水果类-Fruit

package genericity_supplement;
/**
 *  继承链
 *   Object
 *     | 
 *   Fruit
 *    /  \
 * Apple Pear
 *   |
 * FujiApple
 */
public class Fruit {
}
class Apple extends Fruit{
}
class Pear extends Fruit{
}
class FujiApple extends Apple{
}

• 测试类-TestOthers

package genericity_supplement;

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

/**
 * 1、泛型没有多态
 * 2、泛型没有数组
 */

public class TestOthers {
    public static void main(String[] args) {
        //多态
        @SuppressWarnings("unused")
        Fruit f =new Apple();
        /** List<Fruit> list =new ArrayList<Apple>();
          * 泛型没有多态  
          */

        //使用通配符完成类似多态 
        @SuppressWarnings("unused")
        List<? extends Fruit> list =new ArrayList<Apple>();

        /**Fruit<String>[] arr =new Fruit<String>[10];
         * 泛型没有数组
         */

        //jdk1.7泛型简化
        @SuppressWarnings("unused")
        List<Fruit> list2 =new ArrayList<>();
    }
}