Java基础_08_Java泛型

_____Java泛型_____

泛型的概述

JDK1.5版本以后出现的新特性，用于解决安全问题，是一个类型安全机制。

优点：

1.将运行时期出现的ClassCastException，转移到了编译时期。
2.避免了大量的强制转换。

泛型的使用

简单使用：

//JDK1.5版本以前的代码public class Demo {    public static void main(String[] args) {        List list = new ArrayList();        list.add("beijing");        list.add("shanghai");        list.add(100);        for (int i = 0; i < list.size(); i++) {        //下面代码在i=2时，就会出现“java.lang.ClassCastException”异常        //此类型错误在编译阶段是不能被发现的            String name = (String) list.get(i);            System.out.println("name:" + name);        }    }}//JDK1.5版本以后的代码public class Demo {    public static void main(String[] args) {    //加上了泛型限定，这样list中只能加入指定类型或其子类，当然这里String是final修饰类，不存在子类        List<String> list = new ArrayList<String>();        list.add("beijing");        list.add("shanghai");        list.add(100);//这里编译不通过        for (int i = 0; i < list.size(); i++) {        //指定了泛型类型后就不再需要强制转换了            String name = list.get(i);            System.out.println("name:" + name);        }    }}

泛型类：

创建一个存储对象的工具类：
未使用泛型之前：

class Student{}class Worker{}//因为不确定要存储的对象类型，所以为了通用定义成Objectclass Utils {private Object obj;public void set(Object obj) {this.obj = obj;}public Object get() {return obj;}}public class Demo {public static void main(String[] args) {Utils utils = new Utils();utils.set(new Student());//这里需要程序员主观判断强转Student stu = (Student)utils.get();//这里在编译时通过，运行时候异常Worker wor = (Worker)utils.get();}}

使用泛型后：

//定义一个泛型类class Utils<T> {private T t;public void set(T t) {this.t = t;}public T get() {return t;}}public class Demo {public static void main(String[] args) {//在创建工具类对象之前就指定要操作的对象为StudentUtils<Student> utils = new Utils<Student>();utils.set(new Student());//指定了泛型就不需要强转了Student stu = utils.get();//这里在编译时期就会报错Worker wor = utils.get();}}

泛型方法：

对于泛型类有个局限性，当创建时指定了类型后就不能改变，在某些时候就显得不方便，如下：
我们创建一个控制台打印的工具类：
使用泛型类：

class Utils<T> {public void out(T t) {System.out.println(t);}}public class Demo {public static void main(String[] args) {Utils<Student> utils = new Utils<Student>();utils.out(new Student());//这里在编译时会报错，我们想要打印Worker对象就必须再次创建一个针对于Worker的工具类utils.out(new Worker());}}

使用泛型方法：

//在方法的返回值前面什么泛型class Utils {public <T> void out(T t) {System.out.println(t);}}public class Demo {public static void main(String[] args) {Utils utils = new Utils();//这样在使用方法时泛型才会被明确，比泛型类方便utils.out(new Student());utils.out(new Worker());}}

注意：静态方法不能使用类上定义的泛型！

泛型接口：

/和泛型类的定义相似interface Inter<T> {void show(T t);}//实现这个接口的时候知道要使用的类型class InterImpl implements Inter<String> {@Overridepublic void show(String t) {System.out.println(t);}}//实现这个接口的时候不知道要使用的类型，在创建对象的时候指定class InterImpl<T> implements Inter<T> {@Overridepublic void show(T t) {System.out.println(t);}}

泛型限定：

通配符：?    指代任意类型
泛型的限定上限：<? extends E>    接受E或者E的子类型。
泛型的限定下限：<? super E>    接收E或者E的父类。

具体事例：

我们用TreeSet的两个构造方法为例：

//1.TreeSet(Collection<? extends E> c)class A{}class B extends A{}public class Demo {public static void main(String[] args) {TreeSet<A> tree = new TreeSet<>(new ArrayList<B>());}}

向上转型为安全的，所以我们在创建一个TreeSet的时候可以传入元素类型为其子类的元素，所以知识限定了上线。

//2.TreeSet(Comparator<? super E> comparator)class A{}class B extends A{}public class Demo {public static void main(String[] args) {TreeSet<B> tree = new TreeSet<>(new Comparator<A>() {@Overridepublic int compare(A o1, A o2) {// TODO Auto-generated method stubreturn 0;}});}}

同样的上转型安全，但是与前面的不同的是，这个是要将TreeSet中的元素传递到Comparator比较器中进行比较，所以限定了Comparator的下线。