分层对象设计（Java）

Question

我正在寻找一种优雅的设计来解决类似于以下的问题：

故事可以具有灵活的层次结构。它可能由多本书组成，每本书都有章节，每本书都有章节，每本书都包含文本。或者，它可能只是有几个部分（例如短篇小说）。或者它可能只包含有章节的章节。在所有情况下，都不允许您混合风格（因此您不能向基于书籍的故事添加章节，您必须将章节添加到书籍本身）。

我针对此类问题提出了一些设计解决方案，但它们变得混乱。是否有一种干净的方式来表示这一点，以便在参考 Story 类的情况下，我可以以清晰、系统的方式访问内容？

Answer 1

这是一种棘手的情况，因为像“书籍”、“章节”、“部分”这样的概念可能有一些共同的元素，这些元素表明类层次结构或公共接口实现。

同时时间，足够不同，可以作为不同的类/对象来处理，完全按照“所以你不能向基于书籍的故事添加章节”的要求。

在概念上处理分层对象时，有将它们转化为代码的几种方法，每种方法一个更适合特定的情况。

1.类组成

每个概念都有一个类或原型，它们可能通过继承或接口相关或不相关。
元素有内部集合，并且可以限制它们的操作，
通过方法。

// this one can be optional, not required,
// replaced by several parent classes,
// or replaced by interfaces

public class LibraryRootClassMaybe {
  // members here
}

public class BookText extends LibraryRootClassMaybe {
  // members here
} // class BookText

public class BookSection extends LibraryRootClassMaybe {
    // element collection should not be public
  List BookTexts;

  public Book() {
    this.BookTexts = new ArrayList();
  }

  public void addBookTest(BookText Item) {
    // validation and casting from object to BookText
  }

  // members here
} // class BookSection

public class BookChapter extends LibraryRootClassMaybe {
    // element collection should not be public
  List BookSections;

  public Book() {
    this.BookSections = new ArrayList();
  }

  public void addBookTest(BookSection Item) {
    // validation and casting from object to BookSection
  }

  // members here
} // class BookChapter

public class Book extends LibraryRootClassMaybe {
    // element collection should not be public
  List BookChapters;

  public Book() {
    this.BookChapters = new ArrayList();
  }

  public void addBookTest(BookText Item) {
    // validation and casting from object to BookText
  }

  // members here
} // class Book

当不同的类不多（可能是 5 个）时，这些方法很好。

2。树设计模式。

当所有元素即使不相似也将相等时，适用该模式，
通常是相同的类或接口，通常有很多项。

这些不适用于您的情况，但是，
我不得不提一下，为了更好地申请。

通常，使用树/分层集合类。
它可以是通用/模板树集合的子类，
或基本 tre 集合的子类，
它旨在被具有特定成员的子类所取代。

public class FileSystemRootClass {

  public bool AmISystemRoot() {
    // more
  }

  public bool AmIAFolder() {
    // more
  }

  public bool AmIAFile() {
    // more
  }

  public void addSystemRoot(string FileSystemName) {
    // more
  }

  public void addFolder(string FileSystemName) {
    // more
  }

  public void addFile(string FileSystemName) {
    // more
  }

  // members here
}

3.混合动力。

这是前两者的组合，
当有很多相关项目时使用它，
它比较复杂，可以使用也可以不使用Factory &抽象工厂模式，
其更常见的例子是视觉控制和视觉控制。小部件库。

