Question

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

我有这些课程：

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;
    }
}

我的一些课程（大部分课程）都需要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复制它。< / p>

我已经尝试了使用interface的多重继承解决方法，但这会导致问题，因为我使用的是字段int id，int priority和boolean active，这些领域的getter / setter。此外，接口不能有构造函数。

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

Answer 1

不是一个可行的答案，因为提问者说他不能使用Java 8，但我想我会发布这个因为它很有趣。这是令人憎恶的，但乍一看似乎绕过了Java的多重继承限制。有什么意见吗？

public interface ObjWithID {
    public static final Map<ObjWithID, Integer> idMap = new HashMap<>();
    default public int getId() {
        return idMap.get(this);
    }
}


public interface ObjWithIDActivity extends ObjWithID {
    public static final Map<ObjWithIDActivity, Boolean> activeMap = new HashMap<>();
    default public boolean isActive() {
        return activeMap.get(this);
    }
    default public void setActive(boolean active) {
        activeMap.put(this, active);
    }
}


public interface ObjWithIDPriority extends ObjWithID {
    public static final Map<ObjWithIDPriority, Integer> priorityMap = new HashMap<>();
    default public int getPriority() {
        return priorityMap.get(this);
    }
    default public void setPriority(int priority) {
        priorityMap.put(this, priority);
    }
}


public class NewClass implements ObjWithIDActivity, ObjWithIDPriority {
    public void foo() {
        int id = getId();
        int priority = getPriority();
        boolean active = isActive();
    }
}

钻石图案祝你好运！

Answer 2

我对作文的看法：

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关键字。

我发现这个作品在过去很有用。拥有样板代码最初并不好。但是，委托方法可以由IDE生成。也可以生成支持类（创建字段，让IDE创建构造函数和getter / setter）。缺点可能是仍然需要维护的生成代码的大幅下滑。但是，从长远来看，我更喜欢更简单的代码，即使阅读起来也很无聊。在过去的25年里，我不止一次看过我的代码，并想知道我在想什么。有时甚至如果一个人没有记录当时显而易见的重要提示，即使现在还没有，那么即使是评论也无济于事。

Answer 3

Java方法是使用接口Activable和Priorisable，并将实现包括状态放在所有实现类中。

此处的可比较应由Priorisable继承。

如果你真的想要分解状态声明（但是没有必要），你可以隐藏你的模型classe隐藏在某个接口（Employee实现的EmployeeImpl）后面并使模型实现类扩展modelBase POJO暴露所有可能的属性（活动，优先级......）。通过接口操作模型类时，只会暴露可用的方法。

无法在Java中进行多重继承的解决方法

3 个答案: