Java泛型

Java泛型

泛型 <T> : T :即是一个类型占位符  在编译的时候检查

在泛型之前多态算是一种泛式机制，例如可以将方法的参数类型设置为基类，那么该方法就可以接受从这个基类的任何子类作为参数，这样方法更具有通用性。（以一个通用栈为例子）

class ObjectStack{
	private Object[] elem;//Object类型的
	private int top;
	public ObjectStack(){
		this(10);
	}
	
	public ObjectStack(int size){
		this.elem = new Object[size];
		this.top = 0;
	}
	
	public void push(Object val){
		this.elem[this.top++] = val;
	}
	
	public void pop(){
		--this.top;
	}
	
	public Object getTop(){
		return this.elem[top-1];
	}
	
}

接下来对它进行操作

1，我们可以看到这块报错，虽然我们栈顶元素为double值，但是编译器并不能知道。所以这个时候我们需要进行强转。

2，假设我们是想将Integer型入栈，但是我们并不能阻止其它类型进行入栈。

所以我们引用了泛型这个神奇的东西！！！！

class GenericStack<T>{
	private T[] elem;
	private int top;
	
	public GenericStack(){
		this(10);
	}
	public GenericStack(int size){
		//this.elem = new T[size];
		this.elem = (T[])new Object[size];
		this.top = 0;
	}
	public void push(T val){
		this.elem[this.top++] = val;
	}
	public void pop(){
		//防止内存泄漏
		this.elem[this.top-1] = null;
		--this.top;
	}
	public T getTop(){
		return this.elem[this.top-1];
	}
}

这个时候如果我们要将其它类型入栈的时候就会发现编译器会报错。

泛型的实现原理

public static void main(String[] args) {
		GenericStack<Integer> s1 = new GenericStack<Integer>();
		GenericStack<String> s2 = new GenericStack<String>();
		System.out.println(s1);
		System.out.println(s2);
		System.out.println(s1.getClass()==s2.getClass());
	}

我们来看看运行结果

这个时候我们会发现<Integer>和<String>对这个类的属性没有什么影响。这就与我们泛型的实现原理----类型擦除机制有关了

在编译期间，所有的泛型信息都会被擦除，在编译后都会变成<Object>.          向上擦除--》往基类方向进行擦除

泛型的一些需要注意的地方

1，不能new泛型类型的数组 

2，不能new泛型类型的对象 T obj = new T();    

3，能不能 得到泛型类型的对象数组   GenericStack<T>[] a = new GenericStack<T>[10];   不可以！！！！

Java在运行时候泛型被擦除，所以泛型数组会转化为Object数组，编译器辨别不出具体类型，Integer和String不分，所以会引起类型不安全，所以编译器禁止你这样做

4，简单类型不能为泛型的参数

原因：(类型擦除往基类方向擦，简单类型无基类！！！！)

5，在static方法中，不能用泛型类型参数(static 不依赖对象，不能指定其泛型类型)

6，容易内存泄漏

 如果出栈的时候没有这一句

我们来执行以下语句（对它进行调试并查看内存）

GenericStack<Animal4> g1 = new GenericStack<Animal4>();
		
		g1.push(new Animal4());
		g1.push(new Animal4());
		g1.pop();
	     
		//jmap 命令检查内存泄漏
		System.gc();

//jps获得当前进程号

这个时候我们会发现Animal4对象时两个，也就是说并没有将这块内存进行释放回收！所以应该要注意内存泄露的问题

泛型的上界

class GnericAlg<T>{
	public T findMaxVal(T[] array){
		T maxVal = array[0];
		for(int i = 1;i < array.length;i++) {
			if(maxVal.compareTo(array[i]) < 0){//报错
				maxVal = array[i];
			}
		}
		return maxVal;
	}
	
}
public class Test12 {
	public static void main(String[] args) {
		Integer[] array = {10,20,30,1,2,0};
		GnericAlg<Integer> g1 = new GnericAlg<Integer>();
		System.out.println(g1.findMaxVal(array));
	}
}

这块报错是因为编译器擦除到Object ，但是Object并没有实现Comparable接口，所以就没有compareTo这个方法!!!!!

事实上Integer类实现了这个 接口，所以我们就引入了泛型上界让它擦除到指定的类即可。

<T extends Comparable>

class GnericAlg<T>{
	public static<T extends Comparable>T findMaxVal(T[] array){
		T maxVal = array[0];
		for(int i = 1;i < array.length;i++) {
			if(maxVal.compareTo(array[i]) < 0){
				maxVal = array[i];
			}
		}
		return maxVal;
	}
	
}
public class Test12 {
	public static void main(String[] args) {
		Integer[] array = {10,20,30,1,2,0};
		GnericAlg<Integer> g1 = new GnericAlg<Integer>();
		System.out.println(g1.findMaxVal(array));
	}
}

接下来用我们自定义的类实现一下

class GnericAlg<T extends Comparable<T>>{
	
	public static<T extends Comparable<T>> T findMaxVal(T[] array){//泛型方法！！！
		T maxVal = array[0];
		for(int i = 1;i < array.length;i++) {
			if(maxVal.compareTo(array[i]) < 0){
				maxVal = array[i];
			}
		}
		return maxVal;
	}
}
class Usr implements Comparable<Usr>{
	private String name;
	private String sex;
	private int age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public Usr(String name, String sex, int i) {
		super();
		this.name = name;
		this.sex = sex;
		this.age = i;
	}
	@Override
	public String toString() {
		return "Usr [name=" + name + ", sex=" + sex + ", age=" + age + "]";
	}
	@Override
	public int compareTo(Usr o) {//重写compareTo方法
		// TODO Auto-generated method stub
		return age > o.age ? 1 :(age == o.age) ? 0 : -1;
	}
	
	
}
public class Test22 {
	public static void main(String[] args) {
		Usr[] usr = new Usr[3];
		usr[0] = new Usr("加盟","woman",18);
		usr[1] = new Usr("加盟1","woman",19);
		usr[2] = new Usr("加盟2","woman",20);
		//System.out.println(GnericAlg.<Usr>findMaxVal(usr));//如果没有指定泛型类型，泛型会通过参数类型自动推演
		System.out.println(GnericAlg.findMaxVal(usr));
	}