Java泛型小结

最新推荐文章于 2025-02-18 10:30:47 发布
最新推荐文章于 2025-02-18 10:30:47 发布
阅读量407 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： Java 文章标签： 泛型
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Wisimer/article/details/89574871
一、普通的泛型

比如我们经常使用的List data = new ArrayList;
这里我们直接指定List中存储的是String类型的数据，避免在get的时候还要强制转换。

1.来定义一个简单的泛型：

public class MessageQueue<T> {
    private T mMsg = null;
    public T getMsg() {
        return mMsg;
    }
    public void addMsg(T msg) {
        this.mMsg = msg;
    }
    public void printMsg() {
        System.out.println(this.mMsg);
    }
}

2.测试代码：

public class TypeTest {
    public static void main(String[] args) {
        System.out.println("= = = = = = = = MessageQueue | 基本泛型 = = = = = = = = = ");
        MessageQueue<String> mq= new MessageQueue<String>();
        mq.addMsg("MQ");
        System.out.println(mq.getMsg());
        mq.printMsg();
        MessageQueue<Integer> mqInt= new MessageQueue<Integer>();
        mqInt.addMsg(1);
        System.out.println(mqInt.getMsg());
        mqInt.printMsg();
    }
}

3.可以看到运行的结果是：

= = = = = = = = MessageQueue | 基本泛型 = = = = = = = = =
MQ
MQ
1
1
二、两个或者多个泛型参数

1.还是来定义含有两个参数的泛型类

public class UserInfo<K,V> {
  private K key;
  private V value;
  public void put(K key,V value) {
    this.key = key;
    this.value = value;
  }

  public K getKey() {
    return key;
  }

  public V getValue() {
    return value;
  }

  public String toString() {
      return this.key.toString() + " | " + value.toString();
  }
}

2.测试代码：

public class TypeTest {
    public static void main(String[] args) {
        System.out.println("= = = = = = = = UserInfo | 两个泛型参数 = = = = = = = = = ");
        UserInfo<Integer,String> userInfo = new UserInfo<Integer,String>();
        userInfo.put(2,"wxp");
        System.out.println(userInfo.toString());
    }
}

3.看一下运行的结果：

= = = = = = = = UserInfo | 两个泛型参数 = = = = = = = = =
2 | wxp

第一个参数就是key，第二个参数就是value

三、泛型通配符

1.定义一个简单的泛型，或者直接使用上面的MessageQueue类，都是可以的

public class MsgModel<T> {
    private T mMsg = null;
    public T getMsg() {
      return mMsg;
    }
    public void addMsg(T msg) {
      this.mMsg = msg;
    }
    @Override
    public String toString() {
      return this.mMsg.toString();
    }
}

2.接着定义一个printStringMsgModel方法，这个方法的参数时一个MsgModel类型，但是它的泛型参数只能只能接收String或Object（String的父类）类型的泛型，这个是受限通配符，用<? extends String>表示。

    //受限通配符，限制泛型参数只能接收String或Object类型的泛型
    public static void printStringMsgModel(MsgModel<? extends String> model) {
        System.out.println("model = "+model.toString());
    }

3.测试代码：

public class TypeTest {
    public static void main(String[] args) {
        System.out.println("= = = = = = = = MsgModel | 通配符 = = = = = = = = = ");
        MsgModel<String> msgModel = new MsgModel<String>();
        msgModel.addMsg("www");
        printStringMsgModel(msgModel);
    }
}

4.运行的结果是：

= = = = = = = = MsgModel | 通配符 = = = = = = = = =
model = www
  • <? extends UserInfo> 表示上边界通配符，参数类型只能是UserInfo或者其子类
  • <? super UserInfo> 表示下边界通配符，参数类型只能是UserInfo或者其父类

5.或者也可以这样定义一个printUserInfoMsgModel方法，表示只能接受UserInfo或者其子类的泛型参数

    //受限通配符，限制泛型参数只能接收UserInfo或子类类型的泛型
    public static void printUserInfoMsgModel(MsgModel<? extends UserInfo> model) {
        System.out.println("model = "+model.getMsg().toString());
    }

测试一下：

public class TypeTest {
    public static void main(String[] args) {
        UserInfo<Integer,String> userInfo1 = new UserInfo<Integer,String>();
        userInfo1.put(3,"wxp");
        MsgModel<UserInfo> msgModelUserInfo = new MsgModel<UserInfo>();
        msgModelUserInfo.addMsg(userInfo1);
        printUserInfoMsgModel(msgModelUserInfo);
    }
}

运行的结果：

model = 3 | wxp

6.如果是非受限通配符的话直接使用MsgModel<? >这样就可以了

四.泛型接口

1.定义一个泛型接口

public interface IUploadMsg<T> {
    public void upload(T msg);
}

2.定义一个UploadAction类，并实现IUploadMsg接口

    //泛型接口
    public static class UploadAction<T> implements IUploadMsg<T> {
        private T mMsg;
        public void addMsg(T msg) {
            this.mMsg = msg;
            upload(msg);
        }

        @Override
        public void upload(T msg) {
            System.out.println("uploading msg..."+msg.toString());
        }
    }

3.测试代码：

public class TypeTest {
    public static void main(String[] args) {
        System.out.println("= = = = = = = = IUploadMsg | 泛型接口 = = = = = = = = = ");
        UploadAction<String> uploadAction = new UploadAction<String>();
        uploadAction.addMsg("xxx");

        UploadIntAction uploadIntAction = new UploadIntAction();
        uploadIntAction.addMsg(4);
    }
}

4.看一下运行结果：

= = = = = = = = IUploadMsg | 泛型接口 = = = = = = = = =
uploading msg...xxx
uploading msg...4
五、泛型方法

1.定义一个DownloadMsg类，它有一个download方法，可以传入一个泛型参数msg

public class DownloadMsg {
    public static <T> void download(T msg) {
        System.out.println("Downloading msg..."+msg.toString());
    }
}

2.测试代码：

public class TypeTest {
    public static void main(String[] args) {
        System.out.println("= = = = = = = = DownloadMsg | 泛型方法 = = = = = = = = = ");
        DownloadMsg.download("ppp");
        DownloadMsg.download(5.0);
    }
}

3.看一下运行结果：

= = = = = = = = DownloadMsg | 泛型方法 = = = = = = = = =
Downloading msg...ppp
Downloading msg...5.0
六、泛型方法返回泛型实例

1.定义一个普通的泛型类

public class GenerateInfo<T> {
    private T mInfo;
    public void setInfo(T info) {
        mInfo = info;
    }
    public T getInfo() {
        return mInfo;
    }
    public String toString() {
        System.out.println(this.mInfo.toString());
        return mInfo.toString();
    }
}

2.定义一个方法，传入泛型参数，返回一个泛型实例

    public static <T> GenerateInfo<T> genInfo(T info) {
        GenerateInfo<T> temp = new GenerateInfo<T>();
        temp.setInfo(info);
        return temp;
    }

3.测试代码：

public class TypeTest {
    public static void main(String[] args) {
        System.out.println("= = = = = = = = GenerateInfo | 泛型方法返回泛型实例 = = = = = = = = = ");
        GenerateInfo<String> info = genInfo("wwwxxxppp");
        info.toString();

        UserInfo<String,Integer> userInfo2 = genUserInfo("wxp",5);
        System.out.println(userInfo2.toString());
    }
}

4.运行结果：

= = = = = = = = GenerateInfo | 泛型方法返回泛型实例 = = = = = = = = =
wwwxxxppp
wxp | 5
七、类型擦除

泛型是 Java 1.5 版本才引进的概念，在这之前是没有泛型的概念的，但显然，泛型代码能够很好地和之前版本的代码很好地兼容。

这是因为，泛型信息只存在于代码编译阶段，在进入 JVM 之前，与泛型相关的信息会被擦除掉，专业术语叫做类型擦除。

通俗地讲，泛型类和普通类在 java 虚拟机内是没有什么特别的地方。例如：

List<String> l1 = new ArrayList<String>();
List<Integer> l2 = new ArrayList<Integer>();
System.out.println(l1.getClass() == l2.getClass());

这个代码输出的就是true，因为编译之后，List中的泛型参数类型全部被设置为Object。

但是如果使用 extends ` ，对类型的上限和下限进行设置，那么类型擦除之后就不是Object了，例如：

public class Erasure <T extends String>{
	T object;
	public Erasure(T object) {
		this.object = object;
	}
}

Erasure<String> erasure = new Erasure<String>("hello");
Class eclz = erasure.getClass();
Field[] fs = eclz.getDeclaredFields();
for ( Field f:fs) {
	System.out.println("Field name "+f.getName()+" type:"+f.getType().getName());
}

输出：Field name object type:java.lang.String

所以，总结一下，在泛型类被类型擦除的时候，之前泛型类中的类型参数部分如果没有指定上限，如 则会被转译成普通的 Object 类型，如果指定了上限如 则类型参数就被替换成类型上限。

THE END.

深入理解 Java 泛型
Chiclaim
10-14 762
彻底搞懂 Java 泛型
Java泛型学习记录
鱼蛋的博客
03-14 1598
1 什么是泛型（Generic Type） “参数化类型” 就是所操作的数据类型被指定为一个参数，然后在使用/调用时传入具体的类型。 2 泛型怎么用 2.1 泛型类 class A<T>{ T t; public void set(T t){ this.t = t; } public T get(){ return t; } } //泛型类的使用 A<String> a = new A<>(); 2.2 泛型接口 in
java泛型类 方法 接口_Java泛型：接收实现类的类型参数的接口方法
weixin_42250191的博客
02-13 2115
在Java中,是否可以定义一个接口,该接口具有接收实现类参数的方法？接口：public interface MyInterface {public void method(T object);}类：public class A implements MyInterface {public void method(A object) {...}}我想避免的是一个类可以像其他类一样实现MyInter...
添加泛型string object_带你深挖Java泛型类型擦除以及类型擦除带来的问题
weixin_33604071的博客
01-22 312
点击上方“Java知音”，选择“置顶公众号”技术文章第一时间送达！作者：蜗牛大师cnblogs.com/wuqinglong/p/9456193.html1.Java泛型的实现方法：类型擦除大家都知道，Java的泛型是伪泛型，这是因为Java在编译期间，所有的泛型信息都会被擦掉，正确理解泛型概念的首要前提是理解类型擦除。Java的泛型基本上都是在编译器这个层次上实现的，在生成的字节码中是...
java模型给泛型_模型映射器将Map <String，Object>映射到扩展另一个不适用于列表字段的泛型类的类...
weixin_30651409的博客
02-25 270
我正在尝试使用模型映射器从Map创建自定义配置对象 . 一切都得到正确映射，除了 fields 属性，它来自Generic超类 .我的目标对象是public class ADParserConfig extends CustomParserConfig {private String pattern;public String getPattern() {return pattern;}publi...
Java全栈知识（5）泛型机制详解
dghehe的博客
04-05 792
这些也被叫做泛型类，泛型接口，泛型方法。为我们的本意是把子类中的泛型也都指定为Date类型，但是由于泛型擦除机制，此时的父类和子类中同名方法的返回类型就变得不相同了，而重写也就变成了重载，泛型擦除就和多态发生冲突。泛型机制是JDK1.5引入的新内容，所以说需要与老的代码兼容，所以说Java实现的其实是一种”伪泛型“的机制，即在编译期会把里的内容全部擦去，替换为具体的类型。我们可以看到在子类中我们覆盖了弗雷德两个方法，但是因为泛型擦除的机制，编译的时候父类方法中的泛型都被擦除为Object。
linux 虚拟gprs设备,Ubuntu使用手机作为GPRS modem上网体验
weixin_30068377的博客
05-10 137
与刚才前面的一篇的 Linux中让智能手机使用蓝牙连接PC并利用PC网络上网 不同,本篇主要解决当笔记本周围没有固定上网设施时,如果利用手机的GPRS功能使笔记本上网.本文在nokia 5500 及 Sony Erisson W958C上测试通过.在Ubuntu下安装gnome-ppp及wvdial..1.使用usb数据线,将手机连接到电脑.运行dmesg 或 cat /var/log/messa...
不同Java泛型构造函数的详解
08-25
4. 小结 在本文中，我们讨论了Java中的泛型构造函数，包括非泛型类中的泛型构造函数和泛型类中的泛型构造函数。我们也学习了如何使用泛型构造函数来创建对象。在实际开发中，泛型构造函数可以帮助我们编写更加灵活...
Java 中的泛型详解
XuChaofafa的博客
05-29 1434
泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参列表，普通方法的形参列表中，每个形参的数据类型是确定的，而变量是一个参数。在调用普通方法时需要传入对应形参数据类型的变量（实参），若传入的实参与形参定义的数据类型不匹配，则会报错。那参数化类型是什么？以方法的定义为例，在方法定义时，将方法签名中的形参的数据类型也设置为参数（也可称之为类型参数），在调用该方法时再从外部传入一个具体的数据类型和变量。
Java 泛型与反射
最新发布
02-18 1044
Java 泛型与反射
封装、继承、多态和抽象（日常开发常用）
心有谦谦结
09-08 1173
Java的四个基本特性：封装、继承、多态和抽象 （1）抽象：将一类对象的共同特征总结出来，然后构造成类的过程（包括数据抽象和行为抽象）。抽象只关注对象的属性和行为，不关注行为的细节。 （2）封装：把数据和操作数据的方法绑定起来，对数据的访问只能通过已定义好的接口。 好处：【1】保证数据的安全性，防止调用者随意更改数据。（例如，我们在封装一些常用的工具类时，会把类的无参构造器私有化或者在类名前使用abstract修饰，不准创建该类，达到只能调用，不能修改的效果） 【2】提高代码的复用性。（把..
Java学习（95）Java泛型——泛型作为方法参数和方法重载
weixin_43360025的博客
01-15 2862
Java学习（95）Java泛型——泛型作为方法参数和方法重载
Java中的泛型 - 细节篇
汤圆学Java
04-08 838
前言 大家好啊，我是汤圆，今天给大家带来的是《Java中的泛型 - 细节篇》，希望对大家有帮助，谢谢 细心的观众朋友们可能发现了，现在的标题不再是入门篇，而是各种详细篇，细节篇； 是因为之前的几篇比较简单，所以叫做入门篇会合适点； 现在往后的都慢慢的开始复杂化了，所以叫入门就有点标题党了，所以改叫详细篇或者细节篇或者进阶篇等等 文章纯属原创，个人总结难免有差错，如果有，麻烦在评论区回复或后台私信，谢啦 简介 泛型的作用就是把类型参数化，也就是我们常说的类型参数 平时我们接触的普通方法的参数，比如publ
添加泛型string object_Java泛型中的类型擦除详解
weixin_39913141的博客
01-27 218
本文目录1.Java泛型的实现方法：类型擦除2.类型擦除后保留的原始类型3.类型擦除引起的问题及解决方法1.Java泛型的实现方法：类型擦除大家都知道，Java的泛型是伪泛型，这是因为Java在编译期间，所有的泛型信息都会被擦掉，正确理解泛型概念的首要前提是理解类型擦除。Java的泛型基本上都是在编译器这个层次上实现的，在生成的字节码中是不包含泛型中的类型信息的，使用泛型的时候加上类型参数，在编译...
添加泛型string object_3分钟带你彻底搞懂泛型背后的秘密
weixin_42400643的博客
01-23 263
码个蛋(codeegg)第 751 次推文作者：的一幕原文：https://www.jianshu.com/p/dd34211f2565这一节主要讲的内容是java中泛型的应用，通过该篇让大家更好地理解泛型，以及面试中经常说的泛型类型擦除是什么概念，今天就带着这几个问题一起看下:举一个简单的例子:这里可以看出来在代码编写阶段就已经报错了，不能往string类型的集合中添加int类型的数据。那可不可...
调用泛型对象方法List＜T＞并返回泛型结果Map ＜String，Object＞，参数为具体对象集合，根据不同对象类型进行不同操作
dmlcq的博客
09-08 1828
然后调用公共方法getChoosePlansMap()，公共方法可能是不同对象集合。到方法里再根据传入的对象类型，实现不同的处理逻辑。首先要对集合处理，取集合其中某几条的数据，业务方法getRequireMap()。遍历集合，获取参数的实例化对象desObj。最后对泛型map进行实例化转换操作。根据不同类型进行操作。
Java集合泛型--无泛型、Object泛型、?泛型之间的区别
SunHongmin
06-27 659
/** List List<Object> List<Integer> List<?>之间的区别 * 集合之间的转换和数组转换之间的差异 * @param args */ public static void main(String[] args) { List list1 = new ArrayList(); list1.add(ne...
直接在终端对Java代码进行Debug
Wisimer
08-09 4104
有时候写个小算法或者Demo时不想用IDE，直接打开Atom就可以写了。但是如果遇到bug，就只能在命令行终端调试了。下面看看如何在终端使用jdb调试Java代码。1. 编译准备使用 -g 参数编译Java代码： javac -g Test.java 2. jdb初始化执行命令： jdb Test 此时会显示：Sort wxp$ jdb Test 正在初始化jdb...3. 设置断点 s
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值