Java 泛型详解（一）

最新推荐文章于 2025-02-24 18:02:22 发布
最新推荐文章于 2025-02-24 18:02:22 发布
阅读量2.1k 收藏 27
点赞数 13
分类专栏： Java 文章标签： java 泛型 通配符
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/wei_zhi/article/details/52834213
版权

一、泛型的引出

假设要求定义一个表示坐标的操作类（Point），这个类可以表示三种类型的坐标：
（1）整数坐标：x = 10、y = 20；
（2）小数坐标：x = 10.1、y = 20.3；
（3）字符串数据：x = “东经100度”、y = “北纬20度”。

分析：

类中如果想保存以上的数据，一定需要定义x和y两个属性，而这两个属性可以接收三种数据类型，这样的话，只能使用Object类来定义会比较合适，这样会发生如下的几种转换关系：
（1）整数：int - >自动装箱为Integer->向上转型为Object；
（2）小数：double -> 自动装箱为Double-> 向上转型为Object；
（3）字符串：字符串->向上转型为Object。

于是，代码定义如下：


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 Test {
    public static void main(String[] args) throws Exception {
        //设置整型
        Point point1 = new Point() ;
        point1.setX(10) ;
        point1.setY(20) ;
        int x1 = (Integer) point1.getX() ;
        int y1 = (Integer) point1.getY() ;
        System.out.println("X的坐标是：" + x1 + "，Y的坐标是：" + y1);

        //设置小数
        Point point2 = new Point() ;
        point2.setX(10.1) ;
        point2.setY(20.3) ;
        double x2 = (Double) point2.getX() ;
        double y2 = (Double) point2.getY() ;
        System.out.println("X的坐标是：" + x2 + "，Y的坐标是：" + y2);

        //设置字符串
        Point point3 = new Point() ;
        point3.setX("东经100度") ;
        point3.setY("北纬20度") ;
        String x3 = (String) point3.getX() ;
        String y3 = (String) point3.getY() ;
        System.out.println("X的坐标是：" + x3 + "，Y的坐标是：" + y3);
    }
}

运行结果：

X的坐标是：10，Y的坐标是：20
X的坐标是：10.1，Y的坐标是：20.3
X的坐标是：东经100度，Y的坐标是：北纬20度

现在，看起来功能都实现了，但是本程序是否有问题？
本程序解决问题的关键就在于Object类，所有的类型都可以向Object转换，但是成是Object，败也是Object：

public class Test{
    public static void main(String[] args) throws Exception {

        Point point = new Point() ;
        point.setX(10) ;    // 此处设置成int型（Integer型）
        point.setY("北纬20度") ;
        String x = (String) point.getX() ;
        String y = (String) point.getY() ;
        System.out.println("X的坐标是：" + x + "，Y的坐标是：" + y);
    }
}

这时程序并没有出现任何语法错误，因为数字10被装箱成了Integer，可以使用Object接收，从技术上而言，本操作没有问题，但是从实际来讲，数据是有错误的，因为没有统一，所以在取得数据并且执行向下转型的过程之中就会出现如下的错误提示信息：

Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
    at Test.main(Test.java:7)

所以，以上的代码存在安全隐患，并且这一安全隐患并没有在程序编译的过程中检查出来。现在可以利用泛型来解决这种尴尬的问题！

二、泛型的定义和使用

泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。类中操作的属性或方法的参数的类型不在定义的时候声明，而是在使用的时候动态设置。

上面Point类利用泛型可以做如下定义：

class Point<T> { // T：Type
    private T x;
    private T y;

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

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

    public T getX() {
        return x;
    }

    public T getY() {
        return y;
    }
}

此时，point类中的x和y两个属性的类型暂时还不知道，等待程序运行的时候动态设置。

测试：

public class Test {
    public static void main(String[] args) throws Exception {

        Point<String> point = new Point<String>();
        point.setX("东经100度");
        point.setY("北纬20度");

        String x = point.getX();
        String y = point.getY();
        System.out.println("X的坐标是：" + x + "，Y的坐标是：" + y);
    }
}

运行结果：

X的坐标是：东经100度，Y的坐标是：北纬20度

此时，没了向下转型的操作关系，程序就避免了安全性的问题。如果设置的类型不统一，在程序编译的过程中也是可以很好的解决了，直接会报出语法错误。

而当用户在使用Point类声明对象的时候没有设置泛型，那么程序在编译的过程之中会出现警告信息。使用泛型可以很好的解决数据类型的统一问题。

注意：
JDK 1.5和JDK 1.7在定义泛型的时候是稍微有些区别的，
JDK 1.5的语法，在声明对象和实例化对象的时候必须都同时设置好泛型类型：

Point<String> point = new Point<String>() ;

JDK 1.7的时候简化了，实例化对象时的泛型类型就通过声明时的泛型类型来定义：

Point<String> point = new Point<>() ;

三、泛型通配符

泛型的出现的确可以解决了数据类型的统一问题以及避免了向下转型操作，但同时又会带来新的问题，下面先通过一段程序来观察一下会产生什么问题？

为了简化操作，下面定义一个简单的泛型类：

class Message<T> {
    private T info;

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

    public T getInfo() {
        return info;
    }
}

使用以上类对象执行引用传递：

public class Test {
    public static void main(String[] args) throws Exception {
        Message<String> msg = new Message<String>();
        msg.setInfo("Hello World .");
        print(msg); // 引用传递
    }

    public static void print(Message<String> temp) {
        System.out.println(temp.getInfo()); // 只是输出
    }
}

但是，如果现在定义的泛型类型不是String了呢？例如，换成了int（不能写基本类型，只能是包装类）：

public class Test {
    public static void main(String[] args) throws Exception {
        Message<Integer> msg = new Message<Integer>();
        msg.setInfo(100);
        print(msg); // 无法进行引用传递
    }

    public static void print(Message<String> temp) {
        System.out.println(temp.getInfo()); // 只是输出
    }
}

发现这个时候的print()方法无法再接收Message<Integer>对象的引用，因为这个方法只能够接收Message<String>对象的引用，那么可以将print()方法重载，换成Message<Integer>：

public class Test {
    public static void main(String[] args) throws Exception {
        Message<Integer> msg = new Message<Integer>();
        msg.setInfo(100);
        print(msg); // 无法进行引用传递
    }

    public static void print(Message<String> temp) {
        System.out.println(temp.getInfo()); // 只是输出
    }

    public static void print(Message<Integer> temp) {
        System.out.println(temp.getInfo()); // 只是输出
    }
}

但是，这时候发现按照之前的方式根本就无法进行方法的重载，因为方法重载的时候观察的不是泛型类型，而是类的名称，或者是说数据类型的，那么现在就可以发现，这个给出了泛型类之后，就相当于将一个类又划分成了若干个不同的小类型：
1

那么现在的问题：方法接收的参数问题又严重了，而且比之前使用对象多态性解决问题时出现的麻烦更大了，至少那个时候可以利用重载来接收一个类的所有子类对象，而现在呢连重载的机会都不给了。

这个时候，有人提出了，干脆在定义方法的时候就别写泛型类型了。
定义方法时不写上泛型类型：

public class Test {
    public static void main(String[] args) throws Exception {
        Message<Integer> msg = new Message<Integer>();
        msg.setInfo(100);
        print(msg); 
    }

    public static void print(Message temp) {
        System.out.println(temp.getInfo()); 
    }
}

虽然现在在print()方法的参数上出现了警告，但是现在的程序可算是正常了。但是新的问题又来了，问题就在于方法操作中，没有类型限制了：

    public static void print(Message temp) {
        temp.setInfo(100); // 设置Integer
        System.out.println(temp.getInfo()); // 只是输出
    }

发现此时在print()方法之中操作的时候，由于没有设置泛型类型，那么所有的类型都统一变为了Object，也就可以修改了，而通过本程序也就发现了，必须找到一种方法：此方法可以接收任意的泛型类型的设置，并且不能够修改，只能够输出。为了解决这样的问题，可以使用通配符“?”表示：

    public static void print(Message<?> temp) {
        System.out.println(temp.getInfo());
    }

在通配符“?”上有两个子通配符：
（1）设置泛型的上限：

？ extends 类

可以在声明上和方法参数上使用，例如：

? extends Number

表示：只能是Number或者是Number的子类Integer、Double等。

（2）设置泛型的下限：

? super 类

方法参数上使用，例如：

? super String

表示只能是String或者是String的父类（Object类）。

范例：设置泛型上限

class Message<T extends Number> {
    private T info;

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

    public T getInfo() {
        return info;
    }
}

public class Test {
    public static void main(String[] args) throws Exception {
        Message<Integer> msg = new Message<Integer>(); // Integer是Number的子类
        msg.setInfo(100);
        print(msg); // 引用传递
    }

    public static void print(Message<?> temp) {
        System.out.println(temp.getInfo()); // 只是输出
    }
}

运行结果：

100

范例：设置泛型下限，在方法的参数上使用

class Message<T> {
    private T info;

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

    public T getInfo() {
        return info;
    }
}

public class Test {
    public static void main(String[] args) throws Exception {
        Message<String> msg = new Message<String>(); // Integer是Number的子类
        msg.setInfo("Hello World .");
        print(msg); // 引用传递
    }

    // 只能是String的泛型或者是Object的泛型使用
    public static void print(Message<? super String> temp) {
        System.out.println(temp.getInfo()); // 只是输出
    }
}

运行结果：

Hello World .

未完待续。。。

