Java中的多重继承设计问题

Question

你如何处理java中只有单一继承的情况？这是我的具体问题：

我有三个（简化的）类：

public abstract class AbstractWord{
    String kind;    // eg noun, verb, etc

    public String getKind(){ return kind; }

}

public class Word extends AbstractWord{
    public final String word;

    ctor...

    public void setKind(){
        // based on the variable word calculate kind..
    }
}

public class WordDescriptor extends AbstractWord{

    ctor..

    public void setKind(String kind){this.kind = kind;}

}

这是我认为最基本的实现，但我想进行其他实现。

假设我想添加一个新变量，例如 wordLength，但我想使用继承来添加它。这意味着我不想修改原始的 AbstractWord 类。即：

public class Length{
    private int length;

    public int getLength(){return length};
}

public class BetterWord extends AbstractWord AND Length{

    public void setLength(){
        // based on the variable word calculate Length..
    }
}

public class BetterWordDescriptor extends AbstractWord AND length{

    public void setLength(int length){this.length = length;}
}

我知道 java 不允许我这样做，但它使我的代码非常丑陋。现在，每当我添加一个字段时，我只是将其添加到 AbstractWord，但随后我需要重命名该 AbstractWord（以及 Word 和 WordDescriptor）。 （由于向后兼容性，我不能只将该字段添加到另一个字段，它会破坏 equals 方法和类似的内容）。

这似乎是一个非常常见的设计问题，但我绞尽脑汁却无法想出任何漂亮的解决方案。

有没有一种设计模式可以解决这个问题？我有一些潜在的解决方案，但我想看看是否有我遗漏的东西。

谢谢， 杰克

更新：长度是指单词中的音节数（抱歉不清楚）

Answer 1

优先考虑组合而不是继承。

解决方案考虑到可能存在另一种类型的单词可能需要 WordLengthSupport。

类似地，可以创建和实现其他接口，并且各种单词类型可以混合和匹配这些接口。

。

public class WordLength {
    private int length = 0;
    public int getLength(){return length};
    public void setLength(int length){this.length = length};
}

。

public interface WordLengthSupport {
    public WordLength getWordLength();
}

。

public class BetterWord extends AbstractWord 
        implements WordLengthSupport {
    WordLength wordLength;
    public WordLength getWordLength() {
        if(wordLength==null) {
            // each time word changes 
            // make sure to set wordLength to null
            calculateWordLength(); 
        }
        return wordLength;
    }
    private void calculateWordLength() {
        // This method should be 
        //    called in constructor 
        //    or each time word changes 
        int length = // based on the variable word calculate Length..
        this.wordLength = new WordLength();
        this.wordLength.setLength(length);
    }
}

。

public class BetterWordDescriptor extends AbstractWord  
        implements WordLengthSupport {
    WordLength wordLength;
    public WordLength getWordLength(return wordLength);
    public void setWordLength(WordLength wordLength) {
        // Use this to populate WordLength of respective word
        this.wordLength = wordLength;
    }
}

。

策略模式定义了一系列算法，封装了每个算法，并使它们可以互换。策略使算法能够独立于使用它的客户端而变化。

该解决方案不使用策略模式，但可以对其进行重构。

Answer 2

只需使用组合而不是继承：

has-a Length<的 BetterWord is-an AbstractWord /code>:

public class BetterWord extends AbstractWord {

    private Length length;

    public void setLength(int value){
        length.setLength(value);
    }
}

编辑

如果 API 需要 Length 类型的对象，只需添加一个 getter：

public class BetterWord extends AbstractWord {

    private Length length;

    public void setLength(int value){
        length.setLength(value);
    }

    public Length getLength() {
        return length
    }
}

或者将实现 Length 重命名为 LengthImpl 并定义接口Length，因为一个类可以实现多个接口。

Answer 3

根据您的具体示例，您可以将 装饰器 模式与接口结合使用来补充您的 具有附加功能的Word类；例如，

// *Optional* interface, useful if we wish to reference Words along with
// other classes that support the concept of "length".
public interface Length {
  int getLength();
}

// Decorator class that wraps another Word and provides additional
// functionality.  Could add any additional fields here too.
public class WordExt extends AbstractWord implements Length {
  private final Word word;

  public class(Word word) {
    this.word = word;
  }

  public int getLength() {
    return word.getKind().length();
  }
}

此外值得注意的是，Java 中缺乏多重继承并不是这里真正的问题；这更多的是重新设计你的设计。一般来说，过度使用继承被认为是不好的做法，因为深层继承层次结构难以解释/维护。

Answer 4

看了之后，我的第一感觉就是你的模型有点复杂。

单词有一个 String 来描述存储在 Word 对象中的单词本身，还有一个类来表示它是名词、动词、形容词等。Word 的另一个属性是存储在 Word 对象中的字符串的长度。

