Java 泛型解读

泛型的初认识

1. 泛型是在JDK1.5之后增加的新功能。泛型（Generic）
2. 泛型可以解决数据类型的安全性问题，在类的声明时通过一个标示表示类中某个属性的类型或者是某个方法的返回值及参数类型。
3. 大致格式：
   • 访问权限 class 类名称 <泛型,泛型,...> {
     属性
     方法
     }
4. 对象的创建: 类名称<具体类型> 对象名称 = new 类名称<具体类型>();

• 将上篇泛型认识前篇中的 Point 类用泛型优化

class Point<T>{
private T x;
private T y;
public T getX() {
return x;
}
public void setX(T x) {
this.x = x;
}
public T getY() {
return y;
}
public void setY(T y) {
this.y = y;
}
}
public class Generics {
public static void main(String[] args) {
// TODO Auto-generated method stub
Point<Integer> point = new Point<Integer>();
point.setX(10);
point.setY(29);
System.out.println("打印坐标:"+
point.getX()+","+point.getY());
}
}

通过使用泛型的例子与上篇做相应代码比较可发现，在创建对象初始化坐标时比较方便，需要什么类型数据的坐标，直接在 <> 类加入相应的类名就行。

- 指定多个泛型，只需在尖括号 <> 中用逗号“,”分开就行。例如：

    ```
class Demo<T,K>{
    private T take;
    private K key;        
}

泛型的构造方法

• 构造方法可以为类中的属性初始化，那么如果类中的属性通过泛型指定，又需要构造方法来设置其内容的时候，那么构造方法的定语与普通类的构造方法并无大同，不需要像声明类那样指定泛型。
  • 在上诉代码 泛型类 Point 中加入构造方法:

public Point(T x,T y){
    this.x = x;
    this.y = y;
}

- 在对象实例化时使用构造方法：
```

Point<String> point1 = new Point<String>("经度1","纬度2")；
```

泛型 - 通配符

class Info<T>{
    private T key;
    public T getKey() {
        return key;
    }
    public void setKey(T key) {
        this.key = key;
    }
    @Override
    public String toString(){
        return this.getKey().toString();
    }
}

public class Generics2 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Info<String> info = new Info<String>();
        info.setKey("Java学习");
        read(info);
    }
    public static void read(Info<?> t) {
        //这里用 ？通配符代表任意类型，使用Object会出错，不写<?>会有警告
        System.out.println(t.toString());
    }
}

泛型接口

• 泛型接口的创建于泛型类的创界并无大同，只是将 class 变为 interface, 但是实现接口的类必须将接口的方法实现。

泛型方法

• 泛型方法与泛型类并没有必然的联系，泛型方法有自己的类型参数，在普通类中也可以定义泛型方法。泛型方法中的T1、T2与泛型类中的T1、T2没有必然的联系，也可以使用其他的标识符来代替。
• 泛型方法中可以定义泛型参数，此时参数的类型就是传入的数据类型

class Gener{
    //泛型方法 返回一 T 类型的数据 
    public <T> T returnT(T t) { 
        return t;    
        }
}
public class Generics3 {

    public static void main(String[] args) {
        Gener gener = new Gener();
        //泛型方法的调用方便传入任意类型的数据
        String str  = gener.returnT("Java学习");
        System.out.println(str);
        int i = gener.returnT(10);
        System.out.println(i);
    }
}

泛型数组

• 在创建一个泛型方法时，也可以传递或者返回一个泛型数组

class Gener{
    //传递一个泛型数组
    public <T> void returnT(T t[]) { 
            for (int i = 0; i < t.length; i++) {
                System.out.print(t[i]);
            }
        }
}
public class Generics3 {

    public static void main(String[] args) {
        Gener gener = new Gener();
        String arr[] ={"Java","学","习"};
        gener.returnT(arr);
    }
}

泛型摩擦

• 如在定义某一个泛型类，在实例化过程中，没有指明具体类型，那么就是自动擦除泛型类型。编译器就将生成一种与泛型类同名的原始类，但是类型参数都被删除了。

总结 - 泛型的好处

1. 类型安全
2. 消除强制类型转换
3. 潜在性能收益