1

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

我的问题是我有一些基本类型 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 情况。我也想看看是否有更好的方法来做到这一点。请忽略静态。我确实希望它们是静态字段和方法。

4

2 回答 2

4

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

例如，您可以在 s 中添加一个abstract方法“foo” enum：

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的话，您可以将任何此类方法放在interfaceyou中。extend

于 2013-06-27T02:34:24.973 回答
0 
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));
  }
}
于 2013-06-27T02:58:15.847 回答