Question

我有一个用例，我有这样的代码：

  <DataGrid ...>
        <DataGrid.Resources>
            <Style TargetType="CheckBox">
                <Setter Property="Background" Value="Green"/>
                <Style.Triggers>
                    <DataTrigger Binding="{Binding Column.DisplayIndex, RelativeSource={RelativeSource AncestorType=DataGridCell, Mode=FindAncestor}}" Value="0">
                        <Setter Property="Background" Value="Red"/>
                    </DataTrigger>
                </Style.Triggers>
            </Style>
        </DataGrid.Resources>
    </DataGrid>

它将从main中的TopApp类调用:(严格要求）

public class Xapp extends App {
     private A a;
     private B b;
     private C c;

     public Xapp() {
        // do anything
     }

     @override
     public void doStuff() {
       try{
          do1();
          do2();
          do3()
       } catch(Exception e) {
           throw new XappException(msg);
       }
     }

     public void do1() {
         a = new A();
         a.process();
     }

     public void do2() {
         b = new B();
         b.process();
     }

     public void do3() {
         c = new C();
         c.process();
     }

}

此处，B的初始化取决于 A 进程， C 的初始化取决于 A 和 B 过程。因此，我正在以迭代的方式初始化。（延迟初始化）。

但是有人告诉我应该严格执行设计，以便每个构造函数（ A ， B 和 C ）初始化都应该在仅限Xapp构造函数。（急切的初始化）

我莫名其妙地不同意。因为我的代码流是生产者和消费者的迭代。通常，我们会在资源可用时进行初始化。但在这里我不能，因为资源将由A然后B迭代地处理，然后C。

我发现这种方法是完美的。有任何设计缺陷吗？

Answer 1

当你无法在构造函数中进行初始化时，一种常见的模式是使构造函数为private，并使静态方法返回新的完全初始化的实例。

public class Xapp extends App {
     private A a;
     private B b;
     private C c;

     private Xapp() {
        // do anything
     }

     public static Xapp newInstance() {
         Xapp x = new Xapp();
         x.doStuff();
         return x
     }

     // snip...

}

当你的类可以被继承时，这个特别有用，因为如果sublcass由于初始化顺序而覆盖它们，那么在构造函数中调用非私有方法可能会有问题。

渴望初始化vs Lazy初始化用例

1 个答案: