泛型

使用泛型的优点：

1. 使用Java的泛型可以在编译时检测出错误。
2. 省心，取出元素时不用类型

List<String> list=new ArrayList<>();
//list.add(1);编译时类型检查出错误
list.add("so easy");
list.get(0);//取出时不再需要类型转换

使用泛型的一些限制：

1. 不能使用 new E()以及new E[]; 泛型存在于编译时，一旦编译器认为泛型类型是安全的，就会将它转换为原始类型（Object）
2. 在静态上下文中不允许类的参数是泛型类型
   例如：

public static void m(E o1){
}

以及

private static T test

都是错误的；<font color=red>因为所有的泛型实例在运行时都用同一个运行时类，所以泛型的静态变量和方法是被它的所有实例所共享的，所以在静态方法、数据域或者初始化语句中为类引用泛型类型参数是非法的。</font>

为什么说“所有的泛型实例在运行时都用同一个运行时类”，如下代码证明：

【编译时ArrayList<String>,ArrayList<Integer>是两种不同的类型，但在运行时只有一个ArrayList加载到JVM中】
public static void main(String[] args) {
        ArrayList<String> list1=new ArrayList<>();
        ArrayList<Integer> list2=new ArrayList<>();
        System.out.println(list1 instanceof ArrayList);
        System.out.println(list2 instanceof ArrayList);
    }

3.在声明时指定类型，但不能是基本类型

泛型方法：

非泛型类中定义泛型方法 在返回类型前面加入泛型，可以使用extends让泛型局限于某些类型下,从而使泛型具有该类型的特性

public class Method3 {
    public static <T> void  test(T t){
        System.out.println(t);
    }
    //可以使用extends让泛型局限于某些类型下
    public static <T extends List> void test1(T t){
        t.add("I love you");
        System.out.println(t.get(0));
    }
    public static void main(String[] args) {
        test("I love you");
        test(1024);
        ArrayList list=new ArrayList();
        test1(list);
    }
}

泛型的继承：

泛型的继承
* 1.保留父类的泛型，泛型子类
* 2.不保留父类泛型，子类按需实现即可，可以是泛型类也可以是非泛型类
* 3.子类也可以扩展自己的泛型也可以
* 4.子类重写的方法的泛型类型取决于父类中该方法的泛型类型
* 5.子类中使用父类的属性随父类而定
* 6.子类新增方法或属性的类型由子类自己决定

public abstract class Father4<T1, T2>{
    T1 age;
    public abstract void test(T2 name);

}
/*
 * 保留-->泛型子类
 */
//1）全部保留
class c1<T1, T2> extends Father4<T1, T2>{
    @Override
    public void test(T2 name) {
        //this.age-->T1 
    }
}
//2）部分保留
class c2<T2> extends Father4<Integer, T2>{
    @Override
    public void test(T2 name) {
        //this.age-->Integer    
    }
}

/*
 * 不保留--》按需实现
 */
//1）指定具体类型
class c3 extends Father4<Integer, String>{

    @Override
    public void test(String name) {
        //this.age-->Integer    
    }   
}
//2）没有类型，擦除泛型，擦出后相当于Object
class c4 extends Father4{
    @Override
    public void test(Object name) {
        //this.age-->Object
    }   
}

class c5<T1, T2, A, B> extends Father4<T1, T2>{
    @Override
    public void test(T2 name) {
        //this.age-->T1
    }   
}

泛型接口与泛型类同理

“?“ 通配符：类型不确定，用于声明变量|形参
1、变量的类型（局部变量&成员变量）

List<? extends Fruit> list1 =new ArrayList<Fruit>();

2、方法形参的类型

public stati cvoid test(List<?> list)

extends: 泛型的上限

public class Fruit8 {

}
class Apple extends Fruit8{}
class Pear extends Fruit8{}
class FujiApple extends Apple{}

===================================

public class ExtendsTest8 {

    public static void main(String[] args) {
        Test<Fruit8> t1=new Test<Fruit8>();
        Test<Apple> t2=new Test<Apple>();
        Test<Pear> t3=new Test<Pear>();
        Test<FujiApple> t4=new Test<FujiApple>();

        //调用方法
        List<? extends Fruit8> list1=new ArrayList<Fruit8>();
        test(list1);
        List<Apple> list2=new ArrayList<Apple>();
        test(list2);

        //? extends Apple
        List<? extends Apple> list4=new ArrayList<FujiApple>();
        test(list4);

        //?-->为什么错误
        List<?> list5=new ArrayList<Apple>();
        //test(list5);
        List<?> list6=new ArrayList<Object>();
        //test(list6);
        //? 相当于任何类型的对象都可以，假设对象超出Fruit8，如Object，
        //所以  声明对象时用 ，即使创建对象时使用的泛型在Fruit8内也不行

    }

    //? extends Fruit8
    public static void test(List<? extends Fruit8> list){

        //不能向list添加任何对象
        //list.add(new Apple());
        //list.addAll(new Pear());
        list.add(null);
    }

}
class Test<T extends Fruit8>{}//extends表示泛型上限为Fruit8，T可以是所有Fruit8的子类

super:　泛型的下限

public class SuperTest {
    public static void test(List<? super Apple> list){
        //只能添加子对象和自己
        list.add(new Apple());
        list.add(new FujiApple());
        //list.add(new Pear());
        //list.add(new Fruit8());

    }

    public static void main(String[] args) {
        List<Apple> list1=new ArrayList<Apple>();
        List<Fruit8> list2=new ArrayList<Fruit8>();
        List<Object> list3=new ArrayList<Object>();
        List<? super Apple> list4=new ArrayList<Apple>();
        List<? super Fruit8> list5=new ArrayList<Fruit8>();

        List<FujiApple> list6=new ArrayList<FujiApple>();
        List<Pear> list7=new ArrayList<Pear>();

        //规则
        //apple为下限，Apple的父类以及超类均可以，子类和与Apple同属于一个父类的其他类不可以
        test(list1);
        test(list2);
        test(list4);
        test(list5);
        //test(list6);
        //test(list7);
    }