JavaSE高级开发-泛型：

最新推荐文章于 2024-03-14 23:10:57 发布
最新推荐文章于 2024-03-14 23:10:57 发布
阅读量216 收藏
点赞数 2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/FTALYB/article/details/84836840
版权

JavaSE高级开发-泛型：

JDK1.5以后引入的三大常用新特性：

  1. 泛型：解决参数的转换问题；
  2. 枚举：enum；
  3. 注释：Annotation；

一、泛型问题引出：

假设需要定义一个可以描述坐标点的类Point，需要提供两个属性x，y。对于这两个属性的内容可以有如下的选择：

  • x = 10; y = 20;
  • x = 10.1; y = 20.1;
  • x = 东经80度; y = 北纬20度;

在Java中，只有Object型可以保存所有的类型。

【相关代码如下】：

class Point{
    private Object x;
    private Object y;
    public void setX(Object x) {
        this.x = x;
    }

    public Object getX() {
        return x;
    }

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

    public Object getY() {
        return y;
    }
}
public class test{
    public static void main(String[] args) {
        Point point1 = new Point();
        //自动装箱并且向上转型为Object：
        point1.setX(10);
        point1.setY(20);
        //由Object强制向下转型为int，并且自动拆箱：
        int x = (Integer)point1.getX();
        int y = (Integer)point1.getY();
        System.out.println("整型坐标：("+x+"，"+y+")");
        Point point2 = new Point();
        //自动装箱并且向上转型为Object：
        point2.setX(10.1);
        point2.setY(20.1);
        //由Object强制向下转型为double，并且自动拆箱：
        double z = (Double)point2.getX();
        double w = (Double)point2.getY();
        System.out.println("浮点型坐标：("+z+"，"+w+")");
        Point point3 = new Point();
        //自动装箱并且向上转型为Object：
        point3.setX("东经20度");
        point3.setY("北纬40度");
        //由Object强制向下转型为String，并且自动拆箱：
        String a = (String)point3.getX();
        String b = (String)point3.getY();
        System.out.println("字符串坐标：("+a+"，"+b+")");

        //与point4代码对比：
        Point point5 = new Point();
        point5.setX(10);
        point5.setY("北纬40度");
        System.out.println("字符串坐标：("+point5.getX()+"，"+point5.getY()+")");
        //错误代码：在主方法中，是用户输入，但是这里用户并不知道x的
        //坐标是double，接收方也不知道用户的输入，就会产生问题：
        //ClassCastException（指两个没有关系的对象因为强转而出现的异常），所以说
        //向下转型并不安全，会带来隐患。
        Point point4 = new Point();
        point4.setX(10);
        point4.setY("北纬40度");
        String c = (String)point4.getX();
        String d = (String)point4.getY();
        System.out.println("字符串坐标：("+c+"，"+d+")");
    }
}

【注意】：

  • 在进行向下转型的过程中，会出现程序错误的问题，因此向下转型是不安全的操作，会带来隐患；
  • 当开发中的程序可以避免向下转型（通过泛型），也就意味着安全隐患被消除，尽量不要使用向下转型；

二、泛型类的基本使用：

（1）泛型的定义：

  • 指的是在类定义的时候，并不会设置类中的属性或方法中的参数的具体类型，而是在类使用的时候在进行定义。

（2）如何进行泛型的操作？

  • 做一个类型标记的声明。

（3）泛型类的基本语法：

class MyClass<T>{
	T  value1；
}

【注意】：

  • <>中的T称为类型参数，用于指代任何类型；
  • 实际上这个T你可以任意写，但是出于规范的目的，还是建议我们用单个大写字母来代替类型参数，常见的有：
    - T：代表一般的任意类；
    - E：代表Element的意思，或者Exception异常的意思；
    - K：代表Key的意思；
    - V：代表value的意思，通常与K一起配合使用；
    - S：代表Subtype的意思；
  • 如果一个类被的形式定义，那么它就被称为泛型类；

（4）泛型类的使用：

  • MyClass myClass = new MyClass;
  • MyClass myClass = new MyClass;

【注意】：

  • 泛型只能接受类，所以的基本数据类型必须使用包装类！
  • 泛型类可以接收多个类型参数；

三、泛型方法：

泛型不仅可以定义类，还可以单独来定义方法。

（1）泛型方法的定义格式：

class MyClass{
	public <T> void testMethod(T t){
  		System.out.println(t);
	 }
}

【注意】：

  • 泛型类与泛型方法不同的是，放在public static 之后，返回值的前面；
  • <>中的T，在类中是类型参数，但是在方法中，T是参数化类型，并不是运行时真正的参数；
  • 声明的类型参数，也可以当做返回值的类型，如下代码所示：
class MyClass{
    public static <T> T testMethod(T t){
        return t;
    }
}
public class Test1{
    public static void main(String[] args) {
        MyClass myClass = new MyClass();
        System.out.println(myClass.testMethod(10));
    }
}

泛型方法与泛型类可以同时存在，如下代码所示：

class MyClass <T>{
        //泛型方法：使用别的类型参数名，避免与泛型类混淆
        public <E> E printT(E e){
            return e;
        }
        public void ptintOthers(){
            //整型：
            System.out.println(123);
        }
    }
    public class test{
        public static void main(String[] args) {
            MyClass myClass = new MyClass();
            myClass.ptintOthers();
            //String类型：
            System.out.println(myClass.printT("123木头人"));
        }
    }

【注意】：

  • 泛型类中的类型参数与泛型方法中的类型参数没有相应的联系，泛型方法始终以自己定义的类型参数为准；
  • 如果在泛型类中定义了一个泛型方法，为了避免与泛型类中的参数类型混淆，可以重新使用一个类型参数名，尽量使泛型类与泛型方法不重名；

四、通配符（重点）

（1）问题引入：
使用泛型类很好的避免了向下转型，使得程序变得安全，不在出现ClassCastException的问题，但是，使用泛型会带来参数不统一的问题，观察下面的代码：

class Message <T>{
    private T message;
    public T getMessage(){
        return message;
    }
    public void setMessage(T message){
        this.message = message;
    }
}
public class test{
    public static void main(String[] args) {
        Message<String> message1 = new Message<String>();
        message1.setMessage("hello world");
        fun(message1);
        
        /**
         * 注意：如果用户输入的不是String类型，就会出现新的问题
         * Message<String> message2 = new Message<String>();
         * message2.setMessage(123);
         * fun(message2);//这里就会出现错误
         */
    }
    public static void fun(Message<String> temp){
        System.out.println(temp.getMessage());
    }
}

（2）解决泛型类型带来的参数不统一的问题——使用通配符
现在需要的解决方案：可以接收所有类型的泛型，但是又不能够让用户随意修改，这时候就可以通过通配符“？”解决此问题，示例代码如下所示：

class Message <T>{
    private T message;
    public T getMessage(){
        return message;
    }
    public void setMessage(T message){
        this.message = message;
    }
}
public class test{
    public static void main(String[] args) {
        Message<String> message1 = new Message<String>();
        message1.setMessage("hello world");
        fun(message1);

        Message<Integer> message2 = new Message<Integer>();
        message2.setMessage(123);
        fun(message2);
    }
    //注意：此时使用通配符“？”代表它可以接收任意类型，但是由于
    //类型不确定，所以无法修改。
    public static void fun(Message<?> temp){
        System.out.println(temp.getMessage());
    }
}

（3）在“？”的基础上又产生的两个子通配符：
？ extends 类：设置泛型上限：
[例如]：
？ extends Number，表示只能够设置Number或其子类，比如：Integer、Double等；

？ super 类：设置泛型下限：
[例如]：
？ super String，表示只能够设置String及其父类Object；

▼观察设置泛型上限：可以用在声明，不能修改

class Message<T extends Number>{
    private T message;
    public T getMessage(){
        return message;
    }
    public void setMessage(T message){
        this.message = message;
    }
}
public class test{
    public static void main(String[] args) {
       Message<Integer> message = new Message<Integer>();
       message.setMessage(123);
       fun(message);
    }
    //表示只能够设置Number类及其子类：
    //此时使用通配符“？”表示它可以接收任何类型，但是由于不确定类型，所以无法修改
    public static void fun(Message<? extends Number> temp){
       //temp.setMessage(100);依然无法修改
       System.out.println(temp.getMessage());
    }
}

▼观察设置泛型下限：只能够用在方法参数中，可以修改

class Message<T>{
    private T message;

    public T getMessage() {
        return message;
    }
    public void setMessage(T message){
        this.message = message;
    }
}
public class test{
    public static void main(String[] args) {
        Message<String> message = new Message();
        message.setMessage("123木头人");
        fun(message);
    }
    public static void fun(Message<? super String> temp){
        //此时可以修改：
        temp.setMessage("123");
        System.out.println(temp.getMessage());
    }
}

五、泛型接口

泛型可以定义在类中，也可以定义在接口里面，这就是所谓的泛型接口。

（1）泛型接口的定义：

Interface IMessage<T> {
	public void print(T  t);
}

（2）对于这个接口，实现子类的两种做法：
【在子类定义的时候继续使用泛型】：

interface IMessage<T>{
    public void print(T t);
}
class MessageImpl<T> implements IMessage<T>{
    @Override
    public void print(T t) {
        System.out.println(t);
    }
}
public class test{
    public static void main(String[] args) {
        IMessage<String> msg = new MessageImpl<>();
        msg.print("123木头人");
    }
}

【在子类实现接口的时候明确给出具体的做法：

interface IMessage<T>{
    public void print(T t);
}
class MessageImpl implements IMessage<String>{
    @Override
    public void print(String  t) {
        System.out.println(t);
    }
}
public class test{
    public static void main(String[] args) {
        IMessage<String> msg = new MessageImpl();
        msg.print("123木头人");
    }
}

六、类型擦除
泛型是在JDK1.5之后才引进的概念，由上述可以看出，泛型代码可以与之前的版本很好的兼容，这是因为，泛型信息仅仅存在于代码编译阶段，在进入JVM之前，与泛型相关的信息会被擦除，专业属于就叫做类型擦除，也就是说，泛型与普通的类在Java虚拟机内没有什么不同。

class MyClass<T>{
    private T message;
    public T getMessage() {
        return message;
    }
    public void setMessage(T message) {
        this.message = message;
    }
    public void testMethod1(T t){
        System.out.println(t);
    }
}
public class test{
    public static void main(String[] args) {
        MyClass<String> myclass1 = new MyClass<>();
        MyClass<Integer> myClass2 = new MyClass<>();
        //注意：getClass() class<? extends MyClass>设置了泛型类的上限。
        System.out.println(myclass1.getClass() == myClass2.getClass());
        //结果是：true，因为MyClass<String>和MyClass<Integer>在JVM中的Class
        //都是MyClass.class
    }
}

【观察泛型中的类型擦除】：

import java.lang.reflect.Field;
class MyClass<T, E>{
    private T message;
    private E text;
    public T getMessage() {
        return message;
    }
    public void setMessage(T message) {
        this.message = message;
    }
    public E getText() {
        return text;
    }
    public void setText(E text) {
        this.text = text;
    }
    public void print(T t, E e){
        System.out.println(t+"，"+e);
    }
}
public class test{
    public static void main(String[] args) {
        MyClass<String, Integer> myClass = new MyClass<>();
        //取得类对象
        Class cls = myClass.getClass();
        Field[] field = cls.getDeclaredFields();
        for (Field field1: field) {
            System.out.println(field1.getType());
        }
    }
}

【注意】：
在泛型类被类型擦除的时候，之前的泛型类参数部分如果没有指定上限，如则会被转译成普通的Object类型，如果指定了上限如则类型参数就会被替换为类型上限。

