Java--泛型

一般的类和方法，只能使用具体的类型：要么是基本类型，要么是自定义的类。如果要编写可以应用于多种类型的代码，这种刻板的限制对代码的束缚就会很大。
泛型实现了参数化类型的概念，是代码可以应用于多种类型。“泛型”这个术语的意思是：“适用于许多许多的类型”。（Java编程思想）
Java泛型的核心概念：告诉编译器想使用什么类型，然后编译器帮你处理一切细节。

---

1、泛型的意义：
a.会对类型进行自动检查—–>编译的时候检查
b.会进行自动类型转换

用泛型实现栈：
< T > :T : 是一个类型占位符
2、 泛型的坑：
1、不能new泛型类型的数组 new T[2];

2、能不能new泛型类型的对象 T obj = new T();不能
3、能不能得到泛型类型的对象数组
4、简单类型不能作为泛型的参数
5、内存泄漏
6、 在static方法当中，不能用泛型类型的参数，static定义方法， 不依赖于对象 ，无法指定当前泛型的类型

class GenericAlg2{
    /**
     * 泛型方法
     * @param array
     * @return
     */
    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 GenericStack<T>{
    private T[] elem;
    private int top;

    public GenericStack(){
        this(10);
    }

    public GenericStack(int size){
        //this.elem = new T[size];//new Object[size];
        this.elem = (T[])new Object[size];//new GenericStack[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];
    }
}

class Animal{

}

public class GenericStackDemo {

    public static void main(String[] args) {
        GenericStack<Animal> s1 = new GenericStack<Animal>();
        s1.push(new Animal());
        s1.push(new Animal());
        s1.push(new Animal());
        s1.pop();

        //测试内存泄漏的方法
        System.gc();

        int a = 10;
        System.out.println(a);

    }


    public static void main1(String[] args) {

        GenericStack<Integer> s1 = new GenericStack<Integer>();
        s1.push(10);
        s1.push(20);
        //s1.push("hello");//

        int data = s1.getTop();
        //com.tulun.src.GenericStack@97d01f
        System.out.println(s1);
        GenericStack<String> s2 = new GenericStack<String>();
        System.out.println(s2);

        System.out.println(int.class);
        System.out.println(String.class);
        //System.out.println(GenericStack<Integer>.class);
        //<Integer>并没有参加类型的组成
        System.out.println(GenericStack.class);


        //====================
        //GenericStack<Integer>[] s3 = new GenericStack<Integer>[10];
        /*       又回来了 
        GenericStack s5 = new GenericStack();
        s5.push(10);
        s5.push(9.99);

        double data4 = (double)s5.getTop();*/

        //GenericStack<int> s6 = new GenericStack<int>();
    }
}

3、java泛型是如何编译的：类型擦除机制 ——>Object
向上擦除——>往基类方向进行擦除
4、泛型的上界：
T extends …. 泛型的上界 ,泛型是没有下界的