Java泛型基础学习

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

泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。
泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。

二、泛型的应用

泛型 : 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对这个类的属性没有什么影响。这就与我们泛型的实现原理—-类型擦除机制有关了

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

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

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

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

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

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

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

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

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

6，容易内存泄漏

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

五、泛型的上界

[java] view plain copy
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 Test {  
    public static void main(String[] args) {  
        Usr[] usr = new Usr[3];  
        usr[0] = new Usr("曹操","man",18);  
        usr[1] = new Usr("张飞","man",19);  
        usr[2] = new Usr("关羽","man",20);  
        //System.out.println(GnericAlg.<Usr>findMaxVal(usr));//如果没有指定泛型类型，泛型会通过参数类型自动推演  
        System.out.println(GnericAlg.findMaxVal(usr));  
    }  

}

运行结果：