具有类主体和数据的枚举类型

Question

enum BankOperation { PLUS, MINUS }
public BankOperation getBankOperation(int oldAmount, int newAmount) {
BankOperation operation = newAmount >= oldAmount ? BankOperation.PLUS : BankOperation.MINUS;
int delta = Math.abs(newAmount - oldAmount);
switch (operation) {
case PLUS:
System.out.println(String.format("Adding %s dollars", delta));
break;
case MINUS:
System.out.println(String.format("Withdrawing %s dollars", delta));
break;
}
return operation;
}

注意：该示例故意简单，不会从使用enum方法中受益。

我有两个BankOperationPLUS，MINUS有一个switch.我通过getBankOperation(5, 20);获得BankOperation，以便我可以继续。

我想知道是否可以在enum上使用方法而不是switch，以便我可以通过以下方式获得BankOperation和足够的日志记录

BankOperation bankOperation = BankOperation.forOldAndNewAmount(5, 20).startProcessing();

哪里

forOldAndNewAmount(5, 20)初始化枚举并使delta15成为枚举BankOperation的private int delta字段

startProcessing()是BankOperation的抽象method，根据BankOperationSystem.out.println(String.format("Adding/Withdrawing %s dollars", delta));

我发现最困难的是 - 在enum体中打印delta15而不将其作为startProcessing()的参数 - 返回PLUS并在startProcessing()中MINUSenum自身。

Answer 1

在您的实际示例中，getBankOperation()是BankOperation枚举应该负责的处理。
您不需要Bank实例来处理它。
所以只需将此方法作为枚举的静态方法移动：

enum BankOperation { PLUS, MINUS; 
public static BankOperation getBankOperation(int oldAmount, int newAmount) {
BankOperation operation = newAmount >= oldAmount ? BankOperation.PLUS : BankOperation.MINUS;
int delta = Math.abs(newAmount - oldAmount);
switch (operation) {
case PLUS:
System.out.println(String.format("Adding %s dollars", delta));
break;
case MINUS:
System.out.println(String.format("Withdrawing %s dollars", delta));
break;
}
return operation;
}
};

现在你可以做：

BankOperation bankOperation = BankOperation.getBankOperation(5, 20);

此外，这部分可以在枚举方法中移动：

switch (operation) {
case PLUS:
System.out.println(String.format("Adding %s dollars", delta));
break;
case MINUS:
System.out.println(String.format("Withdrawing %s dollars", delta));
break;
}

它会给出：

enum BankOperation {
PLUS {
public String getOutput(int delta) {
return String.format("Adding %s dollars", delta);
}
},
MINUS {
@Override
public String getOutput(int delta) {
return String.format("Withdrawing %s dollars", delta);
}
};
public abstract String getOutput(int delta);
public static BankOperation getBankOperation(int oldAmount, int newAmount) {
BankOperation operation = newAmount >= oldAmount ? BankOperation.PLUS : BankOperation.MINUS;
int delta = Math.abs(newAmount - oldAmount);
System.out.println(operation.getOutput(delta));
return operation;
}
}

---

关于您的评论 ：

您是否可能让我知道如何实现"制作三角洲 初始化枚举时BankOperation的private int delta字段 有了forOldAndNewAmount(5, 20)，我就可以打电话给startProcessing()链而不使其成为参数"？

您不应该这样做，因为枚举表示常量值。在处理过程中覆盖枚举的值不清楚，如果你的应用是多线程的，可能会产生副作用。
作为替代方法，您可以使用一个类来包装BankOperation和增量(BankOperationComputed(，并且forOldAndNewAmount()返回。

BankOperation getBankOperation()最好命名为BankOperationComputed computeBankOperation()：

public static BankOperationComputed computeBankOperation(int oldAmount, int newAmount) {
BankOperation operation = newAmount >= oldAmount ? BankOperation.PLUS : BankOperation.MINUS;
int delta = Math.abs(newAmount - oldAmount);
return new BankOperationComputed(operation, delta);
}

银行操作计算

public class BankOperationComputed {
private final BankOperation operation;
private final int delta; 
BankOperationComputed (BankOperation operation, int delta){
this.operation = operation;
this.delta = delta;
}
public void startProcessing(){
System.out.println(operation.getOutput(delta));
}
}

现在你可以这样做：

BankOperation.computeBankOperation(5, 20) // returns BankOperationComputed 
.startProcessing();  // uses the enum under the hoods

Answer 2

我想你正在寻找这样的东西：

public class Bank {
enum BankOperation { 
PLUS("Adding %s dollars"), 
MINUS("Withdrawing %s dollars");
private final String msg;
BankOperation(final String msg) {
this.msg = msg;
}

public String getMsg() {
return msg;
}
}
public BankOperation getBankOperation(int oldAmount, int newAmount) {
BankOperation operation = newAmount >= oldAmount ? BankOperation.PLUS : BankOperation.MINUS;
int delta = abs(newAmount - oldAmount);
System.out.println(String.format(operation.getMsg(), delta));
return operation;
}

}

Answer 3

枚举的常量是(抽象(枚举类本身的子类。然后，您可以执行以下操作

public enum BankOperation {
DEPOSIT {
@Override
public void execute(Bank bank, Amount amount) {
// do something
}
},
WITHDRAW {
@Override
public void execute(Bank bank, Amount amount) {
// do something else
}
};
public abstract void execute(Bank bank, Amount amount);
}
// called like 
BankOperation.DEPOSIT.execute(bank, amount);
// or
BankOperation operation;
...
operation.execute(bank, amount

由于enum类是其每个常量的(抽象(父级，因此可以将字段和构造函数添加到enum：

public enum BankOperation {
DEPOSIT("Deposit") {
@Override
public void execute(Bank bank, Amount amount) {
// do something
}
},
WITHDRAW("Withdraw") {
@Override
public void execute(Bank bank, Amount amount) {
// do something else
}
};
private String name;
private BankOperation(String theName) {
this.name = theName;
}
public abstract void execute(Bank bank, Amount amount);
public String getName() {
return name;
}
}

添加静态方法也很有帮助：

public enum BankOperation {
DEPOSIT("Deposit") {
...
},
WITHDRAW("Withdraw") {
...
};
...
public static BankOperation get(Amount oldAmount, Amount newAmount) {
// same amount being ignored for simplicity
if (newAmount.isLessThan(oldAmount))
return WITHDRAW;
else
return DEPOSIT;
}
}