和Java泛型谈谈

泛型，把类型参数化。
泛型的命名规则：
不要小写字母表示泛型名字，虽然这也没什么错。如果可以的话，泛型就用“T”来表示。
还有就是类上的泛型和方法上的泛型，名字尽量不要相同。

它在JDK1.5之后出现，主要的作用是解决安全问题
比如下面的安全问题：

private static void method_1() {
        ArrayList al=new ArrayList();
        al.add("abc01");
        al.add("abc0991");
        al.add("abc014");
        al.add(4);
        Iterator it=al.iterator();
        while(it.hasNext()){
            String next=(String)it.next();
            System.out.println(next);
        }
    }

ArrayList可以添加任何类型的元素，该方法在程序编译时并不会出现问题。但是在迭代取值时，Integer类型的值无法转换为String，会出现ClassCastException异常。

而避免这种问题的，就是指定ArrayList的元素的类型，把类型参数化。比如这样：

ArrayList<String> al=new ArrayList<String>();
al.add("abc01");
al.add("abc0991");
al.add("abc014");
//al.add(4);    编译时提示错误

本例子中，泛型可以把一些错误提前到了编译时期，方便了调试。而且在迭代时，不再需要强制转化。

Iterator<String> it=al.iterator();
while(it.hasNext()){
    System.out.println(it.next());
}

---

1，泛型定义在类上
ArrayList类上的泛型

public class ArrayList<E> extends AbstractList<E>

ArrayList al=new ArrayList();
传递进去的类的泛型是String，而定义在类上的泛型，在整个类中都是有效的。
类上的泛型可以由一个也可以由多个：

class GenericForClass1<T>{
        private T temp;

        private void set(T t){
            this.temp=t;
        }

        private T get(){
            return temp;
        }

        private void print(){
            System.out.println(temp);
        }
    }

    private void generic_1() {
        GenericForClass1<Integer> generic=
                new GenericForClass1<Integer>();
        generic.set(1);
        generic.print();
    }

class GenericForClass2<T1,T2>{
        private T1 t1;
        private T2 t2;

        private void setT1(T1 t){
            this.t1=t;
        }

        private T1 getT1(){
            return t1;
        }

        private void setT2(T2 t){
            this.t2=t;
        }

        private T2 getT2(){
            return t2;
        }

        private void print(){
            System.out.println(t1+"----"+t2);
        }
    }

private void generic_1() {
        GenericForClass2<Integer,String> generic=
            new GenericForClass2<Integer,String>();
        generic.setT1(1);
        generic.setT2("ronaldo");
        generic.print();
    }

2，泛型定义在方法上

class GenericForClass1<T>{
        private T temp;

        private void set(T t){
            this.temp=t;
        }

        private T get(){
            return temp;
        }

        private void print(){
            System.out.println(temp);
        }
    }

泛型定义在类上后，操作的类型就固定了。比如下面的写法就有问题：

    GenericForClass1<Integer> generic=
                    new GenericForClass1<Integer>();
    eneric.set("1");//编译出错

为了让不同的方法操作不同的类型，我们可以不把泛型定义在类上，而是定义在方法上。
注意的是泛型如果定义在方法上，只对该方法是有效的。
如下：

class GenericForClass1{
        private <T>void show(T t){
            System.out.println(t);
        }
    }

private void generic_1() {
        GenericForClass1 generic=
                new GenericForClass1();
        generic.show("1");
        generic.show(1);
    }

当然也可以在类上定义泛型，而在方法上也定义泛型来操作不同类型。如：

class GenericForClass1<T>{
        private T t;

        private void set(T t){
            this.t=t;
        }

        private T get(){
            return t;
        }

        private void print(){
            System.out.println(t);
        }

        private <S>void show(S s){
            System.out.println(s);
        }
    }

private void generic_1() {
        GenericForClass1<Integer> generic=
                new GenericForClass1<Integer>();
        generic.set(1);
        generic.set("1");//编译错误，set方法的泛型和类是绑定的
        generic.print();
        generic.show("1");
    }

---

静态方法的泛型：

class Demo1<T>{     
        private void show(T t){
            System.out.println(t);
        }

        private <T>void set(T t){
            System.out.println(t);
        }

        //编译时会出现错误
        private static <T> void method(T t){
            System.out.println(t);
        } 
    } 

静态方法访问类上的泛型，编译出错。原因是，建立对象后才会有泛型。
比如ArrayList al=new ArrayList();
我们知道静态成员是先加载的。
既然静态方法无法访问类上的泛型，我们可以为它在方法上定义泛型。

private static <S>  void method(S s){
            System.out.println(s);
        }

3，泛型定义在接口上

    //泛型定义在接口上
    interface MyInter<T>{
        void access(T t);
    }

    //实现接口指定泛型
    class MyImpl1 implements MyInter<String>{
        @Override
        public void access(String t) {

        }
    }

    //实现接口后不知道传递什么类型
    class MyImpl2<T> implements MyInter<T>{
        @Override
        public void access(T t) {

        }
    }