如何在不编写“if 语句”的情况下初始化输入字段？

Question

我有一个枚举，就像

public enum Field {
     A, B, C, D, E ....;

     private Field(){
     }
}

我有一个 class Panel 一样，它需要 Field array 来初始化字段：

public class Panel {
     TextBox A; 
     TextBox B;
     TextBox C;
     TextBox D;
     TextBox E;
     ...


     public Panel(Field[] fields){
          this.fields = fields;
          init();
     }

     public void initA(){}
     public void initB(){}
     public void initC(){}
     public void initD(){}
     public void initE(){}
}

我的问题是，如何在不编写许多 if 语句的情况下初始化给定的字段？

我找不到任何解决方案，我现在像这样初始化：

public void init(){
      for(int i = 0 ; i < fields.length; i++){
          if(fields[i] == Field.A){
              initA();
          } else if(fields[i] == Field.B){
              initB();
          } else if(fields[i] == Field.C){
              initC();
          } else if(fields[i] == Field.D){
              initD();
          } else if(fields[i] == Field.E){
              initE();
          }  ....
      }
}

Answer 1

听起来你的设计可能需要考虑一下。一些建议：

• 将 init 方法添加到您的枚举中。所以
  然后你可以迭代数组
  你的枚举并调用 init
  方法，所以枚举知道如何
  进行自己的初始化
• 创建一个 Command 对象
  初始化并创建一个
  您的枚举的映射作为键和
  命令作为值。循环
  运行命令绕地图旋转
  对于每个枚举。
• 使用反射 - 成本方面我不会太担心这一点，除非您的系统具有令人难以置信的低延迟

对于第一个项目符号，您可以更改 TextBox 以保存针对它的 Field 类型，例如

TextBox A = new TextBox(Field.A);
TextBox B = new TextBox(Field.B);

所以如果 TextBox 知道它是 A，B ,C,D,E 那么你只需要循环你的 Field[] ，当它找到它的数学 TextBox 时运行初始化代码（可以针对特定的枚举实例存储）。当然，您需要在某个数据结构中注册所有 TextBox 实例，因为您似乎非常反对使用广泛使用的反射 API。

本质上，字段和文本框之间必须存在链接。 Java 无法读懂您的想法，并且无需您告诉它就知道这一点。好吧，至少在 Google 推出他们的心灵感应 API 之前（这可能只适用于 Go……）。这可以基于命名（反射）、硬编码逻辑（if 或开关）或基于状态来完成。对于后者，这意味着将字段与文本框相关联，正如我在上面的构造函数示例中所演示的那样。

Answer 2

从设计角度来看，我会选择工厂模式、单例模式（基于枚举）和命令模式的组合。我看到一组命令，其中每个命令都特定于给定值。 工厂（单例）是创建此类专用实例的常见模式。 尽管它只是将 if/switch 链移动到工厂中（但允许工厂使用条件检查来创建实例..）。

// the init command
public interface PanelInitializer {
  public init(Panel p);
}

---

// the factory
public enum PanelInitializerFactory {
  INSTANCE;

  public PanelInitializer create(Field field) {
    switch (field) {
      case A: return new TypeAInitializer();
      case B: return new TypeBInitializer();
      case C: return new TypeCInitializer();
      //..
    }
  }
}

我不认为我们可以在不使用命名约定和反射/实例化或不引入所有初始化程序共享相同代码的约束的情况下摆脱所有条件检查。

Answer 3

这是一个将 init 方法添加到枚举的代码片段。在每个字段的 init 方法中，您可以调用不同的 initX() 方法之一。使 init 方法抽象可以让编译器提醒您为枚举值定义 init 方法。

enum Field
{
  A{public void init(){initA();}},
  B{public void init(){initB();}},
  C{public void init(){initC();}},

  public abstract void init();
}

Answer 4

正如 @planetjones 提到的，您可以向枚举类添加一个 init() 方法。 init 方法应返回对其（枚举）类型的已初始化 TextBox 的引用。如果您需要将数据传递给初始化器，您可以传递this，以便它可以检索所需的任何信息。

为了解决查找要分配的变量的问题，您可以声明一个 TextBox 数组

