Question

我有一个接近扩展枚举的要求，因为这是不可能的，在网上进行一些研究之后，我想出了这种使用接口并使枚举扩展它们的方法。

我的问题是我有一些基本类型A，B和每种类型的标志，说明是否必须检查。同样地，我有一些扩展类型C ...在检查它们的标志后执行相同的操作。

以下是执行此操作的代码

类型接口：

public interface Type {

    public String name();

}

以下是使用基本类型的类

public class BasicChecker {

    private static boolean checkA = false;
    private static boolean checkB = false;

    public enum BasicType implements Type {
        A, B;
    }

    public static boolean isCheckA() {
        return checkA;
    }

    public static void setCheckA(boolean checkA) {
        BasicChecker.checkA = checkA;
    }

    public static boolean isCheckB() {
        return checkB;
    }

    public static void setCheckB(boolean checkB) {
        BasicChecker.checkB = checkB;
    }

    public static void doStuff(String message, Type type) {
        if (type.name().equalsIgnoreCase(BasicType.A.name())) {
            doStuff(message, isCheckA());
        } else if (type.name().equalsIgnoreCase(BasicType.B.name())) {
            doStuff(message, isCheckB());
        }
    }

    protected static void doStuff(String message, boolean flag) {
        if (someCheckMethod() && flag) {
            doStuff(message, flag);
        }
    }

    private static boolean someCheckMethod() {
        return false;
    }
}

这是使用扩展类型的类

public class ExtendedChecker extends BasicChecker {

    private static boolean checkC = false;

    public enum ExtendedType implements Type {
        C;
    }

    public static boolean isCheckC() {
        return checkC;
    }

    public static void setCheckC(boolean checkC) {
        ExtendedChecker.checkC = checkC;
    }

    public static void doStuff(String message, Type type) {
        BasicChecker.doStuff(message, type);
        if (type.name().equalsIgnoreCase(ExtendedType.C.name())) {
            doStuff(message, isCheckC());
        }
    }
}

我现在要解决的是从log方法中删除所有if else案例。我也试图看看是否有更好的方法来做到这一点。请忽略静态。我确实希望它们是静态字段和方法。

Answer 1

我无法准确理解您在描述中尝试做什么，但您可能会发现abstract中的enum方法很有用。

例如，您可以向abstract添加enum方法“foo”：

public enum BasicType implements Type {
    A {
        public void foo(String message) {
            // Do special A stuff
        } 
    }, B {
        public void foo(String message) {
            // Do special B stuff
        } 
    };

    public abstract void foo(String message);
}

然后你可以像这样使用那个方法：

public static void doStuff(String message, Type type) {
    type.foo(message);
}

当然，您可以在abstract interface extend中添加任何此类{{1}}方法，如果这有用的话。

Answer 2

public class BasicChecker {
  private static final Set<Type> _doCheck = Collections.newSetFromMap(new ConcurrentHashMap<Type,Boolean>());

  public enum BasicType implements Type {
    A, B;
  }

  public static boolean isCheck(Type type) {
    return return _doCheck.contains(type);
  }

  public static void setCheck(Type type, boolean check) {
    if(check) {
      _doCheck.add(type);
    } else {
      _doCheck.remove(type);
    }
  }

  public static void doStuff(String message, Type type) {
    doStuff(message, isCheck(type));
  }
}

扩展枚举的优雅方式

2 个答案: