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{}
//因为不确定要存储的对象类型，所以为了通用定义成Object
class 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) {
		//在创建工具类对象之前就指定要操作的对象为Student
		Utils<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> {
	@Override
	public void show(String t) {
		System.out.println(t);
	}	
}
//实现这个接口的时候不知道要使用的类型，在创建对象的时候指定
class InterImpl<T> implements Inter<T> {
	@Override
	public 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>() {
			@Override
			public int compare(A o1, A o2) {
				// TODO Auto-generated method stub
				return 0;
			}
		});
	}
}

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