Java 我应该如何将复合模式包装到构建器模式中？

假设我有一个组合设置，如下所示：

public abstract class Element {
    //position, size, etc.

    //element methods

    //setters/getters
}

public class SimpleElement1 extends Element {
    //...
}

public class SimpleElement2 extends Element {
   //...
}

public class CompositeElement extends Element {
     protected List<Element> childrenElements;

     //methods to add/remove/get children
}

公共抽象类元素{
//位置、大小等。
//元素方法
//二传手
}
公共类SimpleElement1扩展元素{
//...
}
公共类SimpleElement2扩展元素{
//...
}
公共类CompositeElement扩展元素{
受保护的儿童元素列表；
//添加/删除/获取子级的方法
}

---

现在，我该如何将这个组合包装成一个构建器模式，这样我就可以通过使客户机代码不需要关心（或不需要关心）来简化客户机代码关于如何将孩子们与他们的组合链接的复杂性，这里有一个建筑工人制作不同动物部位的动物组合的例子。您应该能够为您的特定应用程序修改它

class BuilderDesignPattern{
     public static void Main(string[] args)
        {
            Kid aKid = new Kid();
            aKid.Name = "Elizabeth";

            AnimalBuilder builderA = new MonkeyBuilder();
            aKid.MakeAnimal(builderA);
            builderA.aAnimal.ShowMe();

            AnimalBuilder builderB = new KittenBuilder();
            aKid.MakeAnimal(builderB);
            builderB.aAnimal.ShowMe();

        }
    }
    public abstract class AnimalBuilder
    {
        public Animal aAnimal;

        public abstract void BuildAnimalHeader();
        public abstract void BuildAnimalBody();
        public abstract void BuildAnimalLeg();
        public abstract void BuildAnimalArm();
        public abstract void BuildAnimalTail();
    }
    public class MonkeyBuilder : AnimalBuilder
    {

        public MonkeyBuilder()
        {
            aAnimal = new Monkey();
        }

        public override void BuildAnimalHeader()
        {
            aAnimal.Head = "Moneky's Head has been built";
        }

        public override void BuildAnimalBody()
        {
            aAnimal.Body = "Moneky's Body has been built";
        }

        public override void BuildAnimalLeg()
        {
            aAnimal.Leg = "Moneky's Leg has been built";
        }

        public override void BuildAnimalArm()
        {
            aAnimal.Arm = "Moneky's Arm has been built";
        }

        public override void BuildAnimalTail()
        {
            aAnimal.Tail = "Moneky's Tail has been built";
        }
    }
    public class KittenBuilder : AnimalBuilder
    {
        public KittenBuilder()
        {
            aAnimal = new Kitten();
        }

        public override void BuildAnimalHeader()
        {
            aAnimal.Head = "Kitten's Head has been built";
        }

        public override void BuildAnimalBody()
        {
            aAnimal.Body = "Kitten's Body has been built";
        }

        public override void BuildAnimalLeg()
        {
            aAnimal.Leg = "Kitten's Leg has been built";
        }

        public override void BuildAnimalArm()
        {
            aAnimal.Arm = "Kitten's Arm has been built";
        }

        public override void BuildAnimalTail()
        {
            aAnimal.Tail = "Kitten's Tail has been built";
        }
    }
    public abstract class Animal
    {
        public BodyPart Head { get; set; }
        public BodyPart Body { get; set; }
        public BodyPart Leg { get; set; }
        public BodyPart Arm { get; set; }
        public BodyPart Tail { get; set; }


        //helper method for demo the Polymorphism, so we can 
        //easily tell what type object it is from client.
        public abstract void Eat();

        //helper method for demo the result from client
        public void ShowMe()
        {
            Console.WriteLine(Head);
            Console.WriteLine(Body);
            Console.WriteLine(Leg);
            Console.WriteLine(Arm);
            Console.WriteLine(Tail);
            Eat();

        }
    }
    public class Monkey : Animal
    {
        //helper method to show monkey's property for demo purpose
        public override void Eat()
        {
            Console.WriteLine("Since I am Monkey, I like to eat banana");
        }
    }
    public class Kitten : Animal
    {
        public override void Eat()
        {
            Console.WriteLine("Since I am Kitten, I like to eat kitten food");
        }
    }
    public class Kid
    {
        public string Name { get; set; }

        //construct process to build an animal object, 
        //after this process completed, a object 
        //will be consider as a ready to use object.
        public void MakeAnimal(AnimalBuilder aAnimalBuilder)
        {
            aAnimalBuilder.BuildAnimalHeader();
            aAnimalBuilder.BuildAnimalBody();
            aAnimalBuilder.BuildAnimalLeg();
            aAnimalBuilder.BuildAnimalArm();
            aAnimalBuilder.BuildAnimalTail();
        }


    }
    public class BodyPart{
        String name= "";
        public BodyPart(String name){
            this.name=name;
        }
    }
}

---

在构建器中，添加方法“startComposite”和“endComposite”。这些方法将组合推送到堆栈上，并从堆栈中移除组合。要添加元素的消息始终添加到堆栈顶部

    builder.startComposite();
        builder.simpleElement1();
        builder.simpleElement2();
    builder.endComposite();
    builder.startComposite();
        builder.simpleElement2();
    builder.endComposite();

如果生成器方法始终返回生成器，则可以消除接收器的重复：

    builder.
        startComposite().
            simpleElement1().
            simpleElement2().
        endComposite().
        startComposite().
            simpleElement2().
        endComposite();

---

谢谢你的快速回答，但是这里的动物合成物怎么样？也许我应该重新表述一个问题：拥有一个类似于构建器模式的结构，以便创建复合元素的客户端代码更简单和/或更适合某种形式的脚本？BodyPart是组件，Monkey是复合的。这个例子很简单，但如果你做一棵树，就像手指放在手臂上，那么就会有树叶。好吧，这就是我在问之前脑子里想的，也是我最终问这个问题的原因。虽然这会起作用，但似乎只会使客户端代码复杂化（或限制其灵活性），还有一个问题是，我是否需要让构建者的组合使整个事情变得灵活，例如，构建者用较小的身体部位制作手臂，构建者制作腿，然后是一个建筑工人，他将依靠那些低水平的建筑工人来制造整个动物？因此，我认为这只会导致类爆炸，从而使整个过程保持一定的灵活性。构建器增加了类的数量，但简化了复杂的类创建。嗯，这可能就是我想要的。我会在白天努力解决，看看结果如何。谢谢你抽出时间。