public void init(){
  for(int i = 0 ; i < fields.length; i++){
      F[i] = fields[i].init(this);
  }
}

，或者在初始化临时数组后分配它们。

public void init(){
  TextBox F[5];
  for(int i = 0 ; i < fields.length; i++){
      F[i] = fields[i].init(this);
  }
  A = F[0];
  B = F[1];
  C = F[2];
  D = F[3];
  E = F[4];
}

当然，您应该声明常量而不是使用幻数。

Answer 5

您可以使用 java 反射来循环枚举，但您确实应该研究某种方法来合并所有 initN() 方法。

Answer 6

为什么你目前的实施很糟糕？仅仅因为长得“丑”？您可以使用 switch 而不是一堆 if：

  public void init(){
    for(int i = 0 ; i < fields.length; i++){
        switch(fields(i)){
          case A:
            initA();
            break
          case B:
          ...
        }
    }
  }

也许 initA、initB... 中的逻辑非常相似？如果你有 20 个不同的枚举，还有 20 个不同的 init 需要运行，那么改进的空间就很小了......

Answer 7

例如，您可以通过将初始化逻辑移至枚举来做到这一点。有一个初始化方法，它以 TextBox 作为参数并对其进行初始化。

顺便说一句，您最好将 TextBox 变量放在数组中。

编辑
另一种选择是，我经常使用枚举作为一种原型存储。我有一个方法返回一个与特定枚举类型匹配的对象。

如果您不想在枚举中进行初始化，您可以将其移至要返回的对象。对于每个特定的对象，您将有一个单独的初始化。

我担心你是想用这个来追龙。
这么看吧。由于您的问题是“有条件的”，即您必须根据字段的枚举类型进行不同的初始化，因此在某些时候您将不得不使用 ifs 或 switch 语句。

相信没有什么神奇的方法可以解决这个问题，程序应该如何知道你想要做什么？即使使用反射，您也会使用 ifs 等来相应地初始化它。

Answer 8

如果与每个 TextBox 关联的 init 方法非常不同，并且字段列表很小，那么您的方法一点也不坏。另外，如果您通常只实例化这些面板实例之一，那么其他方法实际上弊大于利。

话虽如此，请考虑使用 java.util。枚举映射。之后，您有三个选择：

1. 也在其他数组中注册文本框，
2. 调用 initA，...使用反射或
3. 使用某些仿函数构造调用它们。

最佳选择取决于用例。

Answer 9

从这个例子开始：

import java.util.HashMap;
import java.util.Map;

import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;

public class FooPanelMain {

    public static void main(String[] args) {

        FooPanel panel = new FooPanel();
        JFrame frame = new JFrame();
        frame.getContentPane().add(panel);
        frame.pack();
        frame.setVisible(true);
    }

}    

class FooPanel extends JPanel {

    // fields are dynamically created, so we put them into a map
    private Map<PanelField, JLabel> fields = new HashMap<PanelField, JLabel>();

    // enum to configure the fields
    private enum PanelField {
        FIRST("first text"), 
        SECOND("second text"), 
        LAST("last text");

        private String text;

        private PanelField(String text) {
            this.text = text;
        }

        public String getLabelName() {
            return text;
        }

    }
        // constructor uses the enum configuration to create the fields
    public FooPanel() {
        for (PanelField fooPanelField : PanelField.values()) {
            createLabel(fooPanelField);
        }
    }

    private void createLabel(PanelField field) {

        JLabel label = new JLabel(field.getLabelName());
        this.add(label);
        fields.put(field, label);
    }
}    

通过为PanelField定义一个由枚举实现的接口，这个例子可以很容易地变成一个抽象解决方案。 FooPanel 可以用作面板的基类。

Answer 10

最好将 init 移到枚举中，就像：

public enum Example{ 
  value1(1), 
  value2(2), 
  value3(66);

  private final int internalValue;

  Example(int value){ 
       this.internalValue = value; 
  }

  public int getInternalValue(){ 
       return this.internalValue; 
  }
}

虽然这是非常简单的示例，但您可以稍后向构造函数添加任何代码，并根据实际对象本身做出更复杂的决策。