如何根据枚举值创建对象并为各枚举值执行不同方法

嘿，针对你这个需求，其实有两种常用的实现方式，我给你详细说说～

一、最直接的switch分支实现 #

这应该就是你一开始想到的思路，直接在构造方法里通过switch判断枚举值，然后调用对应的处理方法，代码清晰直观，适合简单场景：

public class Foo {
    public enum Bar {FooBar, BarFoo, FooFoo, BarBar}

    public Foo(Bar bar) {
        switch (bar) {
            case FooBar:
                handleFooBar();
                break;
            case BarFoo:
                handleBarFoo();
                break;
            case FooFoo:
                handleFooFoo();
                break;
            case BarBar:
                handleBarBar();
                break;
            default:
                // 防止新增枚举值时遗漏处理
                throw new IllegalArgumentException("未知的Bar枚举值: " + bar);
        }
    }

    private void handleFooBar() {
        // 这里写FooBar对应的专属操作逻辑
        System.out.println("处理FooBar的业务逻辑");
    }

    private void handleBarFoo() {
        // BarFoo对应的操作逻辑
        System.out.println("处理BarFoo的业务逻辑");
    }

    private void handleFooFoo() {
        // FooFoo对应的操作逻辑
        System.out.println("处理FooFoo的业务逻辑");
    }

    private void handleBarBar() {
        // BarBar对应的操作逻辑
        System.out.println("处理BarBar的业务逻辑");
    }
}

这种方式的优点是上手快，代码容易理解；但缺点也很明显——如果后续新增枚举值，很容易忘记在switch里添加对应的case分支，维护起来容易出问题。

二、更优雅的枚举自带行为（推荐） #

这是更符合面向对象思想的方式：让每个枚举值自己携带对应的行为，给枚举定义一个抽象方法，每个枚举实例实现自己的版本。这样行为和枚举值绑定，新增枚举值时必须实现对应的方法，不会遗漏：

public class Foo {
    public enum Bar {
        FooBar {
            @Override
            public void execute() {
                // FooBar专属的操作逻辑
                System.out.println("执行FooBar的专属业务逻辑");
            }
        },
        BarFoo {
            @Override
            public void execute() {
                // BarFoo专属的操作逻辑
                System.out.println("执行BarFoo的专属业务逻辑");
            }
        },
        FooFoo {
            @Override
            public void execute() {
                // FooFoo专属的操作逻辑
                System.out.println("执行FooFoo的专属业务逻辑");
            }
        },
        BarBar {
            @Override
            public void execute() {
                // BarBar专属的操作逻辑
                System.out.println("执行BarBar的专属业务逻辑");
            }
        };

        // 定义抽象方法，每个枚举值必须实现
        public abstract void execute();
    }

    public Foo(Bar bar) {
        // 直接调用枚举自带的execute方法即可
        bar.execute();
    }
}

如果需要给处理方法传递参数（比如Foo的实例或者其他业务参数），只需要修改抽象方法的签名就行：

public enum Bar {
    FooBar {
        @Override
        public void execute(Foo fooInstance, String extraParam) {
            // 可以直接使用传入的参数
            System.out.println("FooBar处理，关联Foo实例: " + fooInstance + "，额外参数: " + extraParam);
        }
    },
    // 其他枚举值同理实现...

    public abstract void execute(Foo fooInstance, String extraParam);
}

// 构造方法里调用时传入参数
public Foo(Bar bar) {
    bar.execute(this, "自定义参数");
}

这种方式遵循开闭原则，后续新增枚举值时，只需要在枚举里添加新的实例并实现execute方法，不需要修改其他代码，维护起来更省心。

总结 #

• 简单场景、枚举值很少变动：用switch分支快速实现
• 复杂场景、枚举值可能新增或变动：优先用枚举自带行为的方式，代码更内聚、更易维护

内容的提问来源于stack exchange，提问作者MazeOfEncryption