Java泛型

导语

这里是导语。对，没错，这里就是导语，没有前几次的代码情书。喜欢情书的关注我，去看我之前的Java文章吧。

主要内容

• 泛型技术的产生背景
• 泛型操作的实现
• 通配符的使用
• 泛型接口
• 泛型方法

具体内容

泛型的引出

现在要求定义一个表示坐标的操作类（Point），在这个类里面要求保存有以下几种坐标：
- 保存数字：x = 10、y = 20。
- 保存小数：x = 10.2、y = 20.3。
- 保存字符串：x = 东经20度、y = 北纬15度。

现在这个Point类设计的关键就在于x与y这两个变量的类型设计上。必须有一种类型可以保存这三类数据。首先想到的一定是Object类型：
- int：int自动装箱为Integer，Integer向上转型为Object。
- double：double自动装箱为Double，Double向上转型为Object。
- String：直接向上转型为Object。

范例：初期设计如下

public class Point {
    private Objects x;
    private Objects y;

    public Objects getX() {
        return x;
    }

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

    public Objects getY() {
        return y;
    }

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

下面重复的演示三个程序，分别使用各个不同的数据类型。
在Point类里面保存整型数据

public class TestDemo {
    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 + "，y坐标：" + y + "。");
    }
}

输出结果

x坐标：10，y坐标：20。

在Point类里面保存小数

public class TestDemo {
    public static void main(String args[]) {
        // 第一步：设置数据
        Point p = new Point();
        p.setX(10.2);
        p.setY(20.3);
        // 第二步：取出数据
        double x = (Double) p.getX();
        double y = (Double) p.getY();
        System.out.println("x坐标：" + x + "，y坐标：" + y + "。");
    }
}

输出结果

x坐标：10.2，y坐标：20.3。

在Point类里面保存字符串

public class TestDemo {
    public static void main(String args[]) {
        // 第一步：设置数据
        Point p = new Point();
        p.setX("东经20度");
        p.setY("北纬15度");
        // 第二步：取出数据
        String x = (String) p.getX();
        String y = (String) p.getY();
        System.out.println("x坐标：" + x + "，y坐标：" + y + "。");
    }
}

输出结果

x坐标：东经20度，y坐标：北纬15度。

此时的代码已经利用了Object数据类型解决了一切的开发问题，可是解决的关系是靠的是Object，于是失败的关键也在于Object。

范例：观察错误的代码

public class TestDemo {
    public static void main(String args[]) {
        // 第一步：设置数据
        Point p = new Point();
        p.setX("东经20度");
        p.setY(10);  // 这里改为数字
        // 第二步：取出数据
        String x = (String) p.getX();
        String y = (String) p.getY();
        System.out.println("x坐标：" + x + "，y坐标：" + y + "。");
    }
}

代码不需要执行就可以看到程序的问题，因为在存放的时候是int（Integer），而取的时候使用的是String，两个没有发生关系的对象之间要发生强制转换，就一定会产生ClassCastException。

向上转型的核心目的在于统一操作的参数上，而向下转型的目的是操作子类的特殊功能，可是现在的问题发现向下转换是一件非常不安全的操作，那么这一操作应该在代码运行之前就已经能够自动的排查出来这是最好的选择。可是之前的技术做不到。

泛型操作的实现

从JDK1.5之后开始增加了泛型技术，而泛型技术的核心意义在于：类的定义的时候，可以使用一个标记，此标记就表示类中属性或方法参数的类型标记，在使用的时候才动态的设置类型。

范例：修改代码

// 此时设置的T在Point类定义上只表示一个标记，在使用的时候需要为其设置具体的类型
public class Point<T> {  // Type = T，是一个类型，也可是任何标记
    private T x;  // 此属性的类型不知道，由Point类使用时动态决定
    private T y;  // 此属性的类型不知道，由Point类使用时动态决定

    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类的时候才去设置标记的内容，也就是设置了类中的属性的类型。

使用String

public class TestDemo {
    public static void main(String args[]) {
        // 第一步：设置数据
        Point<String> p = new Point<String>();
        p.setX("东经20度");
        p.setY("北纬15度");  // 如果使用p.setY(10);会报错
        // 第二步：取出数据
        String x = (String) p.getX();
        String y = (String) p.getY();
        System.out.println("x坐标：" + x + "，y坐标：" + y + "。");
    }
}

使用了泛型之后，所有类中属性的类型都是动态设置的，而所有使用泛型标记的方法参数类型也都发生改变，这样就相当于避免了向下转型的问题，从而解决了类转换的安全隐患。
但是需要特别说明的是，如果想要使用泛型，那么它能够采用的类型只能够是类，即：不能是基本类型，只能够是引用类型（可以使用Integer）。

对于泛型有两点说明：
- 如果在使用泛型类或者是接口的时候，没有设置泛型的具体类型，那么会出现编译时的警告，同是为了保证程序不出错，所有的泛型都将使用Object表示。
- 从JDK1.7开始可以简化声明泛型。

在JDK1.7之后实例化的时候可以写成：

Point<Integer> p = new Point<>();

通配符

为了更好的理解通配符的作用，下面先来观察一段程序。

public class Message<T> {
    private T msg;

