JAVA中的泛型

1、泛型的基本作用

有时候创建一个类，需要这个类中的属性是Object类型的，可以时而为String类型，时而为Long类型等。比如一个坐标类Point，横坐标和纵坐标可能是整型，可能是浮点型，也可能是字符串类型，需要输出的结果如下：

代码如下：

package org.mole.t;

public class Point {

private Object x;//横坐标
private 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 class MixDemo {
public static void main(String args[]){
//坐标是整型
Point p = new Point();
p.setX(10);
p.setY(20);
int x = (Integer)p.getX();
int y = (Integer)p.getY();
System.out.println("横坐标x："+x);
System.out.println("纵坐标y："+y);
//坐标是浮点型
Point f = new Point();
f.setX(10.2f);
f.setY(20.1f);
float fx = (Float)f.getX();
float fy = (Float)f.getY();
System.out.println("横坐标x："+fx);
System.out.println("纵坐标y："+fy);
//坐标是字符串
Point s = new Point();
s.setX("东京150度");
s.setY("北纬20度");
String sx = (String)s.getX();
String sy = (String)s.getY();
System.out.println("横坐标x："+sx);
System.out.println("纵坐标y："+sy);
}
}

通过以上的方法来实现属性类型的可变不是很妥当，程序入口不规范，并且存在安全漏洞。例如，把属性设置类型设置为Object类型，当给属性的赋值与其强制类型装换不匹配时程序编译不会出错，执行报错。

在jdk1.5之后，引入了泛型解决此类问题，使类中属性的类型由外部决定。泛型的声明如下：

class 类名 <泛型类型，泛型类型……>{

}

以上的Point类应用泛型后，修改如下：

package org.mole.t;

public 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 MixDemo {
public static void main(String args[]){
//坐标是整型
Point<Integer> p = new Point<Integer>();
p.setX(10);
p.setY(20);
System.out.println("横坐标x："+p.getX());
System.out.println("纵坐标y："+p.getY());
//坐标是浮点型
Point<Float> f = new Point<Float>();
f.setX(10.2f);
f.setY(20.1f);
System.out.println("横坐标x："+f.getX());
System.out.println("纵坐标y："+f.getY());
//坐标是字符串
Point<String> s = new Point<String>();
s.setX("东京150度");
s.setY("北纬20度");
System.out.println("横坐标x："+s.getX());
System.out.println("纵坐标y："+s.getY());
}


}

使用泛型后类Point中属性的类型由外部决定，这时，当Point<Integer> p = new Point<Integer>()实例化时声明是Integer类型时，再对p赋值为其他类型，编译就会报错。

可以在构造方法上使用泛型：

public 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;
}
Point(T x,T y){
this.setX(x);
this.setY(y);
}
}

泛型也可以擦除，在使用泛型时不指定泛型，直接Point f = new Point();便擦除了泛型，后面的使用按object使用，擦除泛型一般不用

2、泛型的通配符的使用

类名<?>表示可以接受任意类型的泛型结合以上代码加入fun()方法，代码如下：

package org.mole.t;

public 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 MixDemo {
public static void main(String args[]){
//坐标是整型
Point<Integer> p = new Point<Integer>();
p.setX(10);
p.setY(20);
//坐标是浮点型
Point<Float> f = new Point<Float>();
f.setX(10.2f);
f.setY(20.1f);
//坐标是字符串
Point<String> s = new Point<String>();
s.setX("东京150度");
s.setY("北纬20度");
fun(p);
fun(f);
fun(s);

}
public static void fun(Point<?> p){
System.out.println("横坐标x："+p.getX());
System.out.println("纵坐标y："+p.getY());
}
}

值的注意的是，普通的类可以向上转型，应用泛型的类却不能向上转型。

泛型上限：操作泛型的最大父类，格式如下

类名称<泛型名称 extends 父类名称>{}

泛型上限也可以应用在方法上，例如：

public static void fun(Point<? extends Number> p){
System.out.println("横坐标x："+p.getX());
System.out.println("纵坐标y："+p.getY());
}

泛型下限：造作泛型的最小的类型，格式如下

类名称<泛型名称 super 类型名称>{}

泛型下限也可应用在方法上。

3、泛型接口

泛型不仅能在类中使用，也可在接口中使用，格式如下：

interface 接口名称<泛型，泛型……>{

}

接口的实现有两种方法：

第一：创建一个应用泛型T的类，实现泛型为T的接口

package org.mole.t;
public interface Demo<T> {
public void print(T param);
}

package org.mole.t;
public class DeomImpl1<T> implements Demo<T> {
public void print(T param) {
System.out.println("param:"+param);

}
}

package org.mole.t;
public class DemoTest {
public static void main(String args[]){
Demo<String> d = new DeomImpl1<String>();
d.print("Hello");
}
}

第二：创建一个类，实现接口中泛型为类

package org.mole.t;

public class DemoTest2 {
public static void main(String args[]){
Demo<DeomImpl2> d = new DeomImpl2();
d.print(new DeomImpl2());
}
}

public interface Demo<T> {
public void print(T param);
}
public class DeomImpl2 implements Demo<DeomImpl2>{
public void print(DeomImpl2 param) {
System.out.println("param:"+param);

}
}

4、泛型方法

在方法上使用泛型，该方法所在的类不一定是泛型的操作类。泛型的使用格式如下：

package org.mole.t;

public class Demo2 {
public <T> T print(T param){
return param;
}
}

public class Test2 {
public static void main(String args[]){
Demo2 d = new Demo2();
System.out.println(d.print(1));
System.out.println(d.print("Hello"));
System.out.println(d.print(1.11));
}
}

代码的执行结果如下：

也可将返回值设置为泛型数组

5、泛型的嵌套

将Info的类型设置到Person中，同时Person和Info都是泛型，操作代码如下：

package org.mole.t;
public class Person<T> {
private T info;


public T getInfo() {
return info;
}


public void setInfo(T info) {
this.info = info;
}

}

public class Info<T> {
private T param;


public T getParam() {
return param;
}


public void setParam(T param) {
this.param = param;
}

}

public class Test1 {
public static void main(String[] args) {
Person<Info<String>> p = new Person<Info<String>>();
p.setInfo(new Info<String>());
p.getInfo().setParam("hello");
System.out.println(p.getInfo().getParam());
}


}