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());

}

}