java泛型基础

package com.suse.generic;

import java.util.ArrayList;
import java.util.List;

public class Generic {
    //
    public static void main(String[] args) {
        List<Integer> list=new ArrayList<>();
        list.add(new Integer(21));
        //list.add("hello");由于此处的泛型为整型，所以不能添加字符串
        System.out.println(list);
    }

}
```package com.suse.generic;

/*
 * 未用泛型的情况
 */
public class Point {
Object x;
Object y;
public Object getX() {
return x;
}

public void setX(Object x) {
this.x = x;
}

public Object getY() {
return y;
}

public void setY(Object y) {
this.y = y;
}

public static void main(String[] args) {
Point p = new Point();
p.setX(10);
p.setY(10);
int x = (Integer) p.getX();// 必须向下转型，因为不能把父类对象（Object）付给子类（int），所以强制转换为Integer,不转换则会报错
int y = (Integer) p.getY();
System.out.println("x=" + x + ",y=" + y);
p.setX(25.4);
p.setY("suse180度");
double m=(Double)p.getX();
String n=(String)p.getY();
System.out.println(m+","+n);
}
}
/*

上面的代码中，生成坐标时不会有任何问题，但是取出坐标时，要向下转型，在 Java多态对象的类型转换 一文中我们讲到，向下转型存在着风险，而且编译期间不容易发现，只有在运行期间才会抛出异常，所以要尽量避免使用向下转型。运行上面的代码，第12行会抛出 java.lang.ClassCastException 异常。

那么，有没有更好的办法，既可以不使用重载（有重复代码），又能把风险降到最低呢？

有，可以使用泛型类(Java Class)，它可以接受任意类型的数据。所谓“泛型”，就是“宽泛的数据类型”，任意的数据类型。


*/
`
package com.suse.generic;
//自定义泛型
public class PointTest<T1,T2> {

    /**
     * @param args
     */
    T1 X;
    T2 y;
    public T1 getX() {
        return X;
    }
    public void setX(T1 x) {
        X = x;
    }
    public T2 getY() {
        return y;
    }
    public void setY(T2 y) {
        this.y = y;
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        PointTest<Integer,Integer> p=new PointTest<>();
        p.setX(16);
        p.setY(18);
        int x=p.getX();
        int y=p.getY();
        System.out.println(x+","+y);
        PointTest<Double,String> p1=new PointTest<>();//Double
        p1.setX(66.6);
        p1.setY("suse666");
        double m=p1.getX();
        String n=p1.getY();
        System.out.println(m+","+n);

    }

}
与普通类的定义相比，上面的代码在类名后面多出了 <T1, T2>，T1, T2 是自定义的标识符，也是参数，用来传递数据的类型，而不是数据的值，我们称之为类型参数。在泛型中，不但数据的值可以通过参数传递，数据的类型也可以通过参数传递。T1, T2 只是数据类型的占位符，运行时会被替换为真正的数据类型。

传值参数（我们通常所说的参数）由小括号包围，如 (int x, double y)，类型参数（泛型参数）由尖括号包围，多个参数由逗号分隔，如 <T> 或 <T, E>。

类型参数需要在类名后面给出。一旦给出了类型参数，就可以在类中使用了。类型参数必须是一个合法的标识符，习惯上使用单个大写字母，通常情况下，K 表示键，V 表示值，E 表示异常或错误，T 表示一般意义上的数据类型。

泛型类在实例化时必须指出具体的类型，也就是向类型参数传值，格式为：
    className variable<dataType1, dataType2> = new className<dataType1, dataType2>();
也可以省略等号右边的数据类型，但是会产生警告，即：
    className variable<dataType1, dataType2> = new className();
因为在使用泛型类时指明了数据类型，赋给其他类型的值会抛出异常，既不需要向下转型，也没有潜在的风险，比本文一开始介绍的自动装箱和向上转型要更加实用。