【泛型】为什么是泛型？

      需求：先需编写一个程序，用栈（Stack）进行进栈和出栈操作，并对栈中的元素进行运算。
方案一：假设元素为int类型，则可使用代码：

Code:

1. class Stack   
2. {   
3.     private int[] items;   
4.     private int count;   
5.        
6.     public Stack(int size)   
7.     {   
8.         items=new int [size];   
9.         count=0;   
10.     }   
11.        
12.     public void Push(int x)   
13.     {   
14.         items[count++]=x;   
15.     }   
16.        
17.     public int Pop()   
18.     {   
19.         return items[--count];   
20.     }   
21. }   

客户代码：

Code:

1. class Test   
2. {   
3.     static    void Main()   
4.     {   
5.         Stack s=new Stack (10);   
6.         s.Push(111);   
7.         s.Push(222);   
8.         Console.WriteLine (s.Pop ()+s.Pop ());   
9.     }   
10. }   

然而，现在需求发生变化。客户要求使用double类型，甚至还要支持string！这样考虑用到弱类型object。
修改代码如下：

Code:

1. class Stack   
2. {   
3.     private object[] items;   
4.     private int count;   
5.        
6.     public Stack(int size)   
7.     {   
8.         items=new object [size];   
9.         count=0;   
10.     }   
11.        
12.     public void Push(object x)   
13.     {   
14.         items[count++]=x;   
15.     }   
16.        
17.     public object Pop()   
18.     {   
19.         return items[--count];   
20.     }   
21. }   

 

//  客户代码

Code:

1. class Test   
2. {   
3.     static    void Main()   
4.     {   
5.         Stack s=new Stack (10);   
6.         s.Push("111");   
7.         s.Push("222");   
8.         Console.WriteLine ((string)s.Pop ()+(string)s.Pop ());   
9.     }   
10.   

运行结果：

这样的解决方法看似可以，但是对类型的不断封箱和拆箱会降低程序性能，而且很容易写出能通过编译但是不能运行的代码！

       这个时候 ，泛型该出场了！
泛型使用代码如下：

Code:

1. class Stack<T>   
2. {   
3.     private T [] items;   
4.     private int count;   
5.        
6.     public Stack(int size)   
7.     {   
8.         items=new T[size];   
9.     }   
10.        
11.     public void Push(T x)   
12.     {   
13.         items[count++]=x;   
14.     }   
15.        
16.     public  T Pop()   
17.     {   
18.         return items[--count];   
19.     }   
20. }   
21. class Test   
22. {   
23.     static void Main()   
24.     {   
25.         //    int   
26.         Stack<int> s1=new Stack<int> (10);   
27.         s1.Push (111);   
28.         s1.Push (222);   
29.         Console.WriteLine (s1.Pop ()+s1.Pop ());   
30.            
31.         //    double   
32.         Stack<double> s2=new Stack<double> (10);   
33.         s2.Push (111.1);   
34.         s2.Push (222.2);   
35.         Console.WriteLine (s2.Pop ()+s2.Pop ());   
36.   
37.         // string    
38.         Stack<string > s3=new Stack<string > (10);   
39.         s3.Push ("111");   
40.         s3.Push ("222");   
41.         Console.WriteLine (s3.Pop ()+s3.Pop ());   
42.     }   
43. }   

输出结果 ：