Java学习笔记——泛型

唧唧复唧唧

　　　　——木兰诗

冗长的代码实在无趣,这就是为什么程序员会连自己写的代码都不愿意去看.看了就头痛,代码整洁才是关键.

一、什么是泛型？为什么要使用泛型？

且看代码：

public class GenericsDemo {

    public static void main(String[] args) {
        List list = new ArrayList<>();
        list.add("1");
        list.add("2");
        list.add("3");
        list.add(5);//不小心把Integer丢进了集合中
        //编译不报错，运行时发生java.lang.ClassCastException异常
        list.forEach(str -> System.out.println((String)str));
    }
}

第8行代码不小心把Integer丢了进去，会引发ClassCastException

使用了泛型后：

public class GenericsDemo {

    public static void main(String[] args) {
        
        List<String> list = new ArrayList<>();
        list.add("1");
        list.add("2");
        list.add(3);//不小心把Integer丢进了集合中,编译报错
    }
}

第一段代码可能引发运行时异常ClassCastException的代码，在上面代码中直接编译报错了。

public class GenericsDemo {

    public static void main(String[] args) {
        
        List<String> list = new ArrayList<>();
        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        list.forEach(str -> System.out.print(str));
    }
}

发现了么，第10行不用吧str强制转换为String类型了。

public class GenericsDemo {

    public static void main(String[] args) {
        Object o = new Integer(10);
        Float f = (Float)o;
    }
}

程序在编译时并不知道你到底传了什么类型的变量。由于多态（想想猫和狗的例子），程序运行的的时候可能发生类型转换异常。

为了避免ClassCastException运行时异常，Java引入泛型机制。

使用泛型的好处：

1、避免了ClassCastException

2、免去了大量的强制转换

二、定义泛型类和泛型接口

上代码：

使用泛型定义类（泛型定义接口的道理是一样的）

public class Bag <T>{

    private T content;

    Bag(T content) {
        this.content = content;
    }

    T getContent() {
        return content;
    }

    void setContent(T content) {
        this.content = content;
    }
}

这里想下普通的定义方法，T是特定的类型（比如String）。这里的T可以是任意类型，类型范围很广。

public class TestBag {

    public static void main(String[] args) {
        Bag<String> bag = new Bag<String>("book");
        Integer cintent = bag.getContent();//编译出错
        String content1 = bag.getContent();
    }
}

三、使用extends关键字限定类型参数

上代码：

public class LimitBag <T extends Number>{

    private T content;

    LimitBag(T content) {
        this.content = content;
    }

    T getContent() {
        return content;
    }

    void setContent(T content) {
        this.content = content;
    }
}

public class TestBag {

    public static void main(String[] args) {
    
        LimitBag<String> bag = new LimitBag<String>("book");//编译出错
        LimitBag<Integer> bag2 = new LimitBag<Integer>(1);//合法
    }
}

四、定义泛型数组

上代码：

public class GenericArray<T> {

    private T[] content;

    GenericArray(T[] content) {
        this.content = content;
    }

    T[] getContent() {
        return content;
    }

    void setContent(T[] content) {
        this.content = content;
    }
    
}

public class TestBag {

    public static void main(String[] args) {
                
        String[] content = {"1","2","3"};
        GenericArray<String> ss= new GenericArray<>(content);
        for (String item : ss.getContent()) {
            System.out.println(item);
        }
    }
}

五、定义泛型方法

上代码：

public class MethodTest {

    public static <E> void printArray(E[] arr){
        for (E item : arr) {
            System.out.println(item);
        }
    }
    public static <T extends Comparable<T>> T max(T x,T y){
        return x.compareTo(y)>0?x:y;
    }
    public static void main(String[] args) {
        Integer[] arr = {1,2,3};//必须是包装类
        printArray(arr);
        System.out.println(max("B", "a"));
    }
    
}

 六、问号通配符

上代码

public class WildCast {

    public static void main(String[] args) {
        Set<String> set = new HashSet<String>();//向上转型
        //HashSet<Object> set = new HashSet<String>();//编译出错Type mismatch，泛型Object和泛型String之间不存在继承关系
    }
}

 在看下面代码：

public class WildCast {

    public static void main(String[] args) {
        
        List<Integer> list = new ArrayList<>();
        list.add(11);
        print(list);//编译出错
        printNew(list);
    }

    private static void printNew(Collection<?> collection) {
        // TODO Auto-generated method stub
        collection.forEach(obj -> System.out.println(obj));
    }

    private static void print(Collection<Object> collection) {
        // TODO Auto-generated method stub
        collection.forEach(obj -> System.out.println(obj));
    }
}

泛型<Integer>和泛型<Object>没有继承关系，不能传递。所以使用通配符<?>