泛型学习

泛型概念：<> 泛化类型

泛型作用：安全省心

具体使用：

1、自定义泛型

1）泛型类：类<字母> T E K V

*只能用在成员变量上，只能使用引用类型

2）泛型接口：接口<字母,…>

*只能用在抽象方法上

3）泛型方法：<字母，…>

泛型不能定义在静态属性上（静态方法可以）
<T extends List> :规范类型只能是List子类

2、泛型继承、实现

a父类为泛型类，子类继承时：

1）父类 | 擦除 | 指定类型，子类按需编写

2）父类存在泛型，子类必须>=

3）属性类型：根据所在位置而定

父类中，随父类而定
子类中，随子类而定

4）重写方法类型：随父类而定

b 接口为泛型接口

与继承同理，重写方法随接口而定

例1：

 1 /**
 2  * 泛型父类
 3  * 1、保留父类泛型--->泛型子类
 4  * 2、不保留         ---->子类按需实现
 5  * 属性及方法类型 随位置而定
 6  * 子类重写方法的类型随父类
 7  * 子类中使用父类的属性随父类而定
 8  * @author qjc
 9  *
10  * 2016-3-8
11  */
12 public abstract class FanXinExtends<T1,T2> {
13     T1 age;
14     public abstract void test(T2 name);
15 }
16 //保留 ---泛型子类（也可以多个泛型）
17 //1)全部保留
18 class C1<T1,T2> extends FanXinExtends<T1, T2>{
19     @Override
20     public void test(T2 name) {  //只能是T2 
21 //        this.age ---Integer
22     }
23 }
24 //2）部分保留
25 class C2<T2> extends FanXinExtends<Integer, T2>{
26     @Override
27     public void test(T2 name) {     //只能是T2 
28 //        this.age ---Integer
29     }
30 }
31 //不保留 ---按需实现（也可以使泛型）
32 //1）具体类型
33 class C3 extends FanXinExtends<Integer, String>{
34     @Override
35     public void test(String name) {
36 //        this.age ---Integer
37     }
38 }
39 //2）没有类型 擦除 Object
40 class C4 extends FanXinExtends{
41     @Override
42     public void test(Object name) {
43 //        this.age ---Object
44     }
45 }

3、泛型擦除

例2:

/**
 * 泛型的擦除：使用 | 实现 | 继承 没有指定类型
 * 类似于Object 不等同于 Object
 * @author qjc
 *
 * 2016-3-8
 */
public class TestStudent {
    public static void test(Student<Integer> stu){}
    public static void main(String[] args) {
        //擦除 -->没有指定泛型具体类型
        Student stu = new Student<>();
        stu.setName(25);    // int-->Integer-->Object
        Object obj = stu.getName();
        stu.setName("aa"); 
        test(stu); //编译不会类型检查
        Student<Object> stu2 = new Student<Object>();
//        test(stu2); --编译不通过
    }
}
class Student<T> {
    private T name;
    public T getName() {
        return name;
    }
    public void setName(T name) {
        this.name = name;
    }
}

4、？通配符 -->类型不定，声明变量上

1）T、K、V、E等泛型字母有类型，类型参数富裕具体的值

2）？未知类型类型参数赋予不确定值，任意类型

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

例3：

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

5、上限 extends ：指定的类型必须是继承某个类，或者实现某个接口（不是implements）即

？ extends Fruit

？ extends List

extends <= 不能添加信息