import java.util.*;
public class WidgetsExample {
  public static void main(String[] args) {
    TreeSet <Widget> FormControls = new TreeSet<Widget>();

    TextBoxWidget TextBox = new TextBoxWidget();
    FormControls.add(TextBoxWidget);

    ListBoxWidget ListBox = new ListBoxWidget();
    FormControls.add(TextBoxWidget);

    ButtonWidget Button = new ButtonWidget();
    FormControls.add(Button);
} // class WidgetsExample

您可能会注意到我没有使用“工厂模式”和“工厂模式”。 “抽象工厂”，
由于需要更多代码。

祝你好运。

Answer 2

好的面向对象设计从考虑用例开始，而不是类层次结构。这是一个常见的错误，并且往往会产生过于复杂的设计。

首先考虑您正在构建的内容，并使用问题领域的语言使用英语散文写出问题陈述，即您正在解决的问题的描述。

如果产品是 UI，则考虑制作模型。

然后，您可以开始编写用例并开始思考对象如何彼此交互。

这称为面向对象编程，而不是面向类编程。类是管理/创建/运行系统中所有对象的代码规范。我会思考物体以及它们在做什么。类只是一个实现细节。

如果您的目标是对层次结构执行操作，您可能需要考虑使用复合模式。您可以做一些事情，例如拥有一个包含 Story 对象列表的 Story 对象。每个 Story 对象也将有它自己的类型（书集、书籍、章节、子章节、段落、论文），以及它自己的属性和方法（取决于您的用例）。

Answer 3

我会尝试这样的事情：

interface StoryElement<SE extends SubElements>{
    List<SE> getContents()
}

class Story<T extends StoryElement>


class Book implements StoryElement<Chapter> ...
class Chapter implements StoryElement<Section> ...
class Section implements StoryElement<Text>
class Text implements StoryElement<Text> {... // ugly hack, don't know of a clean way to end the recursion with Java Generics

现在你可以有一个书籍的故事或一个文本的故事。

警告：当尝试复杂化事情时，Java 泛型往往会失败。如有疑问，请忘记泛型和强制类型转换。

Answer 4

感谢所有的海报。这是我正在进行的解决方案：

public abstract class Element
{
    public ElementSet getContent() { return content; }

    // Overrides of setContent() check to see if the content type is appropriate
    // using instanceof.
    public void setContent( ElementSet content )
    {
        this.content = content;
    }


    private ElementSet content;
}

public abstract class ElementSet
{
    protected final void addElement( Element e )
    {
         elements.add(e);
    }

    private final List<Element> elements = new ArrayList<Element>();
}

public class BookSet extends ElementSet
{
    // Typesafe interface. 
    public void addBook( Book book ) { super.addElement( book ); }
}

public class ChapterSet extends ElementSet { /* similar to BookSet */ }

public class SectionSet extends ElementSet { /* similar to BookSet */ }

public class Book extends Element
{
    @Override
    public void setContent( ElementSet content )
    {
        if ( !(content instanceof ChapterSet) && !(content instanceof SectionSet) )
        {
            throw new RuntimeException();
        }
        super.setContent( content );
    }

    public boolean addChapter( Chapter chapter )
    {
        ElementSet content = getContent();
        if ( content == null )
        {
            content = new ChapterSet();
            setContent( content );
        }
        else if ( !(content instanceof ChapterSet) )
        {
            // Structure is wrong.
            return false;
        }

        ChapterSet chapters = (ChapterSet)content;
        chapters.addChapter( chapter);

        return true;        
    }

    public boolean addSection( Section section )
    {
        ElementSet content = getContent();
        if ( content == null )
        {
            content = new SectionSet();
            super.setContent( content );
        }
        else if ( !(content instanceof SectionSet) )
        {
            // Structure is wrong.
            return false;
        }

        SectionSet sections = (SectionSet)content;
        sections.addSection( section );

        return true;                
    }
}

public class Chapter extends Element
{
    @Override
    public void setContent( ElementSet content )
    {
        if ( !(content instanceof SectionSet) )
        {
            throw new RuntimeException();
        }
        super.setContent( content );
    }

    public boolean addSection( Section section )
    {
        ElementSet content = getContent();
        if ( content == null )
        {
            content = new SectionSet();
            super.setContent( content );
        }
        else if ( !(content instanceof SectionSet) )
        {
            // Structure is wrong.
            return false;
        }

        SectionSet sections = (SectionSet)content;
        sections.addSection( section );

        return true;                
    }
}

我尝试使用泛型来实现相同的目的，但由于需要反映容器的参数化类型，它看起来相当难看。