FTALYB
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
4 Day14--泛型+集合1
abu1216的博客
11-29 190
4.1泛型 4.1.1概念 public class LinkedList<E> extends AbstractSequentialList<E> implementsList<E>, Deque<E>, Cloneable, java.io.Serializable{} public interface Deque<E>extendsQueue<E> {} public interfa...
javase-training:Java SE培训幻灯片
05-07
这个"javase-training:Java SE培训幻灯片"很显然是一个针对Java SE的学习资源，旨在帮助学习者掌握Java编程语言的基础和高级特性。让我们深入探讨一下Java SE中的关键知识点。 1. **Java语法基础**：Java是一种面向...
JavaSE高级开发----泛型
weixin_43224539的博客
12-22 157
泛型 从JDK1.5以后引入了三大常用新特性： 泛型 枚举(enum) 注解(Annotation) 其中在JDK1.5中泛型是一件非常重要的实现技术，它可以帮助我们解决程序的参数转换问题。通常我们遇到参数类型冲突的时候一般需要转换参数类型来解决问题,而有了泛型就不需要了. 泛型,顾名思义就是广泛的类型,也就是可以接受各种参数类型 一.泛型问题的引出 首先我们来想想,不了解泛型之前我们是怎么解决...
JavaSE笔记-泛型与集合类
a35065521的博客
05-06 760
JavaSE笔记-泛型与集合类 在前面我们学习了最重要的类和对象，了解了面向对象编程的思想，注意，非常重要，面向对象是必须要深入理解和掌握的内容，不能草草结束。在本章节，我们会继续深入了解，从我们的泛型开始，再到我们的数据结构，最后再开始我们的集合类学习。 走进泛型 为了统计学生成绩，要求设计一个Score对象，包括课程名称、课程号、课程成绩，但是成绩分为两种，一种是以优秀、良好、合格 来作为结果，还有一种就是 60.0、75.5、92.5 这样的数字分数，那么现在该如何去设计这样的一个Score类呢？现在
JavaSE高级开发之泛型
近未来
02-25 213
泛型 - 守门员 定义： 在类定义的时候并不会设置类中的属性或方法中参数的具体类型，而是在类使用时再定义 1.泛型类 语法： class MyClass&lt;T&gt; { T value1; public &lt;E&gt; void test(T t) { } } T 被称为类型参数，用于指代任何类型。 T ：代表一般的任何类。 E ：代表 Element ，或者 Exce...
Java基础-泛型
左灯右行的爱情
03-14 853
加油
collection-泛型
penghui_的博客
07-26 261
day02【Collection、泛型】 主要内容 Collection集合 迭代器 增强for 泛型 教学目标 能够说出集合与数组的区别 说出Collection集合的常用功能 能够使用迭代器对集合进行取元素 能够说出集合的使用细节 能够使用集合存储自定义类型 能够使用foreach循环遍历集合 能够使用泛型定义集合对象 能够理解泛型上下限 能够阐述泛型通配符的作用 第一章 Collection集合 1.1 集合概述 在前面基础班我们已经学习过并使用过集合ArrayList ,那
黑马程序员----JAVASE高级部分之泛型
woaibeijixiong的专栏
11-17 730
泛型
Java-SE-泛型的简单认识及应用
wexin_mylove的博客
01-28 1792
JavaSE中的泛型功能的具体介绍以及泛型在代码中的应用，包括ArrayList以及HashMap
JAVASE（四）泛型与集合类
m0_51448653的博客
05-20 185
（三）异常机制 当程序运行出现我们没有考虑到的情况时，就有可能出现异常或是错误！ 异常 我们在之前其实已经接触过一些异常了，比如数组越界异常，空指针异常，算术异常等，他们其实都是异常类型，我们的每一个异常也是一个类，他们都继承自Exception类！异常类型本质依然类的对象，但是异常类型支持在程序运行出现问题时抛出（也就是上面出现的红色报错）也可以提前声明，告知使用者需要处理可能会出现的异常！ 运行时异常 异常的第一种类型是运行时异常，如上述的列子，在编译阶段无法感知代码是否会出现问题，只有在运行的时候才知
java-self-cultivation:Java基础语言学习
04-02
10. **泛型**：泛型引入了类型参数，增强了类型安全，减少了强制类型转换，提高了代码可读性和可维护性。 11. **注解（Annotation）**：注解用于向编译器或JVM提供元数据，可以用于代码的编译时检查、运行时处理、...
java源码知乎-JavaSE:JavaSE知乎专栏源代码，知乎专栏：https://zhuanlan.zhihu.com/javase
05-24
JavaSE，全称为Java Standard Edition，是Java平台的标准版，主要面向桌面应用和服务器端开发。这个JavaSE知乎专栏源代码提供了丰富的学习材料，旨在帮助开发者深入理解Java编程语言的基础和高级特性。在这个开源...
李兴华-JavaSE开发详解笔记-李兴华
02-07
最后，JavaSE还包含了泛型、Lambda表达式等高级特性，它们极大地提升了代码的可读性和效率。泛型可以确保类型安全，而Lambda表达式则是函数式编程的体现，简化了回调函数的编写。 李兴华的"JavaSE开发详解笔记"覆盖...
learn-java:目标是在1.5个月内获得Oracle Certified Java SE 11 Developer的证书
03-19
以下是一份详细的Java学习指南，涵盖从基础到高级的主题，以确保你在短时间内有效地学习。 首先，你需要了解Java的基础。Java是一种面向对象的编程语言，由Sun Microsystems（现为Oracle Corporation）于1995年发布...
前端分析-202307110039
最新发布
07-29
前端分析-202307110039
Oracle中文基础PPT
07-29
Oracle中文基础PPT 虽然是10g，但是学习Oracle，10g版本没问题 Less01_DB_Architecture_MB3.ppt Less02_Installation_MB3.ppt Less03_DB_DBCA_MB3.ppt Less04_Instance_TB3.ppt Less05_Storage_TB3.ppt Less06_Users_MB3.ppt Less07_Schema_TB3.ppt Less08_Data_TB3.ppt Less09_Undo_TB3.ppt Less10_Security_MB3.ppt Less11_Network_MB3.ppt Less12_ProactiveM_MB3.ppt Less13_Performance_TB3.ppt Less14_BR_Concepts_MB3.ppt Less15_Backups_TB3.ppt Less16_R
【创新未发表】Matlab实现粒子群优化算法PSO-Kmean-Transformer-BiLSTM负荷预测算法研究.rar
07-29
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
Java项目：基于SSM框架实现的公务员培训机构管理系统【ssm+B/S架构+源码+数据库+开题+任务书+毕业论文】
07-29
一、项目简介 本项目是一套基于SSM框架实现的公务员培训机构管理系统 包含：项目源码、数据库脚本等，该项目附带全部源码可作为毕设使用。 项目都经过严格调试，eclipse或者idea 确保可以运行！ 该系统功能完善、界面美观、操作简单、功能齐全、管理便捷，具有很高的实际应用价值 二、技术实现 jdk版本：1.8 及以上 ide工具：IDEA或者eclipse 数据库: mysql5.7 后端：spring+springmvc+mybatis+maven+mysql 前端：jsp，css，js 三、系统功能 系统登录角色包括管理员、考生、在职公务员 后台主要功能包括： 个人中心 修改密码 个人信息 在职公务员管理 考生管理 管理员信息 讲师管理 备考课程管理 基础数据管理 单位管理 公告类型管理 课程类型管理 在职培训课程管理 公告管理 轮播图管理等功能 前台主要功能包括： 用户登录 用户注册 首页 备考课程展示 课程详情 立即预订 讲师展示 公告信息 个人中心 备考课程预订 在职培训课程预订 余额充值 在职培训课程 跳转到后台等功能
JavaSE高级开发实战教程
"这是一份JavaSE的实训教材，涵盖了从基础API到高级应用程序开发的内容，包括了集合、泛型、I/O流、线程同步等多个主题。由盈佳科技出品，旨在帮助开发者掌握Java编程的核心技能。" 这份JavaSE实训教材详细介绍了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值