泛型：将类型参数化

普通栈

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Stack

{

     private int[] m_item;

     public int pop(){...}

     public void Push(int item){...}

     public Stack(int i)

     {

          this.m_item = new int[i];

     }

}

数据类型Object来实现这个栈

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Stack

    {

        private object[] m_item;

        public object Pop(){...}

        public void Push(object item){...}

        public Stack(int i)

        {

            this.m_item = new[i];

        }

      }

使用泛型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//下面是用泛型来重写上面的栈，用一个通用的数据类型T来作为一个占位符，等待在实例化时用一个实际的类型来代替。让我们来看看泛型的威力：

public class Stack<T>

{

    private T[] m_item;

    public T Pop(){...}

    public void Push(T item){...}

    public Stack(int i){

         this.m_item = new T[i];

    }

}

比较

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//类的写法不变，只是引入了通用数据类型T就可以适用于任何数据类型，并且类型安全的。这个类的调用方法：

//实例化只能保存int类型的类

Stack<int> a = new Stack<int>(100);

   a.Push(10);

   a.Push("8888");//这行编译不通过，因为类a只接收int类型的数据

   int x = a.Pop();

Stack<String> b = new Stack<String>(100);

    b.Push(10);//这行编译不通过，因为类b只接收String类型的数据

   String y = b.Pop();