0

我有一个简单的问题（使用 Java）。我有两个类，一个代表 Document，第二个代表 Word。

Document 类需要了解有关 Word 中保存的单词的一些信息。我的问题是，解耦这两个类的最佳方法是什么？我有两个选择：

  1. 类之间没有联系，每次我在 Document 中调用一个方法时，我都会将一个 Word 对象传递给它（所以我有一个带有 main 方法的第三个类，它同时启动 Document 和 Word）。

  2. 在 Document 中声明一个 Word 的私有对象。

需要注意的一点是，我只有一个用于 Word 的对象和一个用于 Document 的对象。我不会为每个新文档或单词创建一个新对象。我将整个文档的列表存储在 Document 中，并将整个单词的列表存储在 Word 中。

谢谢！

4

6 回答 6

4

我不同意你对 Decoupling 的理解。解耦不仅与哪些对象创建其他对象有关，还与哪些对象了解其他对象的行为以及（至关重要）在 Word 更改时（您的示例）文档中需要更改的内容有关。

但是，我也真的不明白这两个短语是什么意思：

我只有一个用于 Word 的对象和一个用于 Document 的对象。我不会为每个新文档或单词创建一个新对象。我将整个文档的列表存储在 Document 中，并将整个单词的列表存储在 Word 中

从文档开始。这个类的对象可以做什么？你好像在说

class Document {

     private List<??OfWhat??> allDocuments;
}

如果类 Document 包含一个列表，它是什么列表？我认为你需要：

class Shelf {
      private List<Document> allDocuments;
}

class Document{
      private List<Word> wordInOneDocument;
}

class Word {
      private String wordContents;
}

现在 Shelf 可以提供诸如 getRecentDocumets() findDocumentsContaining(String text) 和 Document 可以包含 getWordCount() 和 insertParagraph(List, START) 等方法；等等。

为了进行更好的讨论，我们需要更多地了解您的想法，更多地了解行为。

我同意你的一般想法，即除了 Document 和 Word 之外还有其他东西。可以合理调用 createDocument() 和 insertParagraph() 等方法的东西

于 2010-08-17T20:14:05.773 回答
1

From my point of view...

public class Document{

  private List<Word> words = new ArrayList<Word>();

  public void setWord(ArrayList<Word> words){this.words = words;}
  public ArrayList<Word> getWord(return this.words;)
}

It's a reasonable approach. In this example you can create a Document without any Word's, which makes for an empty Document, which is valid.

You could still create a third class as you suggest, however, I don't see the benefit with it.

于 2010-08-17T19:52:27.420 回答
0

你的问题是

解耦这两个类的最佳方法是什么？我有两个选择：

这两个选项都不能满足您的要求。如果它们要一起工作，那么它们将被耦合。唯一的问题是耦合的松紧程度。

您的两个选项听起来都像紧耦合。一种更松散的耦合形式是存储interface引用并将其接收到构造函数或 setter 方法中。

于 2010-08-17T20:04:43.067 回答
0

如果要解耦类，一种标准方法是使用接口：

public interface IWord {
...
}

public class Word implements IWord {
...
}

public class Document {
    public boolean append(IWord word) { ... }

    ...
}

这样，Class 和 Word 都依赖于 IWord，但 class 和 Word 都不依赖于另一个。这称为依赖倒置。

于 2010-08-17T20:07:44.450 回答
0

首先，我认为您错误地命名了您的课程。

我不会为每个新文档或单词创建一个新对象。我将整个文档的列表存储在 Document 中，并将整个单词的列表存储在 Word 中。

从你在这里所说的来看，你有这样的事情：

public class Words {
    private List<Word> = new ArrayList<Word>;
    // getters+setters
}

public class Documents {
    private List<Document> = new ArrayList<Document>;
    // getters+setters
}

并且您想在 Documents 中使用 Words 类。如果你想这样做，那意味着你不能将它解耦（因为它违反了“解耦”这个词的定义）。我在这里再次猜测，但我认为您想对其进行编码，以便您可以更改 Documents 类的实现，以便将来它可以使用另一个类，例如 BetterWords。

为此，我将创建一个抽象类或接口（取决于您的体系结构的其余部分），然后让 Words 类扩展它或实现它。然后你可以做这样的事情：

public class Documents {
    private List<Document> = new ArrayList<Document>;

    private IWords wordsInterface = new Words(); //in case you want to make an interface
    private AbstractWords wordsAbstract = new Words(); //in case you want to make an abstract class

    // getters+setters
}

或者你可以把它放在 Document 类（单词）中，真的不知道你想要它们在哪里。

于 2010-08-17T20:12:41.727 回答
0

你的问题应该通过组合来解决。因此，拥有 List ofWord似乎是一种有效的方法。通过分离出 Documents 和 Words，您已经实现了所需的解耦。我不明白你解耦 Document 和 Word 对象的确切观点。

于 2010-08-17T19:59:39.097 回答