Blackjack游戏开发：主类传参至其他类函数及金额计算问题求助

方案1：自定义结果类封装多返回值 #

Java方法仅能返回单个值，你可以创建一个自定义类，将胜负提示信息与更新后的金额打包返回，这样就能同时获取两个结果，再将金额传递给payment函数。这种方式可读性强、结构清晰，是最优方案。

示例代码：

package project1;

// 自定义结果类，封装胜负消息和更新后的金额
class GameResult {
    private final String message;
    private final int updatedMoney;

    public GameResult(String message, int updatedMoney) {
        this.message = message;
        this.updatedMoney = updatedMoney;
    }

    // Getter方法
    public String getMessage() {
        return message;
    }

    public int getUpdatedMoney() {
        return updatedMoney;
    }
}

public class RestultsNPayment {
    public static GameResult determineWinner(int Dtotal, int Ptotal, int money, int bet) {
        if (Ptotal > 21) {
            // 玩家爆牌，输掉赌注
            return new GameResult("--------Dealer wins--------", money - bet);
        } else if (Ptotal == Dtotal) {
            // 平局，金额不变
            return new GameResult("------------Tie------------", money);
        } else {
            boolean dealerWins = (21 - Ptotal > 21 - Dtotal) && Dtotal < 22;
            if (dealerWins) {
                // 庄家获胜，玩家输掉赌注
                return new GameResult("--------Dealer wins--------", money - bet);
            } else {
                // 玩家获胜，赢得等额赌注
                return new GameResult("--------Player wins--------", money + bet);
            }
        }
    }

    public static int payment(int updatedMoney) {
        // 这里可添加后续金额处理逻辑，比如返回最终可支配金额
        return updatedMoney;
    }

    // 调用示例
    public static void main(String[] args) {
        GameResult result = determineWinner(18, 20, 100, 20);
        System.out.println(result.getMessage());
        int finalMoney = payment(result.getUpdatedMoney());
        System.out.println("当前金额：" + finalMoney);
    }
}

方案2：拆分函数职责，分离胜负判断与金额计算 #

将胜负判断和金额计算的逻辑拆分：让一个函数只返回胜负类型（用枚举定义），另一个函数根据胜负类型、原始金额和赌注计算更新后的金额。这种方式符合单一职责原则，代码更易维护。

示例代码：

package project1;

// 定义胜负结果枚举
enum GameOutcome {
    DEALER_WINS, PLAYER_WINS, TIE
}

public class RestultsNPayment {
    public static GameOutcome getGameOutcome(int Dtotal, int Ptotal) {
        if (Ptotal > 21) {
            return GameOutcome.DEALER_WINS;
        } else if (Ptotal == Dtotal) {
            return GameOutcome.TIE;
        } else {
            boolean dealerWins = (21 - Ptotal > 21 - Dtotal) && Dtotal < 22;
            return dealerWins ? GameOutcome.DEALER_WINS : GameOutcome.PLAYER_WINS;
        }
    }

    public static int calculateUpdatedMoney(int money, int bet, GameOutcome outcome) {
        return switch (outcome) {
            case DEALER_WINS -> money - bet;
            case PLAYER_WINS -> money + bet;
            case TIE -> money;
        };
    }

    // 调用示例
    public static void main(String[] args) {
        GameOutcome outcome = getGameOutcome(18, 20);
        int updatedMoney = calculateUpdatedMoney(100, 20, outcome);
        
        // 根据胜负结果输出对应提示
        String message = switch (outcome) {
            case DEALER_WINS -> "--------Dealer wins--------";
            case PLAYER_WINS -> "--------Player wins--------";
            case TIE -> "------------Tie------------";
        };
        
        System.out.println(message);
        System.out.println("当前金额：" + updatedMoney);
    }
}

方案3：使用数组传递更新后的金额（不推荐） #

可以用一个长度为1的int数组作为参数，在判断胜负的函数中修改数组元素来传递更新后的金额，同时返回胜负提示。这种方式虽然能解决问题，但可读性差，容易引发误解，仅作为临时替代方案。

示例代码：

package project1;

public class RestultsNPayment {
    public static String winner(int Dtotal, int Ptotal, int money, int bet, int[] updatedMoneyHolder) {
        if (Ptotal > 21) {
            updatedMoneyHolder[0] = money - bet;
            return "--------Dealer wins--------";
        } else if (Ptotal == Dtotal) {
            updatedMoneyHolder[0] = money;
            return "------------Tie------------";
        } else {
            boolean dealerWins = (21 - Ptotal > 21 - Dtotal) && Dtotal < 22;
            if (dealerWins) {
                updatedMoneyHolder[0] = money - bet;
                return "--------Dealer wins--------";
            } else {
                updatedMoneyHolder[0] = money + bet;
                return "--------Player wins--------";
            }
        }
    }

    public static int payment(int updatedMoney) {
        return updatedMoney;
    }

    // 调用示例
    public static void main(String[] args) {
        int[] updatedMoneyHolder = new int[1];
        String message = winner(18, 20, 100, 20, updatedMoneyHolder);
        System.out.println(message);
        int finalMoney = payment(updatedMoneyHolder[0]);
        System.out.println("当前金额：" + finalMoney);
    }
}

你的思路可行性验证 #

你想在胜负判断函数中计算更新后的金额，再传入payment函数的思路完全可行。方案1和方案3都能实现这个需求，其中方案1是最规范、易维护的实现方式，强烈推荐使用。

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