/*
        此程序实现一个队列和堆栈,实际上就是先进先出和先进后出。
*/
import java.util.*;
public class Steck
{
        private LinkedList link;
        Steck()
        {
                link = new LinkedList();
        }
        public void myAdd(Object obj)
        {
                link.addFirst(obj);
        }
        public Object myGet()
        {
                return link.removeFirst();
        }
        public boolean isNull()
        {
                return link.isEmpty();
        }
}

class TestSteck
{
        public static void main(String[] args)
        {
                Steck s = new Steck();
                s.myAdd("java01");
                s.myAdd("java02");
                s.myAdd("java03");
                s.myAdd("java04");
                while(!s.isNull())
                {
                        sop(s.myGet());  
                }
        }
        public static void sop(Object obj)
        {
                System.out.println(obj);
        }
       
}
这个程序我想让它应用泛型，搞了半天也搞不明白。求解？就是达到编译时不再提醒不安全。

1. import java.util.*;
   
2. 
   
3. class Fanshe<T> {
   
4.         private LinkedList<T> link;
   
5. 
   
6.         Fanshe() {
   
7.                 link = new LinkedList<T>();
   
8.         }
   
9. 
   
10.         public void myAdd(T o) {
    
11.                 link.addFirst(o);
    
12.         }
    
13. 
    
14.         public Object myGet() {
    
15.                 return link.removeFirst();
    
16.         }
    
17. 
    
18.         public boolean isNull() {
    
19.                 return link.isEmpty();
    
20.         }
    
21. }
    
22. 
    
23. class TestSteck {
    
24.         public static void main(String[] args) {
    
25.                 Fanshe<String> s = new Fanshe<String>();
    
26.                 s.myAdd("java01");
    
27.                 s.myAdd("java02");
    
28.                 s.myAdd("java03");
    
29.                 s.myAdd("java04");
    
30.                 while (!s.isNull()) {
    
31.                         sop(s.myGet());
    
32.                 }
    
33.         }
    
34. 
    
35.         public static void sop(Object obj) {
    
36.                 System.out.println(obj);
    
37.         }
    
38. }

复制代码

这样试试看

import java.util.*;

//在定义类时，就可以确定它的泛型。针对于这道题，可以直接确定泛型类型为String。
//不过，不确定时，可以写成: Fanshe<T>,  而创建引用时，也有也类的泛型一致。
class Steck<String> {

        private LinkedList<String> link;

        Steck() {
                link = new LinkedList<String>();
        }

  //添加第一个，因为，你已经确定添加字符串类型了。所以，这里可以直接传入字符串类型的。
        public void myAdd(String str) {
                link.addFirst(str);
        }

  //得到集合中第一元素的方法。
        public Object myGet() {
                return link.removeFirst();
        }

  //返回空
        public boolean isNull() {
                return link.isEmpty();
        }

}

class TestSteck {

        public static void main(String[] args) {
    //在这里创建类对象时，就传入了真正的类的泛型类型。
    //这样java虚拟机在编译时，就不会提示安全问题了。这个泛型在1.5版本后，就出现了。
                Steck<String> s = new Steck<String>();  //创建了类的对象。就会调用了无参的构造函数，返回的是一个new LinkedList<String>()；
   
                s.myAdd("java01");
                s.myAdd("java02");
                s.myAdd("java03");
                s.myAdd("java04");
    //判断如果不为空,就循环调用得到数组中每一个的元素。
                while (!s.isNull()) {
                        sop(s.myGet());
                }
        }
        public static void sop(Object obj) {
                System.out.println(obj);
        }

}
打印结果如图：

褚代江 发表于 2012-5-15 11:06
这样试试看

看来我还是太嫩了。。认识学一下泛型啦得。。