Java 泛型不变性引发的类型转换问题及解决方案

这类报错常见于接口返回值、集合传参和服务层封装。关键点只有一个：Java 泛型默认不变，先判断读写语义，再决定用拷贝转换、通配符，还是直接调整 API 返回类型。

为什么 List<StudyPoint> 不能直接赋给 List<IAdjIniPoint>

即使 StudyPoint 实现了 IAdjIniPoint，List<StudyPoint> 和 List<IAdjIniPoint> 仍是两种不同类型，不能直接赋值：

List<IAdjIniPoint> list = new ArrayList<StudyPoint>(); // 编译错误！

如果允许这样做，就能向原本的 List<StudyPoint> 中放入其他 IAdjIniPoint 实现，破坏类型约束。Java 用不变性在编译期阻止这类问题。

Java 里的协变、逆变到底怎么用

1. 不变性

泛型参数不同，就不能互相替换；对象能向上转型，泛型容器不会自动跟着转。

2. 协变：? extends T

只读场景使用：

List<? extends IAdjIniPoint> readOnlyList = new ArrayList<StudyPoint>();
IAdjIniPoint item = readOnlyList.get(0);
// readOnlyList.add(new StudyPoint()); // 编译错误

可读不可写。

3. 逆变：? super T

只写场景使用：

List<? super StudyPoint> writeOnlyList = new ArrayList<IAdjIniPoint>();
writeOnlyList.add(new StudyPoint());
// IAdjIniPoint item = writeOnlyList.get(0); // 编译错误

可写入 StudyPoint，读取时不能按具体类型安全使用。

4. PECS

• Producer Extends：只读用 ? extends T
• Consumer Super：只写用 ? super T

遇到类型转换报错时，常见解决方案怎么选

最稳妥的做法：创建新列表

List<StudyPoint> studyPoints = service.getList();
List<IAdjIniPoint> interfaceList = new ArrayList<>(studyPoints);

这是复制元素到新集合，不是强转。

在 API 设计阶段，优先返回接口类型

public List<IAdjIniPoint> listPointByGroupId(Integer groupId) {
    List<StudyPoint> points = // 获取具体实现
    return new ArrayList<>(points);
}

只读查询时，再考虑通配符

如果只是遍历、读取、映射，用 List<? extends IAdjIniPoint> 更合适。

为什么不建议双重强制转换

(List<IAdjIniPoint>)(List<?>)list

它只是绕过编译器，风险推迟到运行时。

和 C# 相比，Java 为什么显得更“严格”

泛型协变/逆变支持差异

Java 默认不变，需要在使用点显式写通配符：

List<StudyPoint> studyPoints = new ArrayList<>();
List<? extends IAdjIniPoint> readOnlyList = studyPoints;
List<? super StudyPoint> writeOnlyList = new ArrayList<IAdjIniPoint>();

C# 可在接口和委托上声明协变/逆变：

interface IEnumerable<out T>
{
    T Current { get; }
}

IEnumerable<StudyPoint> studyPoints = new List<StudyPoint>();
IEnumerable<IAdjIniPoint> interfaceList = studyPoints;

两者都支持数组协变，但可能在运行时报错

StudyPoint[] studyPoints = new StudyPoint[10];
IAdjIniPoint[] interfaceArray = studyPoints;
interfaceArray[0] = new OtherImplementation(); // ArrayStoreException

StudyPoint[] studyPoints = new StudyPoint[10];
IAdjIniPoint[] interfaceArray = studyPoints;
interfaceArray[0] = new OtherImplementation(); // ArrayTypeMismatchException

方法重写与返回类型差异

public interface PointGroupService {
    List<IAdjIniPoint> listPointByGroupId(Integer groupId);
}

public class PointGroupServiceImpl implements PointGroupService {
    @Override
    public List<IAdjIniPoint> listPointByGroupId(Integer groupId) {
        return new ArrayList<>();
    }
}

public abstract class PointGroupService 
{
    public abstract List<IAdjIniPoint> ListPointByGroupId(int groupId);
}

public class PointGroupServiceImpl : PointGroupService 
{
    public override List<StudyPoint> ListPointByGroupId(int groupId)
    {
        return new List<StudyPoint>();
    }
}

回到实际业务：接口返回值该怎么写更省事

public List<IAdjIniPoint> listPointByGroupId(Integer groupId) {
    List<StudyPoint> studyPoints = // 获取具体实现
    List<IAdjIniPoint> result = new ArrayList<>();
    result.addAll(studyPoints);
    return result;
}

public IEnumerable<IAdjIniPoint> ListPointByGroupId(int groupId) 
{
    var studyPoints = // 获取具体实现
    return studyPoints;
}

Java 项目里，优先返回接口类型或更抽象的只读视图；需要读写分离时，明确区分 ? extends 和 ? super。

结论：先判断读写语义，再选泛型写法

• 需要真正可用的 List<IAdjIniPoint>：new ArrayList<>(studyPoints)
• 只读取数据：List<? extends IAdjIniPoint>
• 主要写入 StudyPoint：List<? super StudyPoint>
• 还在 API 设计阶段：优先把返回类型设计成接口类型

参考链接：https://link.juejin.cn?target=、https://link.juejin.cn?target=