java - Java中无法多重继承的解决方法

Question

我知道你不能在 Java 中扩展多个类。因此，我需要帮助解决这个问题。

我有这些类(class):

abstract class ObjWithID {
    final int id;

    public ObjWithID(int id) {
        this.id = id;
    }
}

abstract class ObjWithIDActivity extends ObjWithID {

    public ObjWithIDActivity(int id) {
        super(id);
    }

    boolean active;

    public boolean isActive() {
        return active;
    }

    public void setActive(boolean active) {
        this.active = active;
    }
}

abstract class ObjWithIDPriority extends ObjWithID {

    public ObjWithIDPriority(int id) {
        super(id);
    }

    int priority;

    public void setPriority(int priority) {
        this.priority = priority;
    }

    public int getPriority() {
        return priority;
    }
}

我的一些类(class)(大多数)都需要 activity和priority 。因此，在完美的世界中，我会这样写:

class Employee extends ObjWithIDPriority, ObjWithIDActivity implements Comparable<Header> {

    public Employee(int id) {
        super(id);
    }

    @Override
    public int compareTo(Header o) {
        return Integer.compare(o.priority, priority);
    }
}

当然，您不能扩展多个类。

在我当前的代码中，我只是创建了第三个类:

abstract class ObjWithIDActivityPriority extends ObjWithID {

    public ObjWithIDActivityPriority(int id) {
        super(id);
    }

    boolean active;

    public boolean isActive() {
        return active;
    }

    public void setActive(boolean active) {
        this.active = active;
    }

    int priority;

    public void setPriority(int priority) {
        this.priority = priority;
    }

    public int getPriority() {
        return priority;
    }
}

但是，这导致我必须编写更多代码，因为如果我创建一个接受 ObjectWithIDActivity 的方法，我就必须编写更多代码。作为参数，我需要将其复制为 ObjWithIDActivityPriority s。

我尝试过使用 interface 的多重继承解决方法s，但这会导致问题，因为我正在使用字段 int id , int priority ，和boolean active以及这些字段的 getter/setter。另外，接口(interface)不能有构造函数。

那么，实现这一点的最佳方法是什么？第三类是唯一的选择吗？

Answer 1

我对构图的看法:

public interface IDItf {
    abstract int getId();
    abstract void setId(int id);
}
class IDSupport implements IDItf {
    int id;

    public IDSupport(int id) {
        super();
        this.id = id;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }
}
public interface PriorityItf {
    abstract int getPriority();
    abstract void setPriority(int priority);
}

... (PrioritySupport class)

public interface ActivityItf {
    abstract boolean isActive();
    abstract void setActive(boolean active);
}

... (ActivitySupport class)

class Employee implements IDItf, PriorityItf, ActivityItf, Comparable<Header> {
    private IDSupport idSupport;
    private PrioritySupport prioritySupport;
    private ActivitySupport activitySupport;

    public Employee(int id) {
        super();
        idSupport = new IDSupport(id);
        prioritySupport = new PrioritySupport(0);
        activitySupport = new ActivitySupport(false);
    }

    @Override
    public int compareTo(Header o) {
        return Integer.compare(o.prioritySupport.getPriority(), prioritySupport.getPriority());
    }

    // Delegate methods (create them with Eclipse or other IDE's features)
    public int getId() {
        return idSupport.getId();
    }
    public void setId(int id) {
        idSupport.setId(id);
    }
    ...
}

...支持类相当简单，但如果它们需要更多的逻辑，它们就更有意义。 Employee 类中的字段可以使用 final 关键字。

我发现这篇作文过去很有帮助。拥有样板代码一开始感觉不太好。但是，委托(delegate)方法可以由 IDE 生成。支持类也可以大部分生成(创建字段，让 IDE 创建构造函数和 getter/setter)。缺点可能是生成的代码大幅减少，但仍需要维护。然而，从长远来看，我更喜欢更简单的代码，即使读起来很无聊。在过去的 25 年里，我不止一次地查看我不久前的代码，想知道我在想什么。有时，如果没有记录当时显而易见但现在却并非如此的关键提示，即使是注释也无济于事。