泛型类

1，泛型表示的类型不能是基本类型，只能是引用类型,比如int，float等等都不可以作为泛型的类型，但是可以用相应的包装类代替，如int可以表示为Integer。String不是基本类型。
2，让方法局限在特定类型下：

//泛型类实例
public class test01 <T> {
    private T name;
    private T sex;

    public T getName() {
        return name;
    }

    public void setName(T name) {
        this.name = name;
    }


    public static void main(String[] args) {
        test01<String> test = new test01();
        test.setName("张三");
        System.out.println(test.getName());
    }
}

泛型方法

泛型方法可以用在非泛型的类中，使用方法是在放回类型之前加： <类型>
然后该类型就可以在这个函数中使用
如：

public <T> void fun(T e){}
public <T> String fun(T e){}

继承泛型类

已有泛型类 class abstract Father

擦除

使用，实现，继承父类时，父类没有指定泛型的类型
现在有泛型类Test：

public class Test <T> {
    T a;
    public <T> void test (T t){
        System.out.println(t);
    }
}

如果在使用时不指定T的类型，T的用法类似于Object类型，因此下面这段代码不会报错:

public static void main(String [] args){
        Test<Object> test = new Test<Object>();
        Test<String> test2 = new Test<String>();
        test.test(test2);
}

但是，不指定类型并不完全等同于Object，下面的代码执行时会因为类型不匹配而报错

    public static void ss(Test2<Object> t){}

    public static void main(String [] args){
        Test<String> test = new Test<Object>();
        ss(test); //报错
    }

通配符 ？

表示类型不确定，只能用于声明变量，不能用于创建对象，不能用于创建泛型类，不能用于泛型方法上。

List <?> list = new ArrayList<Integer>(); //正常
List <?> list4 = new ArrayList<?>(); //报错
public <?> void test2(String t){} //报错

上限

？ extends Fruit
表示Frut类型和Fruit类型的所有子类,子类的子类也可以，例如有下面的继承关系：

class Fruit{}
class Apple extends Fruit{}
class pear extends Fruit{}
class RedApple extends Apple{}

下面是使用时出现的几种情况。
？的效果等同于 ？ extends Object 。因此List<?> 与List<? extends Fruit>不匹配

    public static void test1(List<? extends Fruit> s){}

    public static void main(String[] args) {
        List<? extends Fruit> list1 = new ArrayList<Fruit>();
        List<? extends Apple> list2 = new ArrayList<RedApple>();
        List<?> list3 = new ArrayList<Fruit>();
        test1(list1);   //正常
        test1(list2);   //正常
        test1(list3);   //报错
    }

形参为List

    public static void test1(List<? extends Fruit> s){
        s.add(new Fruit()); //报错
    }

下限

super与extends相反。表示父类或自身。可能的几种情况：

    public static void test(List <? super Apple> s){}
    public static void main(String[] args) {
        List<Fruit> list1 = new ArrayList<Fruit>();
        List<RedApple> list2 = new ArrayList<RedApple>();
        List<? super Apple> list3 = new ArrayList<RedApple>(); //报错
        List<?> list4 = new ArrayList<Apple>();
        List<? super RedApple> list5 = new ArrayList<RedApple>();

        test(list1);        //正常
        test(list2);        //报错
        test(list4);        //报错
        test(list5);        //报错
    }

可以通过泛型的嵌套访问hashmap中的Entry

        Map<String,String> map = new HashMap();
        map.put("1", "a");
        map.put("2","b");
        Set<Entry<String,String>> s = map.entrySet();
        for(Entry<String,String> temp : s){
            System.out.println(temp.getValue());
        }