Java-泛型

在之前的堆栈中，我们只能存储int数据，如果需要存储Flost数据，就必须再定义一个堆栈，我们发现只是将其中的部分int改成了float，但是我们不得不重新写一遍

如果以后还要存储double/String…等类型怎么办？有没有一劳永逸的办法只写一遍呢？--泛型

代码如下：

public class FloatStack {
    public int size;//栈的长度
    privateint capacity;//栈的容量
    privateint top;//栈顶的位置
    privatefloat []data;//数据的存储空间

    public FloatStack(int capacity){
        data = new float[capacity];
        this.capacity= capacity;
        size = 0;
        top = -1;
    }

    public int getSize(){
        return size;
    }

    /**
     * 判断栈是否满了
     * @return
     */
    publicboolean isFull(){
        return size == capacity;
    }

    /**
     * 栈添加数据
     * @param num-待添加的数据
     * @return true-添加成功 false-添加失败
     */
    publicboolean push(float num){
        if(isFull()){
            returnfalse;
        }
        top++;
        data[top]= num;
        size++;

        returntrue;
    }

    /**
     * 判断栈是否为空
     * @return
     */
    publicboolean isEmpty(){
        return size == 0;
    }

    /**
     * 移除栈顶
     * @return true-移除成功 false-移除失败
     */
    publicfloat pop(){
        if(isEmpty()){
            returnsize;
        }
        float num = data[top];
        top--;
        size--;

        return num;
    }

    public void printn(){
        for (int i = size;i>0;i--){
            System.out.print(data[i-1]+",");
        }
    }
}

泛型的定义和使用

使用泛型定义一个通用型堆栈，也就是把刚才的特定类型改为某种“类型”，即泛指某种类型（这就是泛型的由来）。就那么一点小小的改动带来的却是本质性的变化---一劳永逸，体现了通用。

代码如下：

public class Test {
    public static void main(String[]args) {
        CommonStack<Integer> m=new CommonStack<Integer>(5);
        m.push(11);
        m.push(22);
        int n=m.pop();
        System.out.println(n);

        CommonStack<Float> m1=new CommonStack<Float>(6);
        m1.push(11.33f);
        m1.push(22.22f);

       float f=m1.pop();
        System.out.println(f);

        CommonStack<String> s3 = new CommonStack<String>(5);
        s3.push("aaa");
        s3.push("bbb");
        s3.push("ccc");
        System.out.println(s3.pop());
    }
}

使用泛型的时候需要指定具体类型

CommonStack<Integer> m=new CommonStack<Integer>(5);

这个叫类型参数化，也就是将类型作为参数，在此之前我们说的参数都是数据，只不过数据是有类型的，普通参数用“（）”，类型参数“ <> ”

猜你喜欢