OOP组合

Question

我有一个关于OOP构图的问题。

假设一个母亲有0或更多的孩子，而一个孩子有一个也是唯一的一个生物母亲。

为了说明这一点，我做了以下工作：

public class Mother : ObservableObject
{
    // [...]

    ObservableCollection<Child> Children {get; set;}
}

public class Child : ObservableObject
{
    public Child(Mother mother)
    {
        this.Mother = mother;

        // Adding the child to the mother's children collection
        mother.Children.Add(this);
    }

    public Mother Mother {get; set;}
}

但我不知道是否可以自动将孩子添加到母亲的收藏中，或者我是否应该使用以下内容：

Mother mother = new Mother();

Child child = new Child(mother);
mother.Children.Add(child);

谢谢:)

Answer 1

我更喜欢，

public class Mother : ObservableObject
{
    // ...

    public Child GiveBirth()
    {
        var newBorn = new Child(this);
        this.Children.Add(newBorn);
        return newBorn;
    }

    // ...
}

Answer 2

我觉得模特有点离谱。Mother和Child在语义上是相互关联的，但它们是同一个对象的实例。他们都是Person。

创建Person是由Person执行的操作。因此，一个Person甚至不应该有一个公共构造函数，而是一个处理这个逻辑的工厂方法。就像这样：

public class Person : ObservableObject
{
    private Person()
    {
        Children = new ObservableCollection<Person>();
    }

    public Person Mother { get; private set; }
    public ObservableCollection<Person> Children { get; private set; }

    public Person Procreate()
    {
        var child = new Person();
        child.Mother = this;
        this.Children.Add(child);
        return child;
    }
}

这个模型仍然有一些限制，例如，我们这里只讨论无性繁殖。所以我们还没有有效地模拟人类。也许我们需要增加一个父亲？

public class Person : ObservableObject
{
    private Person()
    {
        Children = new ObservableCollection<Person>();
    }

    public Person Mother { get; private set; }
    public Person Father { get; private set; }
    public ObservableCollection<Person> Children { get; private set; }

    public Person Procreate(Person father)
    {
        var child = new Person();
        child.Mother = this;
        child.Father = father;
        this.Children.Add(child);
        father.Children.Add(child);
        return child;
    }
}

当然，我们想要添加一些检查空值之类的内容。现在我们也发现我们需要指定性别。(虽然家庭结构可能存在很大差异，但创造一个人的行为已经相当成熟。)所以我们可以继续添加这样的功能。在某种程度上，我们确实可以将这些子类划分为子类，但是这些子类最终很可能是具有硬编码默认值的语义传递对象，用于这个Person超类。

不过，为了好玩，我们试着加入性别.

public class Person : ObservableObject
{
    private Person(Sex gender, Person mother, Person father)
    {
        // TODO: Check for null mother and father
        this.Gender = gender;
        this.Mother = mother;
        this.Father = father;
        Children = new ObservableCollection<Person>();
    }

    public Sex Gender { get; private set; }
    public Person Mother { get; private set; }
    public Person Father { get; private set; }
    public ObservableCollection<Person> Children { get; private set; }

    public Person Procreate(Person father)
    {
        // TODO: Check for null father, confirm gender of father
        var child = new Person(PickRandomGender(), this, father);
        this.Children.Add(child);
        father.Children.Add(child);
        return child;
    }

    private Sex PickRandomGender() { /.../ }

    public enum Sex
    {
        Female,
        Male
    }
}

好吧，那很有趣。通过将一些逻辑移到构造函数中，也进行了一些清理。但现在还有另外一个问题..。父亲可以生育。听起来有点痛苦。现在看来，我们已经准备好了子类：

public class Person : ObservableObject
{
    protected Person(Sex gender, Person mother, Person father)
    {
        // TODO: Check for null mother and father
        this.Gender = gender;
        this.Mother = mother;
        this.Father = father;
        Children = new ObservableCollection<Person>();
    }

    public Sex Gender { get; private set; }
    public Person Mother { get; private set; }
    public Person Father { get; private set; }
    public ObservableCollection<Person> Children { get; private set; }

    protected Sex PickRandomGender() { /.../ }

    public enum Sex
    {
        Female,
        Male
    }
}

public class Woman : Person
{
    // TODO: Override Gender with a hard-coded value

    public Person Procreate(Person father)
    {
        // TODO: Check for null father, confirm gender of father
        var child = new Person(PickRandomGender(), this, father);
        this.Children.Add(child);
        father.Children.Add(child);
        return child;
    }
}

(我们是否也应该对Man进行子类划分？它在语义上似乎更干净，但是否有任何特定于男性的操作或属性不为女性所共享？也许吧，但我们的模型还没有那么详细。)

回顾过去，Mother和Child的类在这一点上似乎是有限的和短视的。女人不一定是母亲，所有的人都是孩子。正如您可以想象的那样，有大量的功能可以添加到这个系统中。但是，遵循同样的构建域的一般过程，像这样应该能够适应这种情况。

Answer 3

假设您有一个类名建筑。这个类构建有一个名为BuildRooms()的函数。还有另一间教室，可以用来做房间。您创建了类室的对象，如r1，r2，r3等。现在这座建筑有3间房间。我们可以在教室里打开和关闭门的方法。建筑类由房间组成。这意味着这栋楼有三个房间。用您喜欢的任何语言编写代码。这是构图。建筑物有房间，所以它有-一种关系。

    class building{

    void make_rooms()
    {
        room r1=new room(), r2=new room();
        r1.open();
        r2.close();
    }
}
class room{
    void open()
     {

     }
      void close()
      {

       }    

    }