Java 泛型详解
09-18
Java泛型详解，Java泛型详解，Java泛型详解，Java泛型详解
深入理解java泛型详解
08-30
Java 泛型是一种强大的编程工具，...总的来说，Java泛型提供了一种强类型机制，它增强了代码的可读性、类型安全性，并减少了运行时异常的可能性。熟练掌握泛型的使用，能帮助我们编写出更健壮、更易于维护的Java程序。
java 泛型详解
weixin_30785593的博客
10-08 258
普通泛型 Java代码 classPoint<T>{//此处可以随便写标识符号，T是type的简称privateTvar;//var的类型由T指定，即：由外部指定publicTgetVar(){//返回值的类型由外部决定returnvar;}publicvo...
Java 中的泛型讲解与使用（超全详解）
最新发布
C_V_Better的博客
02-24 2709
泛型是 Java SE 5 引入的一种特性，它允许我们在编译时指定类型参数，从而避免在运行时进行类型转换和类型检查。泛型的本质是在编译时进行类型检查，确保类型安全。我们可以在自定义类中使用泛型，从而提高代码的复用性和安全性。(点击链接跳转见详情)java泛型在自定义类中的应用-优快云博客通过本文的介绍，我们全面了解了 Java 中泛型的基本概念、基本用法、通配符、泛型方法、类型擦除以及实际应用示例。泛型是 Java 编程中一个重要的特性，它可以在编译时进行类型检查，提高代码的安全性和可读性。
Java泛型详解(转)
weixin_30518397的博客
04-01 569
文章转自 importNew：Java 泛型详解 引言 泛型是Java中一个非常重要的知识点，在Java集合类框架中泛型被广泛应用。本文我们将从零开始来看一下Java泛型的设计，将会涉及到通配符处理，以及让人苦恼的类型擦除。 泛型基础 泛型类 我们首先定义一个简单的Box类： public class Box { private String ...
java泛型详解java泛型详解.doc
06-10
Java 泛型是一种强大的语言特性，它允许在类、接口和方法中使用类型参数，以实现类型的安全性和代码的重用性。泛型是 Java 从 JDK 5.0 版本开始引入的重要特性，目的是增强类型系统，提高程序的类型安全性，减少运行...
java泛型详解.pdf
10-02
java泛型详解.pdf
思维导图之Java泛型详解
05-24
思维导图之Java泛型详解
Java 中的泛型（超全详解）
weixin_65752158的博客
07-10 2万+
泛型的出现就是为了统一集合当中数据类型的尖括号 <> 中的 泛型标识被称作是类型参数，用于指代任何数据类型。T ：代表一般的任何类。E ：代表 Element 元素的意思，或者 Exception 异常的意思。K ：代表 Key 的意思。V ：代表 Value 的意思，通常与 K 一起配合使用。S ：代表 Subtype 的意思，文章后面部分会讲解示意。自己实现集合/*E: 表示不确定的类型,该类型在类名后面已经定义过了e: 形参的名字,变量名*/
JAVA 泛型
zhangyonzhi的专栏
07-14 155
 在Java SE1.5中，增加了一个新的特性：泛型（日本语中的总称型）。何谓泛型呢？通俗的说，就是泛泛的指定对象所操作的类型，而不像常规方式一样使用某种固定的类型去指定。泛型的本质就是将所操作的数据类型参数化，也就是说，该数据类型被指定为一个参数。这种参数类型可以使用在类、接口以及方法定义中。   一、                       为什么使用泛型呢？      在以往的J2...
Java泛型详解（史上最全泛型知识详解）
m0_70325779的博客
07-25 1万+
泛型是在JDK5之后引入的一个新特性，可以在编译阶段约束操作的数据类型，并进行检查。泛型的格式为用大白话来说，泛型就好比是给一个标签，通常情况下我们会在开发过程中或者个人学习或练习的过程中使用到泛型；就拿数组的泛型举例来说，我们把数组比作一个药瓶子，我们药瓶子贴上了什么标签，就只能放什么药，如果不管什么药都放在一个药瓶子里，那不得出大事吗？同样容器(数组)写上什么泛型，就只能存放什么数据；这样就不会导致我们存取数据的混乱。这样就解决了我们引言中提到的问题，也就解释了什么是泛型。
Java中的对象集合（三）
NEMO的专栏
02-16 1226
Java泛型编程指南此系列文章译自SUN的泛型编程指南, 看不懂译文的请看原文http://java.sun.com/j2se/1.5/pdf/generics-tutorial.pdf一、绪言JDK1.5对JAVA语言进行了做了几个扩展，其中一个就是泛型。本指南旨在介绍泛型。如果你熟悉其它语言的构造类似的东西，特别是C++的模板（template），你会很快发现它们之间的相同点及重要的不同点；如
java 泛型详解-绝对是对泛型方法讲解最详细的，没有之一
热门推荐
s10461的博客
12-30 61万+
对java的泛型特性的了解仅限于表面的浅浅一层，直到在学习设计模式时发现有不了解的用法，才想起详细的记录一下。 本文参考java 泛型详解、Java中的泛型方法、 java泛型详解 1. 概述泛型在java中有很重要的地位，在面向对象编程及各种设计模式中有非常广泛的应用。什么是泛型？为什么要使用泛型？ 泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传
java 泛型详解
a03910的专栏
09-10 306
Java类型中ParameterizedType，GenericArrayType，TypeVariabl，WildcardType详解   (1). 和反射+泛型有关的接口类型 java.lang.reflect.Type：java语言中所有类型的公共父接口 java.lang.reflect.ParameterizedType java.lang.reflect.GenericArr...
JAVA泛型详解与应用
"JAVA泛型是Java编程语言中的一种特性，用于增强类型安全并提供编译时的类型检查。它允许在定义类、接口和方法时指定参数化类型，从而限制可以使用的数据类型。泛型的主要目的是减少运行时异常，提高代码的可读性和...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值