JAVA5特性---泛型

最新推荐文章于 2021-02-13 13:27:34 发布
最新推荐文章于 2021-02-13 13:27:34 发布
阅读量207 收藏
点赞数
分类专栏： # Java基础 文章标签： Java5 泛型
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Loiterer_Y/article/details/89533142
版权

泛型

问题引出

1、要求：定义一个表示坐标的类（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；

范例：设计如下

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 Demo {
    public static void main(String[] args) {
        // 1. 设置数据
        Point pA = new Point();
        pA.setX(10);
        pA.setY(20);
        // 2. 取出数据
        int x = (Integer) pA.getX();
        int y = (Integer) pA.getY();
        System.out.println("(" + x + " , " + y + ")");
    }
}

上述代码利用Object数据类型解决了问题，但依然可能有一定问题。
范例：造成异常的代码：

public class Demo {
    public static void main(String[] args) {
        // 1. 设置数据
        Point pA = new Point();
        pA.setX("东经10度");
        pA.setY(10);
        // 2. 取出数据
        String x = (String) pA.getX();
        String y = (String) pA.getY();
        System.out.println("(" + x + " , " + y + ")");
    }
}

上述异常产生的原因是因为设置时存放的是int(Integer),而取出时是String。两个没有任何关系的类对象之间发生强制转换，会出现java.lang.ClassCastException错误。
2、向上转型是为了统一参数，向下转型是为了调用子类定义的特殊功能。向下转型是一种不安全的操作，那么这种操作应该在代码运行前排查出来。
从JDK1.5增加了泛型，泛型的核心作用在于：类在定义的时候，可以使用一个标记，此标记动态表示类中属性或方法参数的类型，使用时设置具体类型。

// T在Point类定义上只表示一个标记，使用时需要为其设置具体的类型
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 Demo {
    public static void main(String[] args) {
        // 1. 设置数据
        Point<String> pA = new Point();
        pA.setX("东经10度");
        pA.setY("北纬20度");
        // 此时Point类的类型为String，不需要向下转型
        // 2. 取出数据
        String x = pA.getX();
        String y = pA.getY();
        System.out.println("(" + x + " , " + y + ")");
    }
}

3、使用泛型后，类中属性的类型都是动态设置的，这样避免了向下转型的问题。但是泛型只能用于类，即不能用于基本数据类型，只能是引用类型（例如，不能用<int>，只能用<Integer>）

public class Demo {
    public static void main(String[] args) {
        // 1. 设置数据
        Point<Integer> pA = new Point();
        pA.setX(10);
        pA.setY(20);
        // 利用包装类的自动装箱和自动拆箱
        // 2. 取出数据
        int x = pA.getX();
        int y = pA.getY();
        System.out.println("(" + x + " , " + y + ")");
    }
}

4、对于泛型有两点说明：

· 使用泛型类或接口时，没有设置接口的具体类型会出现编译警告，为了保证程序不出错，将默认使用Object表示。

public class Demo {
    public static void main(String[] args) {
        // 1. 设置数据
        Point pA = new Point(); // 将使用Object描述泛型
        pA.setX(10);
        pA.setY(20);
        // 2. 取出数据,需要转型
        int x = (Integer) pA.getX();
        int y = (Integer) pA.getY();
        System.out.println("(" + x + " , " + y + ")");
    }
}

· JDK1.7开始，可以简化泛型声明

Point<Integer> pA = new Point();

即实例化时只要在前面声明一个泛型的具体类型。

通配符

范例：观察下述程序

class Message<T> {
    private T msg;

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

    public T getMsg() {
        return msg;
    }

}

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

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

上述代码为Message类设置String型的泛型，但是此时设置其他类型时，fun()中的Message<String>就不能使用了，并且fun()不能针对不同的泛型进行重载，因为方法重载只认得参数类型，无法辨别泛型的不同。
解决方法一：不设置方法参数的泛型

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

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

此时fun()存在警告，因为不设置具体泛型，就会存在警告。并且存在下述问题：

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

    public static void fun(Message temp) { // 不设置泛型，默认为Object型
        temp.setMsg("Hello"); // 设置Striing型
        System.out.println(temp.getMsg());
    }
}

1、上述代码说明，需要一种方式可以接收任意的泛型类型，但是不可以修改，只能取出。就可以使用?来描述

public class Demo {
    public static void main(String[] args) throws Exception {
        Message<Integer> num = new Message<>();
        num.setMsg(100);
        fun(num);
    }

    public static void fun (Message<?> tmp) {
        //tmp.setMsg("String"); 报错,无法应用
        System.out.println(tmp.getMsg());

    }
}
  1. 在?通配符基础上还有两个子通配符：

· ?extends 类：设置泛型上限，可以在声明上和方法参数上使用；
|- ?extends Number：意味着可以设置Number或者Number的子类(Integer，Double等)
· ?super 类：设置泛型下限，方法参数使用；
|-?super String：意味着只能设置String或者它的父类Object.

范例：设置泛型上限

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

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

    public T getMsg() {
        return msg;
    }

}

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

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

范例：将Integer改为String

Message<String> mA = new Message<String>();

此时设置为非Number或其子类，那就会出现语法错误。
范例：设置泛型下限

class Message<T> {
    private T msg;

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

    public T getMsg() {
        return msg;
    }

}

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

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

泛型接口

1、泛型可以在接口上声明，这样的接口称为泛型接口。
范例：定义泛型接口

// 如果是接口在前面加“I”，例如：IMessage;
// 如果是抽象类前面加Abstract,例如:AbstractMessage
// 如果是普通类直接写，例如：Message
interface IMessage<T> { // 设置泛型接口
    public void print(T t);
}

2、接口必须定义其相应的子类，定义子类有两种形式：
形式一：在子类继续设置泛型

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

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

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

class Message implements IMessage<String> {
    public void print(String t) {
        System.out.println(t);
    }
}

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

泛型方法

泛型方法也可以定义在普通类中。
范例：泛型方法定义

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

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

总结：
1、泛型解决的是向下转型所带来的安全隐患，其核心是在声明类或接口时不设置参数或属性的类型；
2、“?”可以接收任意的泛型类型，只能取出，不能修改泛型

