在 Java 中可以接受地规避缺乏多重继承的方法

Question

我正在制作游戏。我有一个实体类，它是一对 x,y 坐标和宽度和高度。

我想将此实体类子类化为许多新类，以添加功能组的组合。我想添加几个“组”功能：

Moveable {
    public float getVelocityX();
    public void setVelocityX(float velocityX);
    public float getVelocityY();
    public void setVelocityY(float velocityY);
    public void moveRelative(float dx, float dy);
    public void setPosX(float posX);
}

和

Rotatable {
    public void setAngularVelocity(float degreesPerSecond);
    public void setAbsoluteAngle(float angle);
}

和

Resizable {
    void setAbsoluteSize(int width, int height);
    void setRelativeSize(int widthGrowFactor, int heightGrowFactor);

    public void setWidth(float width);
    public void setHeight(float height);
}

...以及更多（可更新、可绘制、可碰撞）。

一些实体可以旋转/被绘制但不能移动/碰撞/更新/调整大小：“静态”不可触摸的东西，例如背景动画（云、太阳、星星）。

一些实体可以移动/旋转/被绘制/更新/碰撞/调整大小：玩家角色和怪物。

某些实体只能被绘制：游戏的 HUD。

一些实体可以移动/被绘制/更新/碰撞，但不能旋转/调整大小：例如枪声。

如您所见，我需要上述功能的组合，并且可以通过一些多重继承轻松解决。

为什么不用你问的接口来做呢？因为那会让我为所有方法复制/粘贴大量代码，并且创建新类型的实体类将永远引入复制/粘贴。

您可能会问，为什么我不只是创建一个可以完成所有工作的子类，然后覆盖不应与空方法一起使用的方法，或者在那些无效的方法中抛出 UnsupportedOperationException？即使每个方法中只有一行，这仍然是复制/粘贴。一个只能 move() 的实体可能会以 50 个方法结束，并带有“throw new UnsupportedOperationException();”。这是不可接受的。

如果你建议适配器模式，我希望你能发布一个适配器模式如何做类似事情的示例（我已经对此进行了辩论）。

如果您建议作文，请说明我将如何访问受保护的字段。

谢谢！

Answer 1

正如罗曼在评论中所说：

Java 确实允许interfaces 的多重继承。如果您只需要继承 is-a 关系和一组有保证的方法来与对象通信，那么这非常有效。

只能继承一个class（抽象与否）（以及需要的许多接口）。这是为了避免“钻石继承”的复杂性——网络搜索该短语以了解更多信息。如果您确实需要重用来自多个来源的逻辑，通常的解决方法是在实用程序类中定义其他共享行为，并让您的类委托给该实例。是的，这是一个 has-a 而不是 is-a 关系，但是由于 is-a 可以抽象为一个接口，您可以获得组合行为的所需最终外观。 （与菱形继承不同，这迫使您明确决定要调用哪个实现。）

Answer 2

根据合同，您必须实现接口中定义的方法。但是，您可以在这些方法中做任何您喜欢的事情。在这个简单的示例中，为每个实例创建了Moveable 和Rotatable 的进一步实现类。对相应操作的请求被转发到实现。

通过这种方式，您可以与多个对象共享相同的实现。操作本身甚至能够管理其状态而不是委托类。

public SomeClass implements Moveable, Rotatable
{
    // the implementation provide a concrete implementation
    // you can even exchange the implementation with new ones
    private Moveable movaAction = new MoveImpl();
    private Rotatable rotateAction = new RotateImpl();

    public float getVelocityX()
    {
        return moveAction.getVelocityX();
    }

    public void setVelocityX(float velocityX)
    {
        moveAction.getVelocityX(velocityX);
    }

    ...

    public void setAngularVelocity(float degreesPerSecond)
    {
        rotateAction.setAngularVelocity(degreesPerSecond);
    }
    ...
}

如果您进一步定义 f.e. registerNewMove(Moveable action) 如果需要，您甚至可以在运行时交换具体的实现（策略模式）。

Answer 3

如果所有子类的代码都相同，那么它可能在超类中。你可以这样做：

public final move() {
    if (!isMovable()) {
        throw new UnsupportedOperationException("This entity can't be moved");
    }
    // TODO implement the actual move
}

public abstract boolean isMovable();

如果你想有接口来判断一个实体是否可移动，你甚至可以在超类中实现 isMovable() 方法：

public final boolean isMovable() {
    return this instanceof Movable;
}

Answer 4

也许从完全不同的角度看待您的问题会很有用。您是否考虑过，不是将功能构建到对象的层次结构中，而是将功能构建到对象的初始化中。

尝试这样的开始：

static class Thing {
    int x;
    int y;
    float w;
    float h;
    float angle;

}

enum Op {
    Translate{
        @Override
        void op (Thing it, Thing op) {
            it.x += op.x;
            it.y += op.y;
        }
    },
    Rotate{
        @Override
        void op (Thing it, Thing op) {
            it.angle += op.angle;
        }
    },
    Scale{
        @Override
        void op (Thing it, Thing op) {
            it.w *= op.w;
            it.h *= op.h;
        }
    };

    abstract void op(Thing it, Thing op);
}

现在你有了一个可以操作的基类Thing。构建合法操作现在变成了数据处理问题，而不是层次结构问题。