在之前的堆栈中,我们只能存储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);
这个叫类型参数化,也就是将类型作为参数,在此之前我们说的参数都是数据,只不过数据是有类型的,普通参数用“()”,类型参数“ <> ”