如何创建变量/属性实现向多个方法传递相同参数以避免代码重复？

当然有办法解决这个重复传参的麻烦！结合你的场景（每个方法要实例化独特的XML backing实例，没法合并），给你几个实用的方案，挑适合你的就行：

方案1：用函数映射表替代switch #

你可以把每个account对应的方法提前存到一个映射表（比如字典/哈希表）里，然后通过account值直接取出方法，再一次性传入参数。这样不仅消除了重复的参数列表，还让代码更简洁易维护。

拿Java举例，先定义一个匹配参数的函数式接口，再构建映射关系：

// 定义一个和你的方法参数、返回值匹配的函数式接口
@FunctionalInterface
interface AccountHandler {
    Account handle(String name, String address, String location, String accountID, Business business);
}

// 构建account到方法的映射
Map<String, AccountHandler> accountMethodMap = new HashMap<>();
accountMethodMap.put("25", this::getAccount25);
accountMethodMap.put("26", this::getAccount26);
accountMethodMap.put("27", this::getAccount27);
accountMethodMap.put("28", this::getAccount28);
accountMethodMap.put("29", this::getAccount29);

// 调用的时候只需要一行
AccountHandler handler = accountMethodMap.get(account);
if (handler != null) {
    handler.handle(name, address, location, accountID, business);
}

如果是JavaScript/TypeScript的话会更简单，直接用对象字面量存方法引用就行：

const accountMethods = {
    "25": getAccount25,
    "26": getAccount26,
    "27": getAccount27,
    "28": getAccount28,
    "29": getAccount29
};

const method = accountMethods[account];
if (method) {
    method(name, address, location, accountID, business);
}

方案2：把参数封装成单独的对象 #

如果参数列表很长，或者以后可能增减参数，把所有参数打包成一个对象是更优雅的选择。这样每个方法只需要接收这个对象作为参数，调用时也只需要传一次。

还是拿Java举例：

// 先创建一个参数类，把所有需要的参数都封装进去
class AccountRequestParams {
    private String name;
    private String address;
    private String location;
    private String accountID;
    private Business business;

    // 构造函数、getter/setter按需实现
    public AccountRequestParams(String name, String address, String location, String accountID, Business business) {
        this.name = name;
        this.address = address;
        this.location = location;
        this.accountID = accountID;
        this.business = business;
    }

    // getter方法...
}

// 把你的方法都改成接收这个参数类
private Account getAccount25(AccountRequestParams params) {
    // 内部用params.getName()等获取参数
    // 实例化独特的XML backing instance
}

// 调用的时候先创建参数对象，再传入
AccountRequestParams params = new AccountRequestParams(name, address, location, accountID, business);
switch(account){
 case "25": getAccount25(params); break;
 case "26": getAccount26(params); break;
 case "27": getAccount27(params); break;
 case "28": getAccount28(params); break;
 case "29": getAccount29(params); break;
}

这个方案的好处是，以后如果要加参数，只需要修改AccountRequestParams类，不用逐个修改所有方法的参数列表，维护成本低很多。

方案3：反射调用（仅作参考，不推荐） #

如果你的语言支持反射（比如Java、Python），可以通过拼接方法名的方式动态调用。但这个方案有明显缺点：编译期无法检查方法是否存在，运行时可能抛出异常，性能也不如直接调用。除非你有特殊需求，否则不建议用。

Java示例：

try {
    // 根据account拼接方法名
    Method method = this.getClass().getMethod("getAccount" + account, 
        String.class, String.class, String.class, String.class, Business.class);
    // 调用方法
    method.invoke(this, name, address, location, accountID, business);
} catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
    // 处理找不到方法、权限等异常
    e.printStackTrace();
}

总结一下，方案1和方案2都是更安全、易维护的选择：如果不想新增类，选方案1；如果参数可能变化或者想让代码更整洁，选方案2。

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