OOP不可变对象多层继承的实例化冗余问题与优化方案咨询

核心设计逻辑 #

结合模板方法模式+受保护协变工厂的思路，彻底拆分纯坐标计算逻辑与带约束的实例化逻辑，从根源上消除中间临时对象，同时避免泛型耦合、构造器传参繁琐的问题。
整套逻辑不依赖复杂泛型，完全适配现有层级化的不可变类继承结构：Triple 基类 → Vector/Point 通用类 → NonZeroVector/NormalizedVector 带约束子类。

具体实现拆解 #

• 顶层基类 Triple 层
  • 所有坐标字段设为私有终态，保证全层级不可变属性不被破坏
  • 把所有纯几何计算（坐标相加、叉乘、缩放等）抽为受保护的静态纯函数：仅基于传入的双精度坐标值计算结果，全程不生成任何类实例，仅返回计算后的裸坐标数组，从源头避免计算过程中的对象分配。
  • 代码示例：

    public abstract class Triple {
        protected final double x;
        protected final double y;
        protected final double z;
    
        protected Triple(double x, double y, double z) {
            this.x = x;
            this.y = y;
            this.z = z;
        }
    
        // 纯静态计算，无实例化，仅返回数值结果
        protected static double[] calculateAdd(double ax, double ay, double az, double bx, double by, double bz) {
            return new double[]{ax + bx, ay + by, az + bz};
        }
    }
    

• 通用类层（如 Vector）
  • 所有公共几何方法（如 add、scale）固定统一流程：调用基类的静态纯计算函数拿到结果裸坐标，再调用本类的受保护工厂方法生成最终实例，不硬编码 new 具体类的实例。
  • 定义可覆写的受保护工厂方法，利用语言本身的协变返回类型特性，不需要递归泛型支持：

    public class Vector extends Triple {
        // 公共计算方法，流程固定
        public Vector add(Vector other) {
            double[] result = calculateAdd(this.x, this.y, this.z, other.x, other.y, other.z);
            // 调用可覆写的工厂生成实例，不硬编码new Vector
            return createInstance(result[0], result[1], result[2]);
        }
    
        // 受保护工厂方法，子类覆写时可以返回子类类型（协变合法）
        protected Vector createInstance(double x, double y, double z) {
            return new Vector(x, y, z);
        }
    
        // 私有构造，强制走工厂方法
        private Vector(double x, double y, double z) {
            super(x, y, z);
        }
    }
    

• 带约束子类层（如 NonZeroVector、NormalizedVector）
  • 不需要覆写任何从父类继承来的几何计算方法，只要覆写对应层级的工厂方法，在工厂方法中加入本层级的构造约束校验即可。多态机制会自动让父类的计算方法在运行时调用当前子类的工厂方法，直接生成符合本类约束的最终实例。
  • 代码示例：

    // 非零向量子类，仅需覆写工厂方法
    public class NonZeroVector extends Vector {
        @Override
        protected NonZeroVector createInstance(double x, double y, double z) {
            // 直接做非零约束校验，无中间对象
            if (Math.abs(x) < 1e-9 && Math.abs(y) < 1e-9 && Math.abs(z) < 1e-9) {
                throw new IllegalArgumentException("Vector cannot be zero");
            }
            return new NonZeroVector(x, y, z);
        }
    
        private NonZeroVector(double x, double y, double z) {
            super(x, y, z);
        }
    }
    
    // 单位向量子类，同样仅需覆写工厂方法
    public class NormalizedVector extends NonZeroVector {
        @Override
        protected NormalizedVector createInstance(double x, double y, double z) {
            double length = Math.sqrt(x*x + y*y + z*z);
            if (length < 1e-9) throw new IllegalArgumentException("Cannot normalize zero vector");
            // 直接生成归一化后的最终实例，无中间的Vector/NonZeroVector临时对象
            return new NormalizedVector(x/length, y/length, z/length);
        }
    
        private NormalizedVector(double x, double y, double z) {
            super(x, y, z);
        }
    }
    

方案对比原有痛点的适配性 #

• 消除临时对象冗余：全流程计算仅在最后一步生成符合当前层级约束的最终实例，中间没有任何父类实例的分配与销毁。对比旧实现中“先父类实例→再拷贝生成子类实例”的流程，可减少2/3的对象分配开销，尤其适合三维几何计算这种高频调用的场景。
• 避免构造器传参的繁琐写法：不需要在每个几何方法中传入构造器引用，多态机制会自动绑定当前实例类型对应的工厂逻辑，子类的所有继承方法会自动返回正确的子类类型。
• 规避泛型逻辑混乱：完全不需要依赖“递归自类型泛型”这类容易在多层继承中失控的语法，所有类型由语言原生的协变返回类型做静态校验，没有 unchecked 类型转换，层级扩展时不会出现泛型参数漏写、类型不匹配的问题。
• 适配子类的高效重写逻辑：如果某子类（如单位向量）想利用自身属性做计算优化，只需要直接覆写对应的几何方法即可，依然走工厂实例化的流程，不破坏整体结构。

针对提到的 Derived1 与 RestrictedDerived1 的场景：RestrictedDerived1 无需覆写 foo 方法，只要在自身的工厂方法中加入构造约束，父类 Derived1 的 foo 方法会自动通过多态调用 RestrictedDerived1 的工厂逻辑，直接生成符合约束的最终实例，彻底消除中间的 Derived1 临时对象。

内容的提问来源于stack exchange，提问作者Abraham Murciano Benzadon