    public T getMsg() {
        return msg;
    }

    public void setMsg(T msg) {
        this.msg = msg;
    }
}

public class TestDemo {
    public static void main(String args[]) {
        Message<String> m = new Message<String>();
        m.setMsg("Hello World !");
        fun(m);  // 引用传递
    }

    public static void fun(Message<String> temp) {
        System.out.println(temp.getMsg());
    }
}

输出结果

Hello World !

以上代码为Message类设置的是一个String型的泛型类型，但是如果换成其它类型就不能够使用了。

先看一组错误代码

public static void fun(Message temp) {  // 不设置接收参数为泛型，就是Object类型
    temp.setMsg("Hello");  // 如果传过来的泛型不为String就会报错
    System.out.println(temp.getMsg());
}

正确的代码如下

public static void fun(Message<?> temp) {  // 设置为通配符问号，表示不能够设置，只能够取出
    System.out.println(temp.getMsg());
}

在“?”通配符基础上还会有两个子的通配符：
- ? extends类：设置泛型上限，可以在声明上和方法参数上使用。
- ? extends Number：意味着可以设置Number或者Number的子类（Integer、Double…）。
- ? super类：设置泛型下限，方法参数上使用。
- ? super String：意味着只能够设置String或者是它的父类Object。

范例：设置泛型的上限

public class Message<T extends Number> {
    private T msg;

    public T getMsg() {
        return msg;
    }

    public void setMsg(T msg) {
        this.msg = msg;
    }
}

public class TestDemo {
    public static void main(String args[]) {
        Message<Integer> m = new Message<Integer>();
        m.setMsg(100);
        fun(m);  // 引用传递
    }

    public static void fun(Message<? extends Number> temp) {
        System.out.println(temp.getMsg());
    }
}

如果设置了非Number或者其子类的话，那么将出现语法错误。

范例：设置泛型下限

public class Message<T> {
    private T msg;

    public T getMsg() {
        return msg;
    }

    public void setMsg(T msg) {
        this.msg = msg;
    }
}

public class TestDemo {
    public static void main(String args[]) {
        Message<String> m = new Message<String>();
        m.setMsg("Hello");
        fun(m);  // 引用传递
    }

    public static void fun(Message<? extends String> temp) {
        System.out.println(temp.getMsg());
    }
}

泛型接口

在之前都是将泛型定义在了一个类里面，那么泛型也可以定义在接口上声明，称为泛型接口。

范例：定义泛型接口

public interface Message<T> {
    public void print(T t);
}

定义子类有两种形式。

形式一：在子类继续设置泛型

// 子类也继续使用泛型，并且父接口使用和子类同样的泛型标记
public class MessageImpl<T> implements Message<T> {
    public void print(T t) {
        System.out.println(t);
    }
}

public class TestDemo {
    public static void main(String args[]) {
        Message<String> msg = new MessageImpl<String>();
        msg.print("Hello World !");
    }
}

形式二：在子类不设置泛型，而为父接口明确的定义一个泛型类型

// 子类也继续使用泛型，并且父接口使用和子类同样的泛型标记
public class MessageImpl implements Message<String> {
    public void print(String t) {
        System.out.println(t);
    }
}

public class TestDemo {
    public static void main(String args[]) {
        Message<String> msg = new MessageImpl();
        msg.print("Hello World !");
    }
}

泛型方法

泛型方法不一定要定义在支持泛型的类里面。

范例：泛型方法定义

public class TestDemo {
    public static void main(String args[]) {
        String str = fun("Hello");
        Sysout.out.println(str.length);
    }

    // T的类型由传入的参数类型决定
    public static <T> T fun(T t) {
        return t;
    }
}

总结

• 泛型解决的是向下转型所带来的安全隐患，其核心的组成就是在声明类或接口的时候不设置参数或属性的类型。
• “?”可以接收任意的泛型类型，只能够取出，但是不能够修改。

进入我的CSDN戳这里（我的博客导航）