Question

我有一个具有静态内部类的类。 OuterClass想要使用静态内部类中的变量。问题是如果我使用实例变量，我需要实例化内部类。所以，我决定使用静态变量。它与OOP概念相反吗？如果是这样，我应该遵循的任何其他原则或我应该使用的任何设计模式来做同样的事情吗？

我使用静态类的原因是我想为android活动创建一个自定义构建器。问题是我无法使用构造函数初始化扩展Activity的OuterClass。所以，我需要在onCreate（）方法中加载那些静态变量。

这是我的示例代码

public class DialogFactory extends Activity {

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    getWindow().setBackgroundDrawable(
        new ColorDrawable(android.graphics.Color.TRANSPARENT));

    setContentView(R.layout.activity_custom_dialog);
    this.setDialogTitle(Builder.title);
    this.setDialogMessage(Builder.message);
    this.loadButtons();
}

public void onClick(View view) {
    switch (view.getId()) {
    case R.id.dialog_positive_button:
        Builder.callable.onClickButton(Builder.type, DialogEventListener.ButtonType.POSITIVE_BUTTON);
        this.finish();
        break;
    case R.id.dialog_neutral_button:
        Builder.callable.onClickButton(Builder.type, DialogEventListener.ButtonType.NEUTRAL_BUTTON);
        this.finish();
        break;
    case R.id.dialog_negative_button:
        Builder.callable.onClickButton(Builder.type, DialogEventListener.ButtonType.NEGATIVE_BUTTON);
        this.finish();
        break;
    }
}

private void setDialogTitle(String title) {
    TextView view = (TextView) findViewById(R.id.dialog_title);
    view.setText(title);
}

private void setDialogMessage(String message) {
    TextView view = (TextView) findViewById(R.id.dialog_message);
    view.setText(message);
}

private void loadButtons() {
    Button positiveButton = (Button) findViewById(R.id.dialog_positive_button);
    Button negativeButton = (Button) findViewById(R.id.dialog_negative_button);
    Button neutralButton = (Button) findViewById(R.id.dialog_neutral_button);
    positiveButton.setVisibility(View.GONE);
    negativeButton.setVisibility(View.GONE);
    neutralButton.setVisibility(View.GONE);

    for (Map.Entry<DialogEventListener.ButtonType, String> entry: Builder.buttons.entrySet()) {
        if (entry.getKey() == DialogEventListener.ButtonType.POSITIVE_BUTTON) {
            positiveButton.setVisibility(View.VISIBLE);
            positiveButton.setText(entry.getValue());
        }
        else if (entry.getKey() == DialogEventListener.ButtonType.NEGATIVE_BUTTON) {
            negativeButton.setVisibility(View.VISIBLE);
            negativeButton.setText(entry.getValue());
        }
        else if (entry.getKey() == DialogEventListener.ButtonType.NEUTRAL_BUTTON) {
            neutralButton.setVisibility(View.VISIBLE);
            negativeButton.setText(entry.getValue());
        }
    }
}

@Override
  public void onBackPressed() {
  //
  }

public static final class Builder {
    private static DialogEventListener callable;
    private static DialogEventListener.DialogType type;
    private static String title;
    private static String message;
    private Context context;
    private static Map<DialogEventListener.ButtonType, String> buttons;

    public Builder(Context context, DialogEventListener callable,
        DialogEventListener.DialogType dialogType, String title, String message) {
        Builder.callable = callable;
        Builder.type = dialogType;
        Builder.title = title;
        Builder.message = message;
        this.context = context;
        Builder.buttons = new HashMap<DialogEventListener.ButtonType, String>();

    }

    public Intent build() {
        return new Intent(this.context, DialogFactory.class);
    }

    public void addButton(DialogEventListener.ButtonType buttonType, String label) {
        Builder.buttons.put(buttonType, label);
    }
  }
}

Answer 1

查看代码后，我发现了多个问题。首先，Builder类中的构造函数使用较少。并使用类名（将它们声明为静态）访问构建器类的所有属性将为您提供未初始化的引用，并将导致空指针异常。

我在这里并不完全理解你的Builder类的目的，但如果可能的话，尝试创建一个处理创建和初始化的单独类。之后在活动类中创建一个Builder类实例，使用构造函数注入依赖项，并尝试使用builder类中的函数来执行进一步的操作。

在静态内部类中使用静态变量

1 个答案: