Java中的协变、逆变

Java 泛型中的逆变与协变 在 Java 泛型中,逆变(contravariance)和协变(covariance)是两个重要的概念。本文将详细介绍逆变和协变的概念,并使用相应的源代码进行说明。逆变和协变是 Java 泛型中非常有用的概念,它们使我们能够更灵活地处理参数化类型的继承关系。通过合理地运用逆变和协变,我们可以编写更具通用性和可复用性的代码。在 Java 中,协变可以通过通配符(wildcard)和子类型限定(extends)实现。在 Java 中,逆变可以通过通配符(wildcard)和超类型限定(super)实现。 阅读详情

在 Java 中,协变(Covariance) 和 逆变(Contravariance) 是泛型系统中的重要概念,用于描述子类型如何在复杂类型(如集合)中传递。

1. 基础概念:什么是协变和逆变?

假设 B 是 A 的子类型(例如 Integer 是 Number 的子类型),那么:

  • 协变:List<B> 是 List<A> 的子类型(允许从子类型向父类型转换)。
  • 逆变:List<A> 是 List<B> 的子类型(允许从父类型向子类型转换)。
  • 不变:List<B> 和 List<A> 之间没有继承关系(不允许直接转换)。

Java 中的规则:

  • 数组是协变的,但可能导致运行时错误。
  • 泛型是不变的,但可以通过通配符(? extends T 和 ? super T)实现有限的协变和逆变。

2. 数组的协变(Java 中的特殊情况)

Java 的数组是协变的,即如果 B 是 A 的子类,则 B[] 可以赋值给 A[]。但这可能导致运行时异常:

Number[] numbers = new Integer[5]; // 合法,数组是协变的
numbers[0] = 3.14; // 运行时错误:ArrayStoreException(数组类型不匹配)

类比:
想象一个 “水果篮子”(Fruit[]),可以放入苹果(Apple[])或香蕉(Banana[])。但如果篮子实际装的是苹果(new Apple[5]),你却试图放入香蕉(Banana),就会报错。

3. 泛型的不可协变性(不变性)

Java 的泛型是不可协变的,即 List<B> 不是 List<A> 的子类型,即使 B 是 A 的子类。例如:

List<Number> numbers = new ArrayList<Integer>(); // 编译错误!

为什么泛型不可协变?
如果允许这样的赋值,会破坏类型安全。例如:

List<Integer> ints = new ArrayList<>();
ints.add(10);

// 假设允许 List<Integer> 赋值给 List<Number>
List<Number> nums = ints; // 编译错误(实际不允许)
nums.add(3.14); // 如果允许,这里会向 List<Integer> 中添加 Double!
Integer i = ints.get(0); // 运行时 ClassCastException!

类比:
想象一个 “苹果篮子”(List<Apple>)和一个 “水果篮子”(List<Fruit>)。虽然苹果是水果的一种,但 “苹果篮子”不是“水果篮子” 的子类。如果允许将 “苹果篮子” 当作 “水果篮子”,就可能向其中放入香蕉,导致类型错误。

4. 泛型通配符实现有限的协变和逆变

虽然泛型本身不可协变,但可以通过通配符实现安全的类型转换:

(1)上限通配符 ? extends T(协变)

允许读取 T 类型的元素,但不能写入(除了 null):

List<? extends Number> numbers = new ArrayList<Integer>(); // 合法
Number num = numbers.get(0); // 合法,读取为 Number
// numbers.add(10); // 编译错误,不能添加任何类型(除了 null)

作用:安全地从集合中读取元素(生产者)。
类比:
有一个 “水果篮子”(List<? extends Fruit>),你知道里面装的是水果(或其子类),但不确定具体是哪种水果。因此,你可以安全地从中取出水果(作为 Fruit 类型),但不能向其中添加任何水果(因为不知道篮子的具体类型)。

(2)下限通配符 ? super T(逆变)

允许写入 T 类型的元素,但读取时只能作为 Object:

List<? super Integer> numbers = new ArrayList<Number>(); // 合法
numbers.add(10); // 合法,可添加 Integer
Object obj = numbers.get(0); // 读取为 Object

作用:安全地向集合中写入元素(消费者)。
类比:
有一个 “篮子”(List<? super Apple>),你知道它可以装苹果(或其父类,如水果、食物)。因此,你可以安全地向其中放入苹果(Apple),但取出时只能当作 “物品”(Object),因为不确定篮子的具体类型。

5. 协变与逆变的对比表

场景数组(协变)泛型(不变)泛型通配符(有限协变 / 逆变)
赋值Number[] = Integer[](合法)List<Number> = List<Integer>(编译错误)List<? extends Number> = List<Integer>(合法)
写入元素可能运行时错误编译错误? extends T:禁止写入 ? super T:允许写入 T
读取元素安全安全? extends T:读取为 T ? super T:读取为 Object
类型安全运行时可能出错编译阶段强制检查编译阶段保证安全

6. 总结:何时使用协变和逆变?

  • 协变(? extends T):当你只需要从集合中读取元素时使用。例如:

    // 安全地读取 List<Integer> 中的元素
    List<? extends Number> nums = List.of(1, 2, 3);
    Number n = nums.get(0); // 合法
    
  • 逆变(? super T):当你只需要向集合中

    // 安全地向 List<Object> 中添加 Integer
    List<? super Integer> nums = new ArrayList<>();
    nums.add(10); // 合法
    

通过通配符,Java 泛型在保证类型安全的前提下,提供了一定的灵活性。理解协变和逆变是掌握 Java 泛型高级用法的关键。

7. 使用场景

(1)只读场景:使用 ? extends T(协变)

如果你只需要从集合中读取元素,使用上限通配符 ? extends T。
示例:计算数字集合的总和:

public double sum(List<? extends Number> numbers) {
    double sum = 0;
    for (Number num : numbers) {
        sum += num.doubleValue();
    }
    return sum;
}

// 可以传入 List<Integer> 或 List<Double>
List<Integer> ints = List.of(1, 2, 3);
sum(ints); // 合法

List<Double> doubles = List.of(1.5, 2.5);
sum(doubles); // 合法

限制:不能向 List<? extends Number> 中添加元素(除了 null),因为无法确定具体类型。

(2)只写场景:使用 ? super T(逆变)

如果你只需要向集合中写入元素,使用下限通配符 ? super T。
示例:将整数添加到集合中:

public void addNumbers(List<? super Integer> numbers) {
    for (int i = 0; i < 10; i++) {
        numbers.add(i); // 合法:可以添加 Integer 类型
    }
}

// 可以传入 List<Integer>、List<Number> 或 List<Object>
List<Number> nums = new ArrayList<>();
addNumbers(nums); // 合法

限制:从 List<? super Integer> 中读取元素时,只能作为 Object 类型,因为无法确定具体类型。

(3)读写兼顾场景:使用不变(无通配符)

如果你需要对集合进行读写操作,则不使用通配符,直接指定具体类型。
示例:操作整数列表:

public void processIntegers(List<Integer> ints) {
    // 读取元素
    int first = ints.get(0);
    
    // 写入元素
    ints.add(first * 2);
}

// 只能传入 List<Integer>,不能传入 List<Number> 或 List<Object>
List<Integer> ints = new ArrayList<>();
processIntegers(ints); // 合法

限制:类型必须精确匹配,不允许类型转换。

8. 常见误区与注意事项

  1. 数组的协变陷阱:
    数组的协变可能导致运行时异常(ArrayStoreException),应尽量避免将子类数组赋值给父类数组变量。

  2. 通配符与子类的区别:
    List<? extends Number> 不代表 “所有 Number 子类的列表”,而是 “某个具体子类的列表”。例如:

    List<? extends Number> nums = new ArrayList<Integer>(); // 合法
    // nums.add(3.14); // 编译错误:无法确定具体类型
    
  3. 逆变的读取限制:
    List<? super Integer> 中读取的元素只能作为 Object,因为无法确定集合的具体类型。

  4. 泛型方法 vs 通配符:
    如果需要在多个参数或返回值之间建立类型关联,优先使用泛型方法而非通配符。例如:

    <T> void swap(List<T> list, int i, int j); // 泛型方法,保证两个索引位置的元素类型一致
    

