问OOP:从不可变对象继承
EN

Stack Overflow用户

提问于 2021-05-02 01:52:23

回答 1查看 110关注 0票数 1

背景

假设我有一组相互关联的字段，因此我创建了一个类来收集它们。让我们把这个类称为Base。还有一些方法，这些方法在所有派生类中都是通用的。另外，让我们假设我们希望Base及其所有派生类是不可变的。

在不同的上下文中，这些字段支持额外的操作，因此我有不同的派生类，它们继承字段并根据它们的上下文提供额外的方法。让我们把这些叫做Derived1，Derived2等等。

在某些情况下，程序需要派生类的实例，但是字段的状态必须满足某些条件。因此，我做了一个类RestrictedDerived1，在调用它的基本构造函数之前，它确保在构造函数中满足条件(或者更改参数以符合它的要求)，或者抛出一个错误。

此外，在某些情况下，我甚至需要满足更多的条件，所以我有了SuperRestrictedDerived1。(附带注意:如果满足了某些条件，这个类可以更有效地计算某些事情，因此它覆盖了Derived1的一些方法。)

问题

到目前一切尚好。问题是，所有这些类的大多数方法都涉及在这个层次结构中创建一个类的另一个实例(不总是与调用方法的实例相同，但通常是相同的实例)，而是进行了一些修改，这些修改可能涉及到一些复杂的计算(即不只是改变一个字段)。例如，Derived1的一种方法可能如下所示：

public Derived1 foo(Base b) {
    TypeA fieldA = // calculations using this and b
    TypeB fieldB = // more calculations
    // ... calculate all fields in this way
    return new Derived1(fieldA, fieldB, /* ... */);
}

但是，层次结构RestrictedDerived1需要这个相同的函数来返回自身的一个实例(如果不能实例化它显然会抛出一个错误)，所以我需要像这样覆盖它：

@Override
public ResrictedDerived1 foo(Base b) {
    return new RestrictedDerived1(super.foo(b));
}

这需要一个副本构造函数，并不必要地分配一个将立即销毁的中间对象。

可能解决办法

我想到的另一种解决方案是将一个函数传递给这些方法中的每一个，这些方法构造了某种类型的Base，然后函数看起来如下所示：

// In Derived1
public Derived1 foo(Base b, BaseCreator creator) {
    TypeA fieldA = // calculations using this and b
    TypeB fieldB = // more calculations
    // ... calculate all fields in this way
    return creator.create(fieldA, fieldB, /* ... */);
}

public Derived1 foo(Base b) {
    return foo(b, Derived1::create);
}

public static Derived1 create(TypeA fieldA, TypeB fieldB, /* ... */) {
    return new Derived1(fieldA, fieldB, /* ... */);
}

// In RestrictedDerived1
@Override
public ResrictedDerived1 foo(Base b) {
    return (RestrictedDerived1) foo(b, RestrictedDerived1::create);
}

public static RestrictedDerived1 create(TypeA fieldA, TypeB fieldB, /* ... */) {
    return new RestrictedDerived1(fieldA, fieldB, /* ... */);
}

我的问题

这是可行的，但我觉得“笨重”。我的问题是，是否有一些设计模式或概念，或替代设计，以方便我的情况？

我试过使用泛型，但很快就变得凌乱不堪，而且不能很好地应用于不止一个级别的继承。

顺便说一下，它们所引用的实际类是3D点和向量。我有一个名为Triple的基，它包含x、y和z(以及一些函数，这些函数接受lambda并将它们应用于每个坐标，并构造一个新的三元组并得到结果)。然后，我有一个带点相关函数的派生类Point，还有一个带有函数的派生类Vector。然后我有了NonZeroVector (扩展Vector)，它不是零向量(因为需要向量的其他对象有时需要保证它不是零向量，而且我不想到处检查)。此外，我还有NormalizedVector (扩展NonZeroVector)，它保证长度为1，并在构建时将自己规范化。

immutability

oop

inheritance

腾讯云官网建站

SaaS建站+私有服务器，拖拉式完成多端建站，5分钟搭建企业官网

回答 1

Stack Overflow用户

回答已采纳

发布于 2021-05-02 11:10:11

MyType

可以使用MyType、this类型或self类型的概念来解决这一问题。基本思想是MyType是运行时派生最多的类型。您可以将它看作是this的动态类型，但是静态地(在“编译时”)引用。

不幸的是，并不是很多主流编程语言都有MyTypes，但例如TypeScript有，而且我被告知拉库也有。

在TypeScript中，您可以通过将foo的返回类型设置为MyType (在TypeScript中拼写为this )来解决问题。看起来会是这样的：

class Base {
    constructor(public readonly fieldA: number, public readonly fieldB: string) {}

    foo(b: Base): this {
        return new this.constructor(this.fieldA + b.fieldA, this.fieldB + b.fieldB);
    }
}

class Derived1 extends Base {
    constructor(fieldA: number, fieldB: string, protected readonly repeat: number) {
        super(fieldA * repeat, fieldB.repeat(repeat));
    }

    override foo(b: Base): this {
        return new this.constructor(
            this.fieldA + b.fieldA, this.fieldB + b.fieldB, this.repeat
        );
    }
}

class RestrictedDerived1 extends Derived1 {
    constructor(fieldA: number, fieldB: string, repeat: number) {
        super(fieldA * repeat, fieldB.repeat(repeat), repeat);
        if (repeat >= 3) { 
            throw new RangeError(`repeat must be less than 3 but is ${repeat}`)
        }
    }
}

const a = new RestrictedDerived1(23, 'Hello', 2);
const b = new Base(42, ' World');

const restrictedDerived = a.foo(b); // Inferred type is RestrictedDerived1

微b0rken游乐场链接

隐工厂

在具有类型类或隐式(如Scala)的语言中，您可以使用隐式Factory对象解决问题。这类似于您对创建者的第二个示例，但不需要在任何地方显式地传递创建者。相反，语言会含蓄地召唤他们。

实际上，您的需求非常类似于Scala集合框架的核心需求之一，即您希望像map、filter和reduce这样的操作只实现一次，但仍然保留集合的类型。

大多数其他集合框架只能实现其中的一个目标:例如，Java、C#和Ruby，每个操作只有一个实现，但它们总是返回相同的、最通用的类型(Stream在Java中，IEnumerable在C#中，Array在Ruby中)。Smalltalk的集合框架保留了类型，但对每个操作都有重复的实现。一个非复制的、类型保持的集合框架是抽象设计人员/语言设计人员的圣杯之一。(这么多介绍面向对象的新方法的论文使用Smalltalk的重构作为它们的工作示例，这绝非巧合。)

F-有界多态性

如果没有可用的MyType或隐式构建器，则可以使用F-有界多态性。

典型的例子是如何设计Java的clone方法：

interface Cloneable<T extends Cloneable<T>> {
    public T clone();
}

class Foo implements Cloneable<Foo> {
    @Override
    public Foo clone() {
        return new Foo();
    }
}