不会画画的画师
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA-泛型基本讲解
06-06
1、Java泛型是J2 SE1.5中引入的一个新特性，其本质是参数化类型，也就是说所操作的数据类型被指定为一个参数（type parameter）这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。...
java 泛型详解-绝对是对泛型方法讲解最详细的，没有之一
热门推荐
s10461的博客
12-30 60万+
对java的泛型特性的了解仅限于表面的浅浅一层，直到在学习设计模式时发现有不了解的用法，才想起详细的记录一下。 本文参考java 泛型详解、Java中的泛型方法、 java泛型详解 1. 概述泛型在java中有很重要的地位，在面向对象编程及各种设计模式中有非常广泛的应用。什么是泛型？为什么要使用泛型？ 泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传
java5 范型_Java JDK5新特性-泛型
weixin_42139357的博客
02-13 166
2017-10-30 22:47:11Java 泛型(generics)是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。泛型是一种把类型的明确工作推迟到创建对象或者调用方法的时候才去明确的特殊类型。注意：类型参数只能代表引用型类型，不能是原始类型(像int,doubl...
Java5 泛型
水电站
05-14 146
  1.  介绍 JDK1.5中引入了对java语言的多种扩展，泛型(generics)即其中之一。 把一个list中的内容限制为一个特定的数据类型呢？这是generics背后的核心思想。这是上面程序片断的一个泛型版本:        List&lt;Integer&gt; myIntList = new LinkedList&lt;Integer&gt;(); // 1       ...
java--加强之 Java5的泛型
openXu的专栏
08-13 1362
入门泛型的基本应用 体验泛型： Jdk1.5以前的集合类中存在什么问题？ ArrayList collection1 = new ArrayList(); collection1.add(1); coll
java--泛型编程
12-22
Java 泛型编程是Java语言在JDK 1.5版本引入的一项重要特性，它极大地提高了代码的安全性和可重用性。泛型本质上是参数化类型，允许我们在编写代码时，将数据类型作为参数，这使得类、接口和方法能够处理多种不同的...
java基础教程----精华版
09-22
- **继承（Inheritance）**：一个类可以继承另一个类的特性，实现代码复用。 - **多态（Polymorphism）**：同一种行为可以有不同的表现形式，通过接口或抽象类实现。 3. **异常处理**： - Java使用try-catch-...
Java高级特性-笔记.pdf
10-04
其次，泛型是Java 5引入的重要特性，它允许我们在类、接口和方法中指定类型参数，增强了类型安全，避免了运行时的强制类型转换。例如，ArrayList和HashMap,V>中的E、K和V就是泛型类型参数，分别代表元素类型、键类型...
java-1.8.0-openjdk.linux.x86_64
12-10
OpenJDK 1.8.0 版本包含了Java语言的关键特性，如泛型、枚举、匿名内部类、动态代理、增强的for循环、可变参数、注解等。此外，它还提供了Lambda表达式、函数式接口、Stream API、Optional类等Java 8的新特性，这些...
java 泛型
u012481520的专栏
07-07 393
假如我们现在要定义一个类来表示坐标，要求坐标的数据类型可以是整数、小数和字符串，例如： x = 10、y = 10x = 12.88、y = 129.65x = "东京180度"、y = "北纬210度" 针对不同的数据类型，除了借助方法重载，还可以借助自动装箱和向上转型。我们知道，基本数据类型可以自动装箱，被转换成对应的包装类；Object 是所有类的祖先类，任何一个类的实例都可以向
[学习笔记]Java 5特性
Jacob专栏
12-30 500
泛型机制 见《Java泛型机制（Java 5）》 注解 1. 概述 注解（Annotation）相当于一种标记，在程序中加了注解就等于为程序打上了某种标记。编译器、开发工具和其他程序就可以利用注解来完成检查，提醒等功能。 普通程序要获取注解，可以通过反射的方式，以实现特定功能。 2. 特点 注解可以加在包，类（包括class，interface
java泛型和自定义泛型T
Tiglle的博客
03-26 5158
在编译过程中，对于正确检验泛型结果后，会将泛型的相关信息擦出，也就是说，成功编译过后的class文件中是不包含任何泛型信息的。泛型信息不会进入到运行时阶段。 1.泛型类T,U可以用在: 1.属性类型 2.方法返回值 3.方法参数类型public class User<T,U>{//T和U指定了t和u的变量类型,不使用T和U,默认为t和u为Object类型 private T t;
Java 5.0的五个特性_另外（转）
杂记、杂转IT
04-07 169
至今，毫无疑问你已经看过不止一篇网上文章列举了Java5.0的伟大的语言新特性:泛型，标注，枚举类型，自动装箱，可变参数， for/in循环，甚至静态引入。我也认为这些是伟大的特性，但是，你已经读过他们了。因此，在此我将集中于你可能没有听说过的Java5.0的新API特性。 　　那么，在下面，是我喜欢的Java5.0的五个新API特性。那些看完本文后的细心的读者会发现额外的奖励?第六个特性:...
Java基础加强-java5的泛型
深情小建
08-08 830
泛型(Generic)—泛形的作用 （1）JDK5以前，对象保存到集合中就会失去其特性，取出时通常要程序员手工进行类型的强制转换，这样不可避免就会引发程序的一些安全性问题。例如： （2）ArrayList list = new ArrayList(); list.add("abc"); Integer num = (Integer) list.get(0);  //运行时会
java5 范型_Java 5 泛型深入研究
weixin_31448735的博客
02-13 105
Java 5泛型深入研究上接《Java 泛型的理解与等价实现》，这个仅仅是泛型的入门。有博友反映泛型很复杂，难以掌握。鉴于此，写一片续集。实际上泛型可以用得很复杂，复杂到编写代码的人员自己也难以看懂。这往往是对泛型的滥用或者类或接口本身设计不合理导致的。看来用好泛型还真不容易，为此必须从根源说起。一、逐渐深入泛型1、没有任何重构的原始代码：有两个类如下，要构造两个类的对象，并打印出各自的成员x。p...
泛型(二)
yongchaocsdn的博客
12-11 619
我们知道，使用变量之前要定义，定义一个变量必须要指明它的数据类型，什么样的数据类型赋给什么样的值 加入我们现在要定义一个类来表示坐标，要求坐标，的数据类型可以是整数，小数和字符串，例如: x=10,y=10 x=12.88,y=129.65 x=”东京180度”,y=”北纬210度” 针对不同的数据类型，除了借助方法重载，还可以借助自动装箱和向上转型。我们知道，基本数据类型可以自动装箱，被转换成
Java中关于泛型的使用和特性
凡磊的技术栈
09-08 160
import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; /* * JDK1.5 出现了新的安全机制,保证程序的安全性 * 泛型:指明了集合存储数据的类型&lt;数据类型&gt; * */ public class GenericDemo { ...
后端研究-泛型机制在Apla-Java程序生成系统中实现的方法研究.pdf
06-23
编译器需要处理类型擦除（type erasure），这是Java泛型的一个特性，它在编译时移除了所有的类型参数，以保持与早期版本的Java兼容。同时，解释器需要在运行时正确地处理泛型对象，确保类型安全。 为了在Apla-Java...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值