9. 实战案例

案例 1:生产者场景(读取数据)
// 计算集合中所有数字的平均值
public double average(List<? extends Number> numbers) {
    double sum = 0;
    for (Number num : numbers) {
        sum += num.doubleValue();
    }
    return sum / numbers.size();
}
案例 2:消费者场景(写入数据)
// 将元素添加到集合
public void fill(List<? super String> list, String value, int count) {
    for (int i = 0; i < count; i++) {
        list.add(value); // 合法:可以添加 String
    }
}
案例 3:读写兼顾场景(精确类型)
// 对列表中的每个元素执行操作
public void transform(List<Integer> list, Function<Integer, Integer> mapper) {
    for (int i = 0; i < list.size(); i++) {
        list.set(i, mapper.apply(list.get(i))); // 读写操作,必须精确类型
    }
}
深入探讨Java中的协变、逆变、双变与不变性 在Java编程语言中,类型系统是确保程序正确性的关键部分。类型系统的一个重要特性是子类型化(Subtyping),它允许在某些上下文中使用一个类型的实例代替另一个类型的实例。Java支持多种子类型化规则,包括协变(Covariant)、逆变(Contravariant)、双变(Bivariant)和不变性(Invariant)。本文将深入探讨这些概念,并结合实例进行说明。 阅读详情

相关推荐

Java中的逆变与协变编程

例如,逆变只能用于方法参数,不能用于方法返回类型;此外,通配符类型的对象无法直接赋值给具体类型的对象,需要进行类型转换。逆变和协变是Java泛型中的重要概念,它们允许在类型安全的前提下更灵活地使用泛型。本文将详细介绍逆变和协变的概念,并提供一些示例代码来说明它们的用法。通过逆变和协变,我们可以创建更通用的容器类,使其能够处理更多类型的对象。,我们希望创建一个能够接受任意类型动物的容器类。,我们希望创建一个能够存储任意类型动物的容器类。类型的引用,并确保容器中存储的对象是。的类型参数,表示它可以接受。

CodeSpark的博客 261

Java 泛型的协变与逆变

Java 泛型中的协变与逆变

qq_38074398的博客 1847

Java中的逆变与协变

逆变与协变用来描述类型转换(type transformation)后的继承关系,其定义:如果AAABBB表示类型,f⋅f(\cdot)f⋅表示类型转换,≤\leq≤表示继承关系(比如,A≤BA \leq BA≤B表示AAA是由BBB派生出来的子类);f⋅f(\cdot)f⋅是逆变(contravariant)的,当A≤BA \leq BA≤B时有fB≤fAfB≤fA成立;

听雨草堂 707

Java 泛型的型变 (协变、逆变) 和不变

通过PageVO引出的泛型思考: 首先声明: java中对于泛型的型变只是一种约束; 和kotlin等其他语言并不一致. 型变: 分为逆变和协变, 与不变对应 协变(covariant),如果它保持了子类型序关系≦。该序关系是:子类型≦基类型。 逆变(contravariant),如果它逆转了子类型序关系。 不变(invariant),如果上述两种均不适用。 假设Orange类是Fruit类的子类,以集合类List为例: 型变:用来描述类型转换后的继承关系(即协变、逆变和不变的统称)。比如:List

howeres的博客 4299

华为IC岗笔试刷题含答案(2)

又做了几套题,记录了部分及答案,如有错误,欢迎评论指正。

Ingrid的博客 1万+

嘉立创EDA实战:从点亮第一盏灯到完成首块PCB

本文详细介绍了使用嘉立创EDA从点亮第一盏LED灯到完成首块PCB的全过程。通过实战案例分享,包括原理图绘制、PCB设计、DRC检查、覆铜操作等关键步骤,帮助电子设计爱好者快速掌握嘉立创EDA的使用技巧,并避免常见的设计错误。

weixin_30314793的博客 378

java 协变 逆变_JAVA中的协变与逆变

JAVA中的协变与逆变首先说一下关于Java中协变,逆变与不变的概念比较官方的说法是逆变与协变描述的是类型转换后的继承关系。定义A,B两个类型,A是由B派生出来的子类(A<=B),f()表示类型转换如new List();协变: 当A<=B时,f(A)<=f(B)成立逆变: 当A<=B时,f(B)<=f(A)成立不变: 当A<=B时,上面两个式子都不成立这么说可...

weixin_42138408的博客 287

HPE磁盘阵列管理04——MSA事件

本文介绍了HPE MSA存储系统的事件处理机制,重点分析了常见磁盘故障事件及其解决方案。文章首先定义了MSA事件的五个严重级别(严重、错误、警告、信息和解决),然后详细列举了多个典型事件案例(如事件1、3、6、8、172等),包括每种事件的触发条件、对系统的影响以及具体修复步骤。针对磁盘故障场景,文章提供了更换磁盘、重建磁盘组、取消隔离等操作建议,并强调应及时配置备用磁盘以降低数据风险。最后指出更详细的事件说明可参考《MSA事件描述参考指南》,并提供了HPE官方手册下载链接。全文为技术人员处理MSA存储故障

istrangeboy&begin zero的博客 1124

java中的协变与逆变

转自:http://blog.youkuaiyun.com/z69183787/article/details/51598345 看下面一段代码 Number num = new Integer(1); ArrayList list = new ArrayList(); //type mismatch Listextends Number> list = new ArrayList(); l

zjyzz13的博客 234

STM32嵌入式开发实战:如何用miniLZO压缩算法节省70%存储空间(附完整工程)

本文详细介绍了如何在STM32嵌入式开发中使用miniLZO无损压缩算法实现高达70%的存储空间节省。通过对比分析不同轻量级算法,重点讲解miniLZO的内存优化配置、分块压缩策略和完整工程实现,帮助开发者有效解决嵌入式系统中的存储瓶颈问题。

ss78901的博客 882

机器视觉最全面试题总结

空洞卷积(Atrous Convolution)也叫做膨胀卷积、扩张卷积,最初的提出是为了解决图像分割在用下采样(池化、卷积)增加感受野时带来的特征图缩小,后再上采样回去时造成的精度上的损失。空洞卷积通过引入了一个扩张率的超参数,该参数定义了卷积核处理数据时各值的间距。可以在增加感受野的同时保持特征图的尺寸不变,从而代替下采样和上采样a. 是普通的卷积过程(dilation rate = 1),卷积后的感受野为3b. 是dilation rate = 2的空洞卷积,卷积后的感受野为5。

@bangbang的博客 9217

协变逆变java_Java中的逆变与协变

什么是逆变与协变协变(Covariance)如果B是A的子类,并且F(B)也是F(A)的子类,那么F即为协变逆变(Contravariance)如果B是A的子类,并且F(B)成了F(A)的父类,那么F即为逆变Java中的逆变与协变Java中的泛型有逆变和协变两种操作,定义如下:协变 extends A>B是A的子类,那么List< B >是List extends A>的子...

weixin_39732866的博客 214

具身智能的建模和方法(具身智能入门一)

本文以机械臂将小红方块移动到目标位置为例对具身智能的建模和方法进行介绍,如下图所示,该例子来自https://ai-workshops.github.io/building-and-working-in-environments-for-embodied-ai-cvpr-2022/。

weixin_39699362的博客 1466

【软件构造】--Java中的协变与逆变

JAVA

qq_53094471的博客 999

高云FPGA系列教程(7):ARM GPIO外部中断

高云GN1NSR-4C共有16个GPIO,每个GPIO可配置成输入或输出模式,支持中断输入,触发方式可选择:上升沿、下降沿、高电平、低电平触发。中断优先级可通过NVIC进行设置,支持 0-7 级可编程中断优先级。

whik1194的博客 1376

通过Python实现物联网金橙子自动打标

对于自家公司使用金橙子打标卡时,为了与生产线或者PLC联动等,往往需要对金橙子打标卡进行二次开发,而在二次开发中不得不涉及到MarkEzd.dll这个文件,而这个dll文件网上版本多不说,一般都没法直接使用,最后还不得不花大价钱购买专用库。而本文针对这个问题,涉法通过python来绕过MarkEzd.dll文件,直接进行自动化控制EzCad来实现联动,可应用于实际生产。文章最后拓展一下以物联网的形式,实现手机平台等登录网页,输入想要的印字内容后,远程打印的案例。

lylelo的博客 3366

java中的逆变与协变

转:https://blog.youkuaiyun.com/z69183787/article/details/51598345 看下面一段代码 Number num = new Integer(1); ArrayList<Number> list = new ArrayList<Integer>(); //type mismatch List<? extends ...

hou_shiyu的博客 286

霍尼韦尔SoftMaster使用说明

霍尼韦尔SoftMaster使用说明

Java语言中的协变和逆变

协变和逆变指的是宽类型和窄类型在某种情况下的替换或交换的特性。 协变就是用一个窄类型替代宽类型 逆变则用宽类型覆盖窄类型。

MyBlog 3094

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料,已经经过了本人的筛选和整理,希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助!

Java泛型中的协变和逆变(哈工大软件构造)

  在软件构造课程的进行中,讲到复用性和LSP原则的时候,提到了一些协变和逆变的概念,以及在特定的数据结构,如 数组 、Collections 、 泛型 中的协变和逆变情况。但在课堂上并没有完全理解,通过在课后查询资料,有一点收获,在此分享。 协变和逆变?   简而言之,协变和逆变是用来描述类型转换前后的继承关系的两个概念。以A 、B表示类型,f(⋅)表示类型转换(f(A)表示A转换后的类型),≤表示继承关系(比如,A≤B表示A是由B派生出来的子类),其定义可概括如下: f(⋅)是协变(covariant)

Hey_BlingBling的博客 440

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

Java中的协变与逆变

  Java作为面向对象的典型语言,相比于C++而言,对类的继承和派生有着更简洁的设计(比如单根继承)。   在继承派生的过程中,是符合Liskov替换原则(LSP)的。LSP总结起来,就一句话:     所有引用基类(父类)的地方必须能够透明地使用其子类的对象。   LSP包含四层含义:     ① 子类完全拥有父类的方法,且具体子类必须实现父类的抽象方法;     ② 子类...

263

协变逆变java_Java中的协变与逆变

Java作为面向对象的典型语言,相比于C++而言,对类的继承和派生有着更简洁的设计(比如单根继承)。在继承派生的过程中,是符合Liskov替换原则(LSP)的。LSP总结起来,就一句话:所有引用基类(父类)的地方必须能够透明地使用其子类的对象。LSP包含四层含义:① 子类完全拥有父类的方法,且具体子类必须实现父类的抽象方法;② 子类中可以增加自己的方法;③ 当子类覆盖或实现父类的方法时,方法的形参...

weixin_35965051的博客 357

Java泛型中的协变和逆变

Java泛型中的协变和逆变 一般我们看Java泛型好像是不支持协变或逆变的,比如前面提到的List<Object>和List<String>之间是不可变的。但当我们在Java泛型中引入通配符这个概念的时候,Java 其实是支持协变和逆变的。 看下面几行代码: // 不可变 List<Fruit>fruits=newArrayLi...

diaoju3333的博客 89

【千行代码,bug无处藏】Java中的逆变与协变

看下面一段代码 Number num = new Integer(1); ArrayList<Number> list = new ArrayList<Integer>(); //type mismatch List<? extends Number> list = new ArrayList<Number>(); list.add(new Integer(1)); //error list.add(new Float(1.2f)); //error

马小果v:ma-xiaoguo的博客 192
上一篇: Netty中 ? extends Future<? super V>这种的写法的理解
下一篇: Netty中trySuccess和setSuccess的区别
Jooou
博客等级 码龄9年 226粉丝 58原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值