泛型学习

 

泛型概念：<> 泛化类型

泛型作用：安全省心

具体使用：

1、自定义泛型

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

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

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

*只能用在抽象方法上

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

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

 

2、泛型继承、实现

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

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

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

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

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

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

b 接口为泛型接口

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

例1：

/**
 * 泛型父类
 * 1、保留父类泛型--->泛型子类
 * 2、不保留         ---->子类按需实现
 * 属性及方法类型 随位置而定
 * 子类重写方法的类型随父类
 * 子类中使用父类的属性随父类而定
 * @author qjc
 *
 * 2016-3-8
 */
public abstract class FanXinExtends<T1,T2> {
    T1 age;
    public abstract void test(T2 name);
}
//保留 ---泛型子类（也可以多个泛型）
//1)全部保留
class C1<T1,T2> extends FanXinExtends<T1, T2>{
    @Override
    public void test(T2 name) {  //只能是T2 
//        this.age ---Integer
    }
}
//2）部分保留
class C2<T2> extends FanXinExtends<Integer, T2>{
    @Override
    public void test(T2 name) {     //只能是T2 
//        this.age ---Integer
    }
}
//不保留 ---按需实现（也可以使泛型）
//1）具体类型
class C3 extends FanXinExtends<Integer, String>{
    @Override
    public void test(String name) {
//        this.age ---Integer
    }
}
//2）没有类型 擦除 Object
class C4 extends FanXinExtends{
    @Override
    public void test(Object name) {
//        this.age ---Object
    }
}

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：

/**
 *  继承链
 *   Object
 *     | 
 *   Fruit
 *    /  
 * Apple Pear
 *   |
 *  FujiApple
 * @author bj
 *
 */
public class Fruit {
 
}
class Apple extends Fruit{}
class Pear extends Fruit{}
class FujiApple extends Apple{}
 
 
/**
 * extends : 泛型的上限  <= 即子类或自身
 * 1、一般用于 限制操作
 * 2、不能使用在 添加数据上面，一般都是读取操作
 * 3、规则
 *  List<Fruit> -->List<? extends Fruit>
 *  List<Apple> -->List<? extends Fruit>
 *  List<? extends Apple> -->List<? extends Fruit>
 *  不能存放
 *  List<?>
 *  List<? extends Object>
 * @author qjc
 *
 * 2016-3-8
 */
public class ExtendsTest {
    public static void main(String[] args) {
        //extends 为上限
        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);
        // ? extends Apple 
        List<? extends Apple> list4 =new ArrayList<FujiApple>();
        test(list4);
        //? -->为什么错误 ,因为 ? 等同于 ? extends Object
        List<?> list5=new ArrayList<Object>();
        List<? extends Object> list6=new ArrayList<Object>();
        //test(list6);
        List<FujiApple> app =new ArrayList<FujiApple>();        
        test(app);
    }
    //? 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);
    }
    //泛型类
    static class Test<T extends Fruit>{
    }
}

6、下限 super : 指定的类型不能小于操作的类，即
T supperApper
? supper Apper
supper >= 不能添加父对象

例5：

/**
 * 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>
 * @author qjc
 *
 * 2016-3-8
 */
public class SuperTest {
 
    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);
        List<? super FujiApple> list6 =new ArrayList<Object>();
        //test(list6); 编译报错
        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());
    }
}

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