JAVA枚举类状态机 与 Java枚举策略模式
写的比较晚了，贴代码供参考
1、普通的enum方法设计如下，缺点是不方便维护，因为是switch语句，容易在扩展的时候忘了改相关的代码。但如果你的代码千年不变，这个缺点就不明显。
注意：测试结果参见第2点。
package enumclass;
public enum PayrollBySwitch {
Monday,
Tuesday,
Wendsday,
Thursday,
Friday,
Saturday,
Sunday;
private static final int FIXED_WORK_HOUR_PER_DAY = 8;
//加班工资会是基本工资的一半。
private static final double OVER_TIME_PAY_RATE = 1/2;
public double pay(double workHours, double payPerHour){
double basePay = workHours * payPerHour;
double overTimePay = 0;
switch(this){
//周六日每个小时都算加班工资
case Saturday: case Sunday:
overTimePay = workHours * payPerHour * OVER_TIME_PAY_RATE;
break;
default:
overTimePay = workHours <= FIXED_WORK_HOUR_PER_DAY ?
0 : workHours - FIXED_WORK_HOUR_PER_DAY;
break;
}
return basePay+overTimePay;
}
}
2、enum方法的改进版，使用了enum strategy模式。要点：
1、设计一个private的enum，作为strategy的抽象。
2、顶层enum的构造器需要传入策略PayType。
3、策略类需要定义一个抽象类，让private enum去实现这个方法。这里用到enum的另一个特性：特定于常量的方法（Constant-specific class body的Constant -specific method implementation）。
package enumclass;
public enum PayrollByEnumStrategy {
Monday(PayType.WeekDay),
Tuesday(PayType.WeekDay),
Wendsday(PayType.WeekDay),
Thursday(PayType.WeekDay),
Friday(PayType.WeekDay),
Saturday(PayType.WeekEnd),
Sunday(PayType.WeekEnd);
PayType payType;
private PayrollByEnumStrategy(PayType payType) {
this.payType = payType;
}
public double pay(double workHours, double payPerHour){
return payType.pay(workHours, payPerHour);
}
private enum PayType{
WeekDay{
@Override
double overTimePay(double workHours, double payPerHour) {
double overTimePay = workHours <= FIXED_WORK_HOUR_PER_DAY ?
0 : (workHours - FIXED_WORK_HOUR_PER_DAY)*payPerHour*OVER_TIME_PAY_RATE;
return overTimePay;
}
},
WeekEnd{
@Override
double overTimePay(double workHours, double payPerHour) {
double overTimePay = workHours * payPerHour * OVER_TIME_PAY_RATE;
return overTimePay;
}
};
private static final int FIXED_WORK_HOUR_PER_DAY = 8;
//加班工资会是基本工资的一半。
private static final double OVER_TIME_PAY_RATE = 1/2;
abstract double overTimePay(double workHours, double payPerHour);
public double pay(double workHours, double payPerHour){
double basePay = workHours * payPerHour;
double overTimePay = overTimePay(workHours,payPerHour);
return basePay+overTimePay;
}
}
}
1 和 2的测试结果：
工资总额 by Switch= ￥3510.0
工资总额 by Enum Strategy= ￥3510.0
测试类如下：
package enumclass;
public class WorkPayment {
public static void main(String[] args) {
// TODO Auto-generated method stub
//计算一周的工资总额——每天工作10小时，每小时400块。
double sum = 0;
for(PayrollBySwitch day : PayrollBySwitch.values()){
sum += day.pay(10, 50);
}
System.out.println("工资总额 by Switch= ￥"+sum);
sum = 0;
for(PayrollBySwitch day : PayrollBySwitch.values()){
sum += day.pay(10, 50);
}
System.out.println("工资总额 by Enum Strategy= ￥"+sum);
}
}
3、覆盖enum的toString带来的方便。
如下面例子，打印日志时，很方便
package enumclass;
//enum strategy with toString overrided
public enum Operation {
PLUS("*") { double eval(double x, double y) { return x + y; } },
MINUS("-") { double eval(double x, double y) { return x - y; } },
TIMES("*") { double eval(double x, double y) { return x * y; } },
DIVIDE ("/"){ double eval(double x, double y) { return x / y; } };
String symbol = null;
Operation(String symbol){
this.symbol = symbol;
}
public String toString(){
return symbol;
}
// Do arithmetic op represented by this constant
abstract double eval(double x, double y);
}
package enumclass;
public class OperationTest {
public static void main(String[] args) {
double x = 2.000;
double y = 4.0000;
for(Operation oper : Operation.values()){
System.out.printf("%f %s %f = %f%n",x,oper,y,oper.eval(x, y));
}
}
}
测试结果如下:
2.000000 * 4.000000 = 6.000000
2.000000 - 4.000000 = -2.000000
2.000000 * 4.000000 = 8.000000
2.000000 / 4.000000 = 0.500000
4、最后是状态机的实现，已上传。
要点：
1、enum可以实现interface。
2、状态机维护需要两种对象：Context上下文、States状态
3、Context管理State。
4、用while运行状态机，其实这个while放到Context内更好，应该是状态机自己维护状态，而不是外部通过状态机去控制状态。
5、比较巧的设计是，每个state的操作返回boolean，作为状态是否终止的判断。
资源：http://download.csdn.net/detail/xzongyuan/9871848
State设置为如下时：
context.state(States.WHITE);
运行结果：
Current State = WHITE
Current State = BLUE
package enumstatemachin;
public class InfiniteMachineTest {
public static void main(String[] args) {
Context context = new ContextImp();
context.state(States.WHITE);
while(context.state().process(context));
}
}
package enumstatemachin;
import java.nio.ByteBuffer;
enum States implements State {
RED {
public boolean process(Context context) {
context.state(States.GREEN);
System.out.println("Current State = " + this);
return true;
}
}, GREEN {
public boolean process(Context context) {
context.state(States.BLACK);
System.out.println("Current State = " + this);
return true;
}
},BLACK {
public boolean process(Context context) {
context.state(States.YELLOW);
System.out.println("Current State = " + this);
return true;
}
},YELLOW {
public boolean process(Context context) {
context.state(States.WHITE);
System.out.println("Current State = " + this);
return true;
}
},WHITE {
public boolean process(Context context) {
context.state(States.BLUE);
System.out.println("Current State = " + this);
return true;
}
},BLUE{
public boolean process(Context context) {
context.state(States.RED);
System.out.println("Current State = " + this);
return false;
}
};
public abstract boolean process(Context context);
}
package enumstatemachin;
interface State {
/**
* @return true to keep processing, false to read more data.
*/
boolean process(Context context);
}
package enumstatemachin;
import java.nio.ByteBuffer;
public interface Context {
State state();
void state(State state);
}
package enumstatemachin;
import java.nio.ByteBuffer;
public class ContextImp implements Context {
State state;
@Override
public State state() {
// TODO Auto-generated method stub
return state;
}
@Override
public void state(State state) {
this.state = state;
}
}