例4：

 1 /**
 2  *  继承链
 3  *   Object
 4  *     | 
 5  *   Fruit
 6  *    /  
 7  * Apple Pear
 8  *   |
 9  *  FujiApple
10  * @author bj
11  *
12  */
13 public class Fruit {
14  
15 }
16 class Apple extends Fruit{}
17 class Pear extends Fruit{}
18 class FujiApple extends Apple{}
19  
20  
21 /**
22  * extends : 泛型的上限  <= 即子类或自身
23  * 1、一般用于 限制操作
24  * 2、不能使用在 添加数据上面，一般都是读取操作
25  * 3、规则
26  *  List<Fruit> -->List<? extends Fruit>
27  *  List<Apple> -->List<? extends Fruit>
28  *  List<? extends Apple> -->List<? extends Fruit>
29  *  不能存放
30  *  List<?>
31  *  List<? extends Object>
32  * @author qjc
33  *
34  * 2016-3-8
35  */
36 public class ExtendsTest {
37     public static void main(String[] args) {
38         //extends 为上限
39         Test<Fruit> t1 =new Test<Fruit>();
40         Test<Apple> t2 =new Test<Apple>();
41         Test<Pear> t3 =new Test<Pear>();
42  
43         //规则 
44         List<? extends Fruit> list1 =new ArrayList<Fruit>();
45         test(list1);
46         List<Fruit> list2 =new ArrayList<Fruit>();
47         test(list2);
48         List<Apple> list3 =new ArrayList<Apple>();
49         test(list3);
50         // ? extends Apple 
51         List<? extends Apple> list4 =new ArrayList<FujiApple>();
52         test(list4);
53         //? -->为什么错误 ,因为 ? 等同于 ? extends Object
54         List<?> list5=new ArrayList<Object>();
55         List<? extends Object> list6=new ArrayList<Object>();
56         //test(list6);
57         List<FujiApple> app =new ArrayList<FujiApple>();        
58         test(app);
59     }
60     //? extends Fruit
61     public static void test(List<? extends Fruit> list){
62         /*
63         //不能用于添加数据
64         list.add(new Apple());
65         list.add(new FujiApple());
66         list.add(new Pear());
67         list.add(new Fruit());
68         */
69         list.add(null);
70     }
71     //泛型类
72     static class Test<T extends Fruit>{
73     }
74 }
75 
76 6、下限 super : 指定的类型不能小于操作的类，即
77 T supperApper
78 ? supper Apper
79 supper >= 不能添加父对象

例5：

 1 /**
 2  * super : 泛型的下限  >= 即父类或自身
 3  * 1、一般用于 下限操作
 4  * 2、能够添加数据上面，不能添加父对象
 5  * 3、规则
 6  *  List<Fruit> -->List<? super Apple>
 7  *  List<Apple> -->List<? super Apple>
 8  *  List<? super Fruit> -->List<?super Apple>
 9  *  不能存放
10  *  List<? super FujiApple> -->List<?super Apple>
11  * @author qjc
12  *
13  * 2016-3-8
14  */
15 public class SuperTest {
16  
17     public static void main(String[] args) {
18         // >= 即父类或自身
19         List<Apple> list1 =new ArrayList<Apple>();
20         test(list1);
21         List<Fruit> list2 =new ArrayList<Fruit>();
22         test(list2);
23         List<Object> list3 =new ArrayList<Object>();
24         test(list3);
25         //规则
26         List<? super Apple> list4 =new ArrayList<Apple>();
27         test(list4);
28         List<? super Fruit> list5 =new ArrayList<Object>();
29         test(list5);
30         List<? super FujiApple> list6 =new ArrayList<Object>();
31         //test(list6); 编译报错
32         List<?> list7 =new ArrayList<Object>();
33         //test(list7); 编译报错
34  
35     }
36     public static void test(List<? super Apple> list){
37         //不能添加 父类对象
38         list.add(new Apple());
39         list.add(new FujiApple());
40         //list.add(new Fruit());
41     }
42 }

7、泛型的嵌套--由外到内获取即可。如：HashMap的遍历

8、泛型没有多态也没有泛型数组

例6：

/**
 * 1、泛型没有多态
 * 2、泛型没有数组
 * @author qjc
 *
 * 2016-3-8
 */
public class Others {
    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>[10];
        //jdk1.7泛型简化
        List<Fruit> list2 =new ArrayList<>();
    }
}