枚举类各种模式

最新推荐文章于 2024-03-11 20:04:03 发布

zhangzengxiu

最新推荐文章于 2024-03-11 20:04:03 发布

阅读量416

点赞数

文章标签： java 枚举类

本文链接：https://blog.csdn.net/zhangzengxiu/article/details/130277806

版权

策略模式

通过在枚举类型中定义不同的枚举值来代表不同的策略类型，然后使用不同的枚举值调用相应的策略方法。

/**
 * 枚举类策略模式
 *
 * @author zhangzengxiu
 * @date 2023/4/20
 */
public enum StrategyTypeEnum {

    ADD {
        @Override
        public int calculate(int a, int b) {
            return a + b;
        }
    }, SUBTRACT {
        @Override
        public int calculate(int a, int b) {
            return a - b;
        }
    }, MULTIPLY {
        @Override
        public int calculate(int a, int b) {
            return a * b;
        }
    }, DIVIDE {
        @Override
        public int calculate(int a, int b) {
            return a / b;
        }
    };

    /**
     * 计算
     *
     * @param a
     * @param b
     * @return
     */
    public abstract int calculate(int a, int b);

}

使用方式

/**
 * @author zhangzengxiu
 * @date 2023/4/20
 */
public class CalculatorTest {
    public static void main(String[] args) {
        int a = 10;
        int b = 5;
        // 调用加法策略计算
        int result = StrategyTypeEnum.ADD.calculate(a, b);
        System.out.println(result);
        // 调用减法策略计算
        result = StrategyTypeEnum.SUBTRACT.calculate(a, b);
        System.out.println(result);
        // 调用乘法策略计算
        result = StrategyTypeEnum.MULTIPLY.calculate(a, b);
        System.out.println(result);
        // 调用除法策略计算
        result = StrategyTypeEnum.DIVIDE.calculate(a, b);
        System.out.println(result);
    }
}

单例模式

通过将枚举类型定义为单例，枚举值就代表了单例对象，这种方式可以避免线程安全问题，并且可以自动处理序列化和反序列化。

/**
 * 单例模式
 *
 * @author zhangzengxiu
 * @date 2023/4/20
 */
public enum SingletonEnum {
    INSTANCE;

    public void method() {
        System.out.println("do something...");
    }

}

class SingletonEnumTest {
    public static void main(String[] args) {
        SingletonEnum.INSTANCE.method();
    }
}

状态机

通过在枚举类型中定义不同的枚举值来代表不同的状态，然后根据不同的枚举值进行状态转移的处理。

/**
 * 枚举类实现状态机
 *
 * @author zhangzengxiu
 * @date 2023/4/20
 * @description 枚举类型 State，包含三个实例 START、PROCESS、END
 */
public enum StateEnum {

    START {
        @Override
        public StateEnum getNextStatus() {
            return StateEnum.PROCESS;
        }
    }, PROCESS {
        @Override
        public StateEnum getNextStatus() {
            return StateEnum.END;
        }
    }, END {
        @Override
        public StateEnum getNextStatus() {
            return null;
        }
    };

    /**
     * 获取下一个状态
     *
     * @return
     */
    public abstract StateEnum getNextStatus();

}

/**
 * 状态机
 */
class StateMachine {

    /**
     * 设置当前状态
     */
    private StateEnum currentState = StateEnum.START;

    public void process() {
        while (currentState != null) {
            System.out.println("当前状态：" + currentState);
            currentState = currentState.getNextStatus();
        }
    }

    public static void main(String[] args) {
        StateMachine stateEnumTest = new StateMachine();
        stateEnumTest.process();
    }
}

命令模式

通过在枚举类型中定义不同的枚举值来代表不同的命令类型，然后根据不同的枚举值执行相应的命令处理。

/**
 * 枚举类：命令模式
 *
 * @author zhangzengxiu
 * @date 2023/4/20
 */
public enum CommandEnum {

    OPEN {
        @Override
        public void execute() {
            System.out.println("Open command is executed.");
        }
    }, CLOSE {
        @Override
        public void execute() {
            System.out.println("Close command is executed.");
        }
    }, SAVE {
        @Override
        public void execute() {
            System.out.println("Save command is executed.");
        }
    }, UNDO {
        @Override
        public void execute() {
            System.out.println("Undo command is executed.");
        }
    };

    public abstract void execute();

}

class CommandTest {
    public static void main(String[] args) {
        CommandEnum.OPEN.execute();
        CommandEnum.CLOSE.execute();
        CommandEnum.SAVE.execute();
        CommandEnum.UNDO.execute();
    }
}

工厂模式

通过在枚举类型中定义不同的枚举值来代表不同的产品类型，然后根据不同的枚举值创建相应的产品对象。


/**
 * @author zhangzengxiu
 * @date 2023/4/20
 */
public enum ProductTypeEnum {

    BOOK {
        @Override
        public Product createProduct() {
            return new BooK();
        }
    }, DVD {
        @Override
        public Product createProduct() {
            return new DVD();
        }
    }, CD {
        @Override
        public Product createProduct() {
            return new CD();
        }
    };

    /**
     * 抽象方法，创建并返回不同类型的产品
     *
     * @return
     */
    public abstract Product createProduct();
}

class Product {
    public void showInfo() {
    }
}

class CD extends Product {
}

class DVD extends Product {
}

class BooK extends Product {
}

class ProductFactory {
    public static void main(String[] args) {
        // 通过枚举类型创建不同类型的产品
        Product product = ProductTypeEnum.BOOK.createProduct();
        product.showInfo();
        product = ProductTypeEnum.DVD.createProduct();
        product.showInfo();
        product = ProductTypeEnum.CD.createProduct();
        product.showInfo();
    }
}

枚举集合

通过在枚举类型中定义不同的枚举值来代表集合中的元素，然后使用枚举类型的方法进行集合操作，例如遍历、查找、排序等。

/**
 * 实现枚举集合
 *
 * @author zhangzengxiu
 * @date 2023/4/20
 */
public enum ColorEnum {
    RED,
    GREEN,
    BLUE;
}

class ColorEnumTest {
    public static void main(String[] args) {
        for (ColorEnum color : ColorEnum.values()) {
            System.out.println(color.name());
        }
    }
}

状态模式

通过在枚举类型中定义不同的枚举值来代表不同的状态，然后在状态类中进行状态转移的处理，通过切换枚举值来改变状态。

/**
 * 枚举类：状态模式
 *
 * @author zhangzengxiu
 * @date 2023/4/20
 */
public enum TrafficLightEnum {

    RED {
        @Override
        public void handle() {
            System.out.println("Stop! The light is red.");
        }
    }, YELLOW {
        @Override
        public void handle() {
            System.out.println("Prepare to stop! The light is yellow.");
        }
    }, GREEN {
        @Override
        public void handle() {
            System.out.println("Go! The light is green.");
        }
    };


    /**
     * 处理不同的红绿灯行为
     */
    public abstract void handle();

}

责任链模式

通过在枚举类型中定义不同的枚举值来代表不同的处理器类型，然后使用链式调用的方式将处理器链接起来，每个处理器根据自己的枚举值判断是否处理该请求。

/**
 * 实现责任链模式
 *
 * @author zhangzengxiu
 * @date 2023/4/20
 */
public enum HandlerTypeEnum {

    TYPE1 {
        @Override
        public void handleRequest(String request) {
            if (request.equals("Request type 1")) {
                System.out.println("Type1 handler handles the request.");
            } else {
                nextHandler.handleRequest(request);
            }
        }
    }, TYPE2 {
        @Override
        public void handleRequest(String request) {
            if (request.equals("Request type 2")) {
                System.out.println("Type2 handler handles the request.");
            } else {
                nextHandler.handleRequest(request);
            }
        }
    }, TYPE3 {
        @Override
        public void handleRequest(String request) {
            if (request.equals("Request type 3")) {
                System.out.println("Type3 handler handles the request.");
            } else {
                System.out.println("No handler can handle the request.");
            }
        }
    };

    /**
     * 定义了一个名为 nextHandler 的 protected 属性
     */
    protected HandlerTypeEnum nextHandler;

    /**
     * 用于设置 nextHandler 属性的值
     */
    public void setNextHandler(HandlerTypeEnum nextHandler) {
        this.nextHandler = nextHandler;
    }

    /**
     * 用于处理请求
     *
     * @param request
     */
    public abstract void handleRequest(String request);

}

class ChainOfResponsibilityTest {
    public static void main(String[] args) {
        // 设置处理器的顺序
        HandlerTypeEnum.TYPE1.setNextHandler(HandlerTypeEnum.TYPE2);
        HandlerTypeEnum.TYPE2.setNextHandler(HandlerTypeEnum.TYPE3);
        // 依次处理不同类型的请求，并输出处理结果
        HandlerTypeEnum.TYPE1.handleRequest("Request type 1");
        HandlerTypeEnum.TYPE1.handleRequest("Request type 2");
        HandlerTypeEnum.TYPE1.handleRequest("Request type 3");
        HandlerTypeEnum.TYPE1.handleRequest("Unknown request");
    }
}