Java 泛型，

Java 泛型，

泛型的概念

泛型：类中操作的属性或方法的参数类型不在定义时，而是在使用时动态设置．使用泛型可以很好地解决数据类型统一的问题．与使用Object相比，此时程序没有向下转型的操作关系，不存在数据的安全性问题．

泛型的使用

代码示例

class Point<T>{
    private T x;
    private T y;
    public void setX(T x){
        this.x = x;
    }
    public T getX(){
        return this.x;
    }
    public void setY(T y){
        this.y = y;
    }
    public T getY(){
        return this.y;
    }
}
public class TestDemo{
    public static void main(String [] args){
        Point<Integer> p1 = new Point<Integer>();
        Point<String> p2 = new Point<String>();
        Point p3 = new Point();
        p1.setX(10);
        p1.setY(20);
        p2.setX("东经10度");
        p2.setY("西经20度");
        p3.setX(10.0);
        p3.setY(20.0);
        System.out.print("整型坐标:");
        int x1 = p1.getX();
        int y1 = p1.getY();
        System.out.println("X的坐标是：" + x1 + ",Y的坐标是：" + y1);
        System.out.print("字符型坐标:");
        String x2 = p2.getX();
        String y2 = p2.getY();
        System.out.println("X的坐标是：" + x2 + ",Y的坐标是：" + y2);
        System.out.print("double型坐标:");
        double x3 = (double) p3.getX();
        double y3 = (double) p3.getY();
        System.out.println("X的坐标是：" + p3.getX() + ",Y的坐标是：" + p3.getY());

    }
}

---

程序运行结果
整型坐标:X的坐标是：10,Y的坐标是：20
class java.lang.Integer
字符型坐标:X的坐标是：东经10度,Y的坐标是：西经20度
class java.lang.String
double型坐标:X的坐标是：10.0,Y的坐标是：20.0

---

通过本程序可以注意到：
1. 声明泛型对象操作

Point<String> p = new Point<String>()

通配符

泛型的出现确实可以解决数据类型统一的问题，并且避免向下转型，但同时又会带来新的问题——给出了泛型后，将一个类划分为多个不同的小类型．如下图：

由此，之前使用对象多态性解决参数统一问题，在使用泛型后又全被破坏了.例如实例化的对象类型为Point

class Message<T>{
    private T info;
    public void setInfo(T info){
        this.info = info;
    }
    public T getInfo(){
        return this.info;
    }
}
public class TestDemo{
    public static void main(String [] args){
        Message<String> msg1 = new Message<String>();
        Message<Integer> msg2 = new Message<Integer>();
        msg1.setInfo("Hello");
        msg2.setInfo(100);
        print(msg1);
        print(msg2);    
    }
    public static void print(Message<?> msg){
        // 错误语法无法修改
        //msg.setInfo("World");
        System.out.println(msg.getInfo());
    }
}

---

程序运行结果
Hello
100

---

注：Message<Object>不能接收Message的所有泛型类型

通配符”?”衍生出了两个字符号：

• 设置泛型的上限:? extends 类,如 ? extends Number,表示只能是Number或者是Number的子类Integer等．

• 设置泛型的下限：? super 类，如? super String,表示只能是String或者是Stirng类的父类(Object).

泛型接口

使用泛型定义的接口成为泛型接口

定义泛型接口

interface Message<T>{
    public String echo(T msg);
}

在Java中有两种泛型接口的实现方式：
1. 在子类上继续定义泛型，同时此泛型在接口上继续使用

interface Message<T>{
    public String echo(T msg);
}
class MessageImpl<T> implements Message<T>{
    public String echo(T msg){
        return "Echo:" + msg;
    }
}
public class TestDemo{
    public static void main(String [] args){
        Message<String> msg = new MessageImpl<String>();
        System.out.println(msg.echo("张三"));
    }
}

---

程序运行结果
Echo:张三

---

interface Message<T>{
    public String echo(T msg);
}
class MessageImpl implements Message<String>{
    public String echo(String msg){
        return "Echo:" + msg;
    }
}
public class TestDemo{
    public static void main(String [] args){
        Message<String> msg = new MessageImpl();
        System.out.println(msg.echo("张三"));
    }
}

---

程序运行结果
Echo:张三

---

泛型方法

对于泛型，除了可以定义在类上之外，也可以在方法上进行定义．泛型方法的具体类型在调用的时候来决定．

public class TestDemo{
    public static void main(String [] args){
        // 设置泛型类型只能定义为类的形式
        Integer [] data = get(1, 2, 3);
        for(int i : data){
            System.out.print(i + ",");
        }
    }
    //　泛型方法
    public static <T>  T [] get(T ... arg){     //　可变参数实际上是按数组方式进行操作的
        return arg;
    }
}

---

程序运行结果
1,2,3,

---

可以发现，在定义泛型方法时，还要首先定义出泛型的名称”