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