相关疑难解决方法(0)

Builder设计模式和Factory设计模式有什么区别？

哪一个更有利,为什么？

如果我想测试和比较/对比这些模式,我如何将我的发现表示为图表？

我有一个Wicket页面类,它根据抽象方法的结果设置页面标题.

public abstract class BasicPage extends WebPage {

    public BasicPage() {
        add(new Label("title", getTitle()));
    }

    protected abstract String getTitle();

}

NetBeans通过消息"构造函数中的可覆盖方法调用"警告我,但它应该有什么问题呢？我能想象的唯一选择是将其他抽象方法的结果传递给子类中的超级构造函数.但是很多参数很难读懂.

我观察到外类可以访问内部类私有实例变量.这怎么可能？以下是演示相同内容的示例代码:

class ABC{
    class XYZ{
        private int x=10;
    }

    public static void main(String... args){
        ABC.XYZ xx = new ABC().new XYZ();
        System.out.println("Hello :: "+xx.x); ///Why is this allowed??
    }
}

为什么允许这种行为？

在Java中,您可以使用构建器模式提供更具可读性的方法来实例化具有许多参数的类.在构建器模式中,构造一个配置对象,其中包含设置命名属性的方法,然后使用它来构造另一个对象.

Python中的等价物是什么？是模仿相同实现的最佳方法吗？

我很擅长设计模式,并且在流畅的界面和Builder模式之间存在差异.

我理解流畅的接口的概念.但是构建器模式有点令人困惑.我无法理解在Builder模式中使用Director.

我可以一起使用Builder模式和Fluent Interface吗？如果是这样,那么我应该如何与导演和具体建筑师一起这样做？

我的问题不是关于构建器模式的优点.但这个问题的目的是了解构建器模式和流畅界面之间的关系.

使用GoF的Builder的UML序列图进行编辑:

动机

最近我搜索了一种初始化复杂对象的方法,而没有将大量参数传递给构造函数.我尝试使用构建器模式,但我不喜欢这样的事实,即如果我确实设置了所有需要的值,我无法在编译时检查.

传统建设者模式

当我使用构建器模式创建我的Complex对象时,创建更"类型安全",因为它更容易看到用于什么参数:

new ComplexBuilder()
        .setFirst( "first" )
        .setSecond( "second" )
        .setThird( "third" )
        ...
        .build();

但现在我遇到了问题,我很容易错过一个重要的参数.我可以在build()方法中检查它,但这只是在运行时.如果我错过了什么,在编译时没有什么可以警告我.

增强的构建器模式

现在我的想法是创建一个构建器,"提醒"我是否错过了所需的参数.我的第一次尝试看起来像这样:

public class Complex {
    private String m_first;
    private String m_second;
    private String m_third;

    private Complex() {}

    public static class ComplexBuilder {
        private Complex m_complex;

        public ComplexBuilder() {
            m_complex = new Complex();
        }

        public Builder2 setFirst( String first ) {
            m_complex.m_first = first;
            return new Builder2();
        }

        public class Builder2 {
            private Builder2() {}
            Builder3 setSecond( String …

我想重构一些目前由超类和两个子类组成的代码.

这些是我的课程:

public class Animal {
    int a;
    int b;
    int c;
}

public class Dog extends Animal {
    int d;
    int e;
}

public class Cat extends Animal {
    int f; 
    int g;
}

这是我目前的代码:

ArrayList<Animal> listAnimal = new ArrayList<>();

if (condition) {
    Dog dog = new Dog();
    dog.setA(..);
    dog.setB(..);
    dog.setC(..);
    dog.setD(..);
    dog.setE(..);   
    listAnimal.add(dog);

} else {
    Cat cat = new Cat();
    cat.setA(..);
    cat.setB(..);
    cat.setC(..);
    cat.setF(..);
    cat.setG(..);
    listAnimal.add(cat);
}

如何重构有关公共属性的代码？

我想要这样的东西:

Animal animal = new Animal();
animal.setA(..);
animal.setB(..);
animal.setC(..); …

从什么时候开始使用Builder模式？,

据说建造者模式适合比萨实例.

为什么不装饰？将奶酪,意大利辣香肠,培根作为基础披萨上的附加装饰品.

是因为奶酪/意大利辣香肠必须单独建造.我不认为,它们需要单独构建,因为它们可以随时可用.

请澄清一下.我也在寻找装饰模式的一个很好的现实世界的例子,以及为什么它适合那个特定的例子.谢谢.

最近我在求职面试时被问到这个问题,我无法回答.那么,java.io中最常用的模式是什么？它是如何使用的？常见的Java库中使用的其他模式有哪些？

我已经看到这个问题在这里和那里出现了几次,但我从来没有找到并回答我很高兴.

来自维基百科:

Builder专注于逐步构建复杂对象.Abstract Factory强调一系列产品对象(简单或复杂).Builder将产品作为最后一步返回,但就Abstract Factory而言,产品会立即返回.

但对客户来说不是一回事吗？一旦它被构建,他就会获得完整的对象,所以对他来说没有额外的功能.

我看到它的唯一方法是作为一种方式或按步骤组织构造函数代码,以强制实现构建器的结构.哪个好,但从抽象工厂那里迈出的一步很难.

来自维基百科的下一篇文章是一个很好的参考,以达到我的观点:

通常,设计开始使用工厂方法(不太复杂,可定制,子类增加),并逐渐向抽象工厂,原型或构建器(更灵活,更复杂)发展,因为设计师发现需要更多灵活性的地方.

如果是这样,那么您需要在系统中引入哪种复杂性,从而将抽象工厂更改为构建器？

我的观点是,我无法找到并举例说明抽象工厂是否足够,而你需要一个Builder.