从“is-a”和“has-a”关系的角度来思考事物，您可以消除很多复杂性。

例如，为什么需要一个扩展 AbstractWord 的 WordDescriptor？一个词会从动词变成形容词吗？我本以为单词类型是在创建对象时设置的，并且在 Word 对象的生命周期内不会改变。一旦您有了单词“Australia”的 Word 对象，单词的种类在该对象的生命周期内就不会改变。

嗯。在用“动词”类型实例化对象来描述狗发出的声音后，也许您可​​能有一个代表“吠叫”一词的 Word 对象。然后您意识到您实际上需要 Word 对象来表示描述树的覆盖物的名词。有可能，但是狗皮和树皮都可以存在。

所以我认为您选择的模型有点太复杂，您的问题可以通过返回并简化原始对象模型来解决。

首先针对基本模型的每个继承方面问自己一个问题。

当我说 B 类扩展了 A 类时，我可以说 B 类“是”A 类并且我正在专门化它的行为吗？

例如，可以扩展基类 Animal 以提供特殊的袋鼠类。然后你可以说“the kangaroo “is-a” Animal。你正在专门化行为。

然后看看属性，袋鼠有一个 Location 属性来描述它的发现位置。然后你可以说 a Kangaroo “has-a” “位置。袋鼠的“is-a”位置没有意义。

同样，单词“has-a”长度。并且单词“is-a”长度的陈述没有意义。

顺便说一句，所有澳大利亚参考文献写这篇文章是为了庆祝今天的 1 月 26 日澳大利亚国庆日

！

Answer 5

（由于向后兼容性，我不能只将该字段添加到另一个字段，它会破坏 equals 方法和类似的内容）。

它不会破坏源兼容性。除非你在 equals 方法中做了一些非常疯狂的事情。

重命名类通常不是处理二进制兼容性的方法。

Answer 6

问题不在于“如何处理单一继承”。您缺少的并不是真正的设计模式，而是学习将 API 与实现分开设计。

我会像这样实现它：

public interface WordDescriptor {
    void getKind();
    Word getWord();
}

public interface Word {
    String getWord();
}

public class SimpleWord implements Word {
    private String word;

    public SimpleWord(String word) { this.word = word; }
    public String getWord() { return word; }
}

public class SimpleWordDescriptor implements WordDescriptor {
    private Word word;
    private String kind;

    public SimpleWordDescriptor(Word word, String kind) {
        this.word = word;
        this.kind = kind; // even better if WordDescriptor can figure it out internally
    }

    public Word getWord() { return word; }

    public String getKind() { return kind; }
}

通过这个基本设置，当您想引入长度属性时，您所要做的就是：

public interface LengthDescriptor {
    int getLength();
}

public class BetterWordDescriptor extends SimpleWordDescriptor
                                  implements LengthDescriptor {
    public BetterWordDescriptor(Word word, String kind) {
        super(word, kind);
    }

    public int getLength() { getWord().length(); }        
}

使用属性组合以及装饰器模式的其他答案也是您的完全有效的解决方案问题。您只需要确定您的对象是什么、它们的“可组合性”程度以及如何使用它们 - 因此首先设计 API。

Answer 7

/**
* 第一个例子
*/

class FieldsOfClassA {
    public int field1;
    public char field2;
}

interface IClassA {
    public FieldsOfClassA getFieldsA();
}

class CClassA implements IClassA {
    private FieldsOfClassA fields;

    @Override
    public FieldsOfClassA getFieldsA() {
        return fields;
    }
}

/**
 * seems ok for now
 * but let's inherit this sht
 */


class FieldsOfClassB {

    public int field3;
    public char field4;
}

interface IClassB extends IClassA {

    public FieldsOfClassA getFieldsA();
    public FieldsOfClassB getFieldsB();
}

class CClassB implements IClassB {

    private FieldsOfClassA fieldsA;
    private FieldsOfClassB fieldsB;

    @Override
    public FieldsOfClassA getFieldsA() {
        return fieldsA;
    }

    @Override
    public FieldsOfClassB getFieldsB() {
        return fieldsB;
    }
}

/**

• 哇这个怪物变大了

• 想象一下你需要4级继承

• 写这个地狱要花很多时间

• 我什至没有说那些 iface 的用户会认为

• 我需要哪些字段 fieldsA fieldsB fieldsC 或另一个字段

所以组合在这里不起作用
你的可悲尝试是没有用的，

当你考虑面向对象编程时，

你需要具有 6-7 级多重继承的大模型

，因为这是很好的测试，并且因为对应于现实生活的模型或经过文明 4 千年测试的数学模型。

如果您的模型需要 2 级继承，请停止假装您使用 OO

您可以使用任何语言轻松实现它，甚至是像 C 或 Basic 语言这样的过程语言
*/