java编程之泛型（一）

第一部分 泛型出现的原因

---

   在java SE5之前，一般的类和方法只能使用具体的类型——基本类型或自定义类。但这不利于编写应用于多种类型的代码。
   虽然多态的出现在一定程度上解决了这种尴尬，但考虑到除了final类，其他任何类都能被扩展，这种灵活性会带来一些性能的损耗。
   接口也许是一种解决这种问题的好方式，可是一旦指明了接口，就会要求代码使用特定的接口。所以这也将为编写代码带来一定程度的限制。
   自 java SE5及之后的版本重大的变化之一就是添加了泛型的概念，泛型实现了*类型的参数化*，使得代码可以应用于多种类型。

---

第二部分 简单泛型

---

首先，看这样一个例子：

class AutoClass {}

//Holder只能持有单个对象，因此它的复用性很差
class Holder {
    private AutoClass a;
    public Holder(AutoClass a) {this.a = a;}
    AutoClass getA(){return a;}
}

要提高代码的重用性，可以不指定具体类型，利用泛型结构来定义类

//类型参数T用尖括号括住，放在类名后
class HolderGenerics<T>{
    private T t;
    public Generics(T t){this.t = t;}
    T getT(){return t;}
}  
public class Achieve{
    public static void main(String[] args){

//此处在使用时用具体类型AutoClass替换类型参数T
        HolderGenerics<AutoClass> hg = new HolderGenerics<AutoClass>(AutoClass a);
    }
}

1、元组类库

---

    元组：将一组对象打包存储于一个单一的容器对象，容器对象允许读取其中元素，但不允许向其中存放新的对象。
    元组可以是任意长度，任意类型的。

//二维元组

public class TwoTuple<A,B>{
/*此处未将字段first和second声明为private，并不违反安全性原则
原因是final声明不允许再为first，second赋予其他的值*/
    public final A first;
    public final B second;
    public TwoTuple(A a,B b){
        first = a;
        second = b;
    } 
}

//多维元组
//可以利用继承机制增加元组长度

public class ThreeTuple<A,B,C> extends TwoTuple<A,B>{
    public final C third;
    public ThreeTuple(A a,B b,C c){
        super(a,b);
        this.third = c;
    }
} 

2、堆栈类

---

传统的堆栈可以用LinkedList实现

import java.util.LinkedList;

public class Stack<T> {
    private LinkedList<T> storage= new LinkedList<T>();

    //Stack方法调用LinkedList中的方法

    public void push(T v){storage.addFirst(v);}
    public T peek(){return storage.getFirst();}
    public T pop(){return storage.removeFirst();}
    public boolean empty(){return storage.isEmpty();}
    public String toString(){return storage.toString();}
}

不用LinkedList来实现内部链式存储机制

public class OwnStack<T> {
    private static class Node<U> {
        U item;
        Node<U> next;

        Node() {
            item = null;
            next = null;
        }

        Node(U item, Node<U> next) {
            this.item = item;
            this.next = next;
        }

        boolean end() {
            return item == null && next == null;
        }
    }

    private Node<T> top = new Node<T>();
    //入栈方法
    public void push(T item) {
        top = new Node<T>(item, top);
    }
    //出栈方法
    public T pop() {
        T result = top.item;
        if (!top.end())
            top = top.next;
        return result;
    }
}