diff --git a/README.md b/README.md
index 6e35455d1ab..16f3a960975 100644
--- a/README.md
+++ b/README.md
@@ -139,5 +139,49 @@
 
 - 객체지향의 5원칙
 - SOLID
-- stream, record가 뭔지.
-- exception
+
+---
+
+## 두번째 사이클
+
+#### 미션 중 기록
+
+- 기능 추가로 인해 수정한 위치 개수
+    - main(9개) test(4개)
+
+- 사이클1 때보다 수정 범위가 줄었는가/늘었는가
+    - 수정 범위가 준 것 같습니다. 도메인에서 관리하던 string format들을 view에서 관리할 수 있도록 했습니다.
+    - 각 도메인들이 해야할 책임들을 잘 분배한 것 같습니다.
+
+- 규칙 적용으로 변경한 코드 1곳
+    - 이것은 생각이 좀 필요합니다.
+
+- 테스트가 설계를 도운 순간 1회
+    - 기능을 변경하면서 처음 테스트 코드를 생성한 곳은 BettingMoneyTest입니다.
+    - 당장 뭐부터 해야할 지 설계가 막막할 때 1000이하의 숫자를 입력해선 안된다는 규칙읋 세워 적용하였더니 수월하게 설계를 할 수 있었습니다.
+
+### 베팅 기능 추가 시 기능 요구사항
+
+- 겜블러들은 베팅을 할 수 있다.
+- 딜러와 견주어 승리 시 배팅금액의 1배 이다.
+- 블랙잭으로 승리 시 배팅금액의 1.5배 이다.
+- 버스트나 패배 시 배팅금액의 -1배 이다.
+- 무승부 시 수익은 0이 된다.
+- 최소 배팅 금액은 1000 이다.
+- 손해는 -로 표시한다. ex) -10000
+- 딜러의 수익은 **-(모든 겜블러들의 총 수익)** 이다.
+
+### 추가 도메인
+
+- **BettingMoney**
+- [x] 사용자가 0이나 음수를 입력하면 [ERROR] 메세지를 보낸다.
+- [x] 단위는 1000단위로 한다.
+
+- **MatchResult**
+- [x] 승/패/무 에 따라 수익률이 정해진다
+
+- **Gambler**
+- [x] 자신의 배팅 금액을 가진다.
+- [x] 자신의 수익 구한다.
+
+
diff --git a/src/main/java/BlackJack.java b/src/main/java/BlackJack.java
index 15625ae9b90..295d7a3881e 100644
--- a/src/main/java/BlackJack.java
+++ b/src/main/java/BlackJack.java
@@ -1,8 +1,10 @@
+import domain.BettingMoney;
 import domain.deck.Deck;
 import domain.deck.StandardDeck;
 import domain.player.Dealer;
 import domain.player.Gambler;
 import domain.player.Gamblers;
+import java.util.ArrayList;
 import java.util.List;
 import parser.AnswerParser;
 import parser.PlayerNameParser;
@@ -20,7 +22,7 @@ public BlackJack() {
 
     public void start() {
         Dealer dealer = new Dealer();
-        Gamblers gamblers = new Gamblers(getPlayerNames());
+        Gamblers gamblers = new Gamblers(createGambler());
 
         initialDeal(dealer, gamblers);
         printInitialDealInfo(dealer, gamblers);
@@ -36,6 +38,17 @@ private List<String> getPlayerNames() {
         return PlayerNameParser.splitNames(InputView.readLine());
     }
 
+    private List<Gambler> createGambler() {
+        List<Gambler> gamblers = new ArrayList<>();
+        List<String> names = getPlayerNames();
+        for (String name : names) {
+            OutputView.requestBettingMoney(name);
+            int money = Integer.parseInt(InputView.readLine());
+            gamblers.add(new Gambler(name, new BettingMoney(money)));
+        }
+        return gamblers;
+    }
+
     private void initialDeal(Dealer dealer, Gamblers gamblers) {
         for (int i = 0; i < INITIAL_CARD_COUNT; i++) {
             dealer.deal(deck);
@@ -46,16 +59,17 @@ private void initialDeal(Dealer dealer, Gamblers gamblers) {
     private void printInitialDealInfo(Dealer dealer, Gamblers gamblers) {
         OutputView.printInitMessage(gamblers.getNames());
         OutputView.printDealerFirstCard(dealer.getFirstCard());
-
         for (Gambler gambler : gamblers.getGamblers()) {
             OutputView.printPlayerCards(gambler);
         }
+        OutputView.addNewLine();
     }
 
     private void gamblersTurn(Gamblers gamblers) {
         for (Gambler gambler : gamblers.getGamblers()) {
             gamblerTurn(gambler);
         }
+        OutputView.addNewLine();
     }
 
     private void gamblerTurn(Gambler gambler) {
@@ -63,16 +77,16 @@ private void gamblerTurn(Gambler gambler) {
             OutputView.askHit(gambler.getName());
             boolean answer = AnswerParser.parse(InputView.readLine());
             if (!answer) {
+                OutputView.printPlayerCards(gambler);
                 break;
             }
 
             gambler.deal(deck);
-
+            OutputView.printPlayerCards(gambler);
             if (gambler.isBust()) {
                 OutputView.printPlayerBust(gambler.getName());
                 break;
             }
-            OutputView.printPlayerCards(gambler);
         }
     }
 
@@ -97,6 +111,7 @@ private void printFinalPlayerInfo(Dealer dealer, Gamblers gamblers) {
 
     private void printFinalResult(Dealer dealer, Gamblers gamblers) {
         OutputView.printFinalResultHeader();
-        OutputView.printResult(gamblers.getResult(dealer));
+        int dealerFinalIncome = gamblers.dealerFinalIncome(dealer);
+        OutputView.printResult(gamblers.getResult(dealer), dealerFinalIncome);
     }
 }
diff --git a/src/main/java/domain/BettingMoney.java b/src/main/java/domain/BettingMoney.java
new file mode 100644
index 00000000000..56a5efa20e3
--- /dev/null
+++ b/src/main/java/domain/BettingMoney.java
@@ -0,0 +1,30 @@
+package domain;
+
+import exception.BlackjackException;
+import exception.ExceptionMessage;
+
+public class BettingMoney {
+    private final int money;
+
+    public BettingMoney(int money) {
+        validateMoney(money);
+        validateMoneyUnit(money);
+        this.money = money;
+    }
+
+    private void validateMoneyUnit(int money) {
+        if (money % 100 != 0) {
+            throw new BlackjackException(ExceptionMessage.MONEY_UNIT_ERROR);
+        }
+    }
+
+    private void validateMoney(int money) {
+        if (money < 1000) {
+            throw new BlackjackException(ExceptionMessage.MONEY_INPUT_ERROR);
+        }
+    }
+
+    public int getMoney() {
+        return this.money;
+    }
+}
diff --git a/src/main/java/domain/MatchResult.java b/src/main/java/domain/MatchResult.java
index be20880d821..a6f33f5a154 100644
--- a/src/main/java/domain/MatchResult.java
+++ b/src/main/java/domain/MatchResult.java
@@ -1,17 +1,24 @@
 package domain;
 
 public enum MatchResult {
-    WIN("승"),
-    LOSE("패"),
-    DRAW("무");
+    BLACKJACK("블랙잭", 1.5),
+    WIN("승", 1.0),
+    LOSE("패", -1.0),
+    DRAW("무", 0.0);
 
     private final String name;
+    private final double ratio;
 
-    MatchResult(String name) {
+    MatchResult(String name, double ratio) {
         this.name = name;
+        this.ratio = ratio;
     }
 
     public String getName() {
         return name;
     }
+
+    public int calculateIncome(BettingMoney bettingMoney) {
+        return (int) (this.ratio * bettingMoney.getMoney());
+    }
 }
diff --git a/src/main/java/domain/deck/StandardDeck.java b/src/main/java/domain/deck/StandardDeck.java
index 24fbc831237..5bb4045c512 100644
--- a/src/main/java/domain/deck/StandardDeck.java
+++ b/src/main/java/domain/deck/StandardDeck.java
@@ -3,8 +3,8 @@
 import domain.card.Card;
 import domain.card.CardRank;
 import domain.card.CardSuit;
-import expcetion.BlackjackException;
-import expcetion.ExceptionMessage;
+import exception.BlackjackException;
+import exception.ExceptionMessage;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
diff --git a/src/main/java/domain/player/Gambler.java b/src/main/java/domain/player/Gambler.java
index 34ef5ce09c1..4c77dc3fe78 100644
--- a/src/main/java/domain/player/Gambler.java
+++ b/src/main/java/domain/player/Gambler.java
@@ -1,9 +1,10 @@
 package domain.player;
 
+import domain.BettingMoney;
 import domain.MatchResult;
 import domain.card.Card;
-import expcetion.BlackjackException;
-import expcetion.ExceptionMessage;
+import exception.BlackjackException;
+import exception.ExceptionMessage;
 import java.util.List;
 
 public class Gambler extends Player {
@@ -13,14 +14,15 @@ public class Gambler extends Player {
     private static final String RESULT_FORMAT = "%s:%s";
 
     private final String name;
+    private final BettingMoney bettingMoney;
 
-    public Gambler(String name) {
+    public Gambler(String name, BettingMoney bettingMoney) {
         super();
+        this.bettingMoney = bettingMoney;
         validate(name);
         this.name = name;
     }
 
-
     private void validate(String name) {
         validateContainsNumber(name);
         validateLength(name);
@@ -51,6 +53,11 @@ public MatchResult getResult(Dealer dealer) {
         return MatchResult.DRAW;
     }
 
+    public int calculateFinalIncome(Dealer dealer) {
+        MatchResult matchResult = getResult(dealer);
+        return matchResult.calculateIncome(this.bettingMoney);
+    }
+
     private int normalize(int score) {
         if (score > BLACKJACK_MAX_LIMIT) {
             return 0;
@@ -58,11 +65,6 @@ private int normalize(int score) {
         return score;
     }
 
-
-    public String showResult(MatchResult result) {
-        return String.format(RESULT_FORMAT, name, result.getName());
-    }
-
     public String getName() {
         return name;
     }
diff --git a/src/main/java/domain/player/Gamblers.java b/src/main/java/domain/player/Gamblers.java
index 9c6d33eca80..95abb51f84c 100644
--- a/src/main/java/domain/player/Gamblers.java
+++ b/src/main/java/domain/player/Gamblers.java
@@ -1,35 +1,33 @@
 package domain.player;
 
-import domain.MatchResult;
 import domain.deck.Deck;
-import dto.BlackjackResult;
-import expcetion.BlackjackException;
-import expcetion.ExceptionMessage;
-import java.util.ArrayList;
+import exception.BlackjackException;
+import exception.ExceptionMessage;
 import java.util.HashSet;
+import java.util.LinkedHashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 
 public class Gamblers {
     private final List<Gambler> gamblers;
 
-    public Gamblers(List<String> names) {
-        validateNonDuplicate(names);
-        gamblers = new ArrayList<>();
-        init(names);
+    public Gamblers(List<Gambler> gamblers) {
+        validateNonDuplicateNames(gamblers);
+        this.gamblers = gamblers;
     }
 
-    private void validateNonDuplicate(List<String> names) {
-        Set<String> namesSet = new HashSet<>(names);
-        if (namesSet.size() != names.size()) {
+    private void validateNonDuplicateNames(List<Gambler> gamblers) {
+        List<String> names = gamblers.stream()
+                .map(Gambler::getName)
+                .toList();
+
+        Set<String> targetNames = new HashSet<>(names);
+        if (targetNames.size() != names.size()) {
             throw new BlackjackException(ExceptionMessage.INPUT_ERROR);
         }
     }
 
-    private void init(List<String> names) {
-        names.stream().map(Gambler::new).forEach(gamblers::add);
-    }
-
     public List<Gambler> getGamblers() {
         return gamblers;
     }
@@ -38,21 +36,22 @@ public void dealAll(Deck deck) {
         gamblers.forEach(gambler -> gambler.deal(deck));
     }
 
-    public BlackjackResult getResult(Dealer dealer) {
-        int winCount = 0;
-        int loseCount = 0;
-        List<String> logs = new ArrayList<>();
+    public Map<String, Integer> getResult(Dealer dealer) {
+        Map<String, Integer> gamblersResult = new LinkedHashMap<>();
+        for (Gambler gambler : gamblers) {
+            String name = gambler.getName();
+            int finalIncomeMoney = gambler.calculateFinalIncome(dealer);
+            gamblersResult.put(name, finalIncomeMoney);
+        }
+        return gamblersResult;
+    }
+
+    public int dealerFinalIncome(Dealer dealer) {
+        int dealerFinalIncome = 0;
         for (Gambler gambler : gamblers) {
-            MatchResult result = gambler.getResult(dealer);
-            if (result == MatchResult.WIN) {
-                loseCount++;
-            }
-            if (result == MatchResult.LOSE) {
-                winCount++;
-            }
-            logs.add(gambler.showResult(result));
+            dealerFinalIncome += gambler.calculateFinalIncome(dealer);
         }
-        return new BlackjackResult(winCount, loseCount, gamblers.size() - winCount - loseCount, logs);
+        return dealerFinalIncome * -1;
     }
 
     public List<String> getNames() {
diff --git a/src/main/java/expcetion/BlackjackException.java b/src/main/java/exception/BlackjackException.java
similarity index 89%
rename from src/main/java/expcetion/BlackjackException.java
rename to src/main/java/exception/BlackjackException.java
index 6524c3c42a7..092fe163b4b 100644
--- a/src/main/java/expcetion/BlackjackException.java
+++ b/src/main/java/exception/BlackjackException.java
@@ -1,4 +1,4 @@
-package expcetion;
+package exception;
 
 public class BlackjackException extends IllegalArgumentException {
 
diff --git a/src/main/java/expcetion/ExceptionMessage.java b/src/main/java/exception/ExceptionMessage.java
similarity index 54%
rename from src/main/java/expcetion/ExceptionMessage.java
rename to src/main/java/exception/ExceptionMessage.java
index 55d899861ce..81eb451b8a3 100644
--- a/src/main/java/expcetion/ExceptionMessage.java
+++ b/src/main/java/exception/ExceptionMessage.java
@@ -1,8 +1,10 @@
-package expcetion;
+package exception;
 
 public enum ExceptionMessage {
     EMPTY_CARD_DECK("[ERROR] 카드가 모두 소진되었습니다."),
-    INPUT_ERROR("[ERROR] 잘못된 입력입니다.");
+    INPUT_ERROR("[ERROR] 잘못된 입력입니다."),
+    MONEY_INPUT_ERROR("[ERROR] 1000 이상의 숫자를 입력해주시기 바랍니다."),
+    MONEY_UNIT_ERROR("[ERROR] 돈의 단위는 100입니다.");
 
     private final String message;
 
diff --git a/src/main/java/parser/AnswerParser.java b/src/main/java/parser/AnswerParser.java
index 5c420e9b480..70ae7b265a8 100644
--- a/src/main/java/parser/AnswerParser.java
+++ b/src/main/java/parser/AnswerParser.java
@@ -1,7 +1,7 @@
 package parser;
 
-import expcetion.BlackjackException;
-import expcetion.ExceptionMessage;
+import exception.BlackjackException;
+import exception.ExceptionMessage;
 
 public class AnswerParser {
     private AnswerParser() {
diff --git a/src/main/java/view/InputView.java b/src/main/java/view/InputView.java
index d6d6d65b4c1..2a0002554c7 100644
--- a/src/main/java/view/InputView.java
+++ b/src/main/java/view/InputView.java
@@ -1,7 +1,7 @@
 package view;
 
-import expcetion.BlackjackException;
-import expcetion.ExceptionMessage;
+import exception.BlackjackException;
+import exception.ExceptionMessage;
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStreamReader;
@@ -19,4 +19,4 @@ public static String readLine() {
             throw new BlackjackException(ExceptionMessage.INPUT_ERROR);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/main/java/view/OutputView.java b/src/main/java/view/OutputView.java
index 6c6ab7b6522..27fe2668d0b 100644
--- a/src/main/java/view/OutputView.java
+++ b/src/main/java/view/OutputView.java
@@ -3,8 +3,8 @@
 import domain.card.Card;
 import domain.player.Dealer;
 import domain.player.Gambler;
-import dto.BlackjackResult;
 import java.util.List;
+import java.util.Map;
 import java.util.stream.Collectors;
 
 public class OutputView {
@@ -22,12 +22,12 @@ public static void printInitMessage(List<String> names) {
     }
 
     public static void printDealerFirstCard(Card card) {
-        System.out.println("딜러카드: " + formatCard(card));
+        System.out.println("딜러: " + formatCard(card));
     }
 
     public static void printPlayerCards(Gambler gambler) {
         String gamblerCards = formatCards(gambler.getCardInfo());
-        System.out.println(gambler.getName() + " " + gamblerCards);
+        System.out.println(gambler.getName() + "카드: " + gamblerCards);
     }
 
     public static void printPlayerBust(String name) {
@@ -39,7 +39,7 @@ public static void askHit(String name) {
     }
 
     public static void printDealerHit() {
-        System.out.println("딜러는 16이하라 한장의 카드를 더 받았습니다.");
+        System.out.println("딜러는 16이하라 한장의 카드를 더 받았습니다.\n");
     }
 
     public static void printFinalDealer(Dealer dealer, int score) {
@@ -53,13 +53,15 @@ public static void printFinalPlayer(Gambler gambler) {
 
     public static void printFinalResultHeader() {
         System.out.println();
-        System.out.println("## 최종 승패");
+        System.out.println("## 최종 수익");
     }
 
-    public static void printResult(BlackjackResult result) {
-        System.out.println("딜러: " + result.winCount() + "승 " + result.lossCount() + "패 " + result.drawCount() + "무");
-        for (String gamblerResult : result.logs()) {
-            System.out.println(gamblerResult);
+    public static void printResult(Map<String, Integer> result, int dealerFinalIncome) {
+        System.out.printf("딜러: %d%n", dealerFinalIncome);
+        for (Map.Entry<String, Integer> entry : result.entrySet()) {
+            String name = entry.getKey();
+            Integer gamblerFinalIncome = entry.getValue();
+            System.out.println(name + ": " + gamblerFinalIncome);
         }
     }
 
@@ -74,4 +76,12 @@ private static String formatCards(List<Card> cards) {
                 .map(OutputView::formatCard)
                 .collect(Collectors.joining(", "));
     }
+
+    public static void requestBettingMoney(String name) {
+        System.out.printf("%n%s의 배팅 금액은?%n", name);
+    }
+
+    public static void addNewLine() {
+        System.out.println();
+    }
 }
diff --git a/src/test/java/domain/BettingMoneyTest.java b/src/test/java/domain/BettingMoneyTest.java
new file mode 100644
index 00000000000..18b736b059f
--- /dev/null
+++ b/src/test/java/domain/BettingMoneyTest.java
@@ -0,0 +1,44 @@
+package domain;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import exception.BlackjackException;
+import exception.ExceptionMessage;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+public class BettingMoneyTest {
+
+    @ParameterizedTest
+    @ValueSource(ints = {999, 0, -999, -2000})
+    @DisplayName("1000 미만 숫자 입력 시 오류발생")
+    void 숫자1000_미만_숫자_입력_시_오류발생(int invalidMoney) {
+        //when & then
+        assertThatThrownBy(() -> new BettingMoney(invalidMoney))
+                .isInstanceOf(BlackjackException.class)
+                .hasMessageContaining(ExceptionMessage.MONEY_INPUT_ERROR.message());
+    }
+
+    @ParameterizedTest
+    @ValueSource(ints = {1000, 2000, 10000})
+    @DisplayName("1000 이상 숫자 입력 시 정상작동")
+    void 숫자1000_이상_입력_시_정상(int validMoney) {
+        //when
+        BettingMoney bettingMoney = new BettingMoney(validMoney);
+
+        //then
+        assertThat(bettingMoney.getMoney()).isEqualTo(validMoney);
+    }
+
+    @Test
+    @DisplayName("돈의 단위는 100으로 한다.")
+    void 단위는_1000이다() {
+        // when & then
+        assertThatThrownBy(() -> new BettingMoney(1020))
+                .isInstanceOf(BlackjackException.class)
+                .hasMessageContaining(ExceptionMessage.MONEY_UNIT_ERROR.message());
+    }
+}
diff --git a/src/test/java/domain/HandCardTest.java b/src/test/java/domain/HandCardTest.java
index e2b34d2c718..3d36e3172ff 100644
--- a/src/test/java/domain/HandCardTest.java
+++ b/src/test/java/domain/HandCardTest.java
@@ -33,5 +33,4 @@ public class HandCardTest {
         //then
         assertThat(result).isEqualTo(21);
     }
-
 }
diff --git a/src/test/java/domain/MatchResultTest.java b/src/test/java/domain/MatchResultTest.java
new file mode 100644
index 00000000000..2540f817e71
--- /dev/null
+++ b/src/test/java/domain/MatchResultTest.java
@@ -0,0 +1,60 @@
+package domain;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+class MatchResultTest {
+    @Test
+    @DisplayName("승리 시 배팅금액의 1배")
+    void 승리_시_수익() {
+        //given
+        BettingMoney bettingMoney = new BettingMoney(1000);
+
+        //when
+        int winMoney = MatchResult.WIN.calculateIncome(bettingMoney);
+
+        //then
+        assertThat(winMoney).isEqualTo(1000);
+    }
+
+    @Test
+    @DisplayName("패배 시 배팅금액의 -1배")
+    void 패배_시_수익() {
+        //given
+        BettingMoney bettingMoney = new BettingMoney(1000);
+
+        //when
+        int loseMoney = MatchResult.LOSE.calculateIncome(bettingMoney);
+
+        //then
+        assertThat(loseMoney).isEqualTo(-1000);
+    }
+
+    @Test
+    @DisplayName("무승부 시 0")
+    void 무승부_시_금액() {
+        //given
+        BettingMoney bettingMoney = new BettingMoney(1000);
+
+        //when
+        int drawMoney = MatchResult.DRAW.calculateIncome(bettingMoney);
+
+        //then
+        assertThat(drawMoney).isEqualTo(0);
+    }
+
+    @Test
+    @DisplayName("블랙잭 시 배팅금액의 1.5배")
+    void 블랙잭_시_수익() {
+        //given
+        BettingMoney bettingMoney = new BettingMoney(1000);
+
+        //when
+        int blackJackMoney = MatchResult.BLACKJACK.calculateIncome(bettingMoney);
+
+        //then
+        assertThat(blackJackMoney).isEqualTo(1500);
+    }
+}
diff --git a/src/test/java/domain/player/DealerTest.java b/src/test/java/domain/player/DealerTest.java
index deea8b499f0..8f043178854 100644
--- a/src/test/java/domain/player/DealerTest.java
+++ b/src/test/java/domain/player/DealerTest.java
@@ -12,13 +12,12 @@
 import org.junit.jupiter.api.Test;
 
 public class DealerTest {
-
     @Test
     @DisplayName("처음 출력할 때 1장만 나오게 함")
     void 딜러는_처음_출력_때_1장만_나오게_함() {
         //given
-        Card five = new Card(CardRank.FIVE, CardSuit.CLOVER); // 5
-        Card ten = new Card(CardRank.TEN, CardSuit.CLOVER); // 10
+        Card five = new Card(CardRank.FIVE, CardSuit.CLOVER);
+        Card ten = new Card(CardRank.TEN, CardSuit.DIAMOND);
         FixedDeck sd = new FixedDeck(List.of(five, ten));
 
         Dealer dealer = new Dealer();
@@ -26,19 +25,20 @@ public class DealerTest {
         dealer.deal(sd);
 
         //when
-        String startPrintResult = dealer.getFirstCardInfo();
+        Card card = dealer.getFirstCard();
 
         //then
-        assertThat(startPrintResult).isEqualTo("5클로버");
+        assertThat(card.getCardRank()).isEqualTo(CardRank.FIVE);
+        assertThat(card.getCardSuit()).isEqualTo(CardSuit.CLOVER);
     }
 
     @Test
     @DisplayName("딜러는 16이하 강제 히트")
     void 딜러는_16이하_강제_히트() {
         //given
-        Card jack = new Card(CardRank.JACK, CardSuit.CLOVER); // 10
-        Card five = new Card(CardRank.FIVE, CardSuit.CLOVER); // 5
-        Card ten = new Card(CardRank.TEN, CardSuit.CLOVER); // 10
+        Card jack = new Card(CardRank.JACK, CardSuit.CLOVER);
+        Card five = new Card(CardRank.FIVE, CardSuit.CLOVER);
+        Card ten = new Card(CardRank.TEN, CardSuit.CLOVER);
         FixedDeck sd = new FixedDeck(List.of(jack, five, ten));
 
         Dealer dealer = new Dealer();
@@ -49,7 +49,6 @@ public class DealerTest {
         boolean canStand = dealer.canStand();
 
         //then
-        assertThat(canStand).isFalse(); // 딜러가 16을 넘어 멈출 수 있는가?
+        assertThat(canStand).isFalse();
     }
-
 }
diff --git a/src/test/java/domain/player/GamblerTest.java b/src/test/java/domain/player/GamblerTest.java
index 6ec5a8df33f..091250b4a97 100644
--- a/src/test/java/domain/player/GamblerTest.java
+++ b/src/test/java/domain/player/GamblerTest.java
@@ -3,17 +3,23 @@
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
+import domain.BettingMoney;
 import domain.FixedDeck;
 import domain.MatchResult;
 import domain.card.Card;
 import domain.card.CardRank;
 import domain.card.CardSuit;
-import expcetion.BlackjackException;
+import domain.deck.Deck;
+import exception.BlackjackException;
 import java.util.List;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 
 class GamblerTest {
+    private Gambler createGambler(String name) {
+        return new Gambler(name, new BettingMoney(1000));
+    }
+
     @Test
     @DisplayName("이름이 숫자면 안된다.")
     void 이름이_숫자일_시() {
@@ -21,7 +27,7 @@ class GamblerTest {
         String name = "121345";
 
         //when & then
-        assertThatThrownBy(() -> new Gambler(name))
+        assertThatThrownBy(() -> createGambler(name))
                 .isInstanceOf(BlackjackException.class);
     }
 
@@ -32,9 +38,9 @@ class GamblerTest {
         String max_range_name = "tobiisverygoob";
         String min_range_name = "h";
         //when & then
-        assertThatThrownBy(() -> new Gambler(max_range_name))
+        assertThatThrownBy(() -> createGambler(max_range_name))
                 .isInstanceOf(BlackjackException.class);
-        assertThatThrownBy(() -> new Gambler(min_range_name))
+        assertThatThrownBy(() -> createGambler(min_range_name))
                 .isInstanceOf(BlackjackException.class);
     }
 
@@ -43,8 +49,8 @@ class GamblerTest {
     void 승리_정상_판정() {
         //given
         Dealer dealer = new Dealer();
-        Gambler tobi = new Gambler("tobi");
-        Gambler quda = new Gambler("quda");
+        Gambler tobi = createGambler("tobi");
+        Gambler quda = createGambler("quda");
 
         Card jack = new Card(CardRank.JACK, CardSuit.CLOVER); // 딜러
         Card eight = new Card(CardRank.EIGHT, CardSuit.DIAMOND); // tobi
@@ -63,4 +69,35 @@ class GamblerTest {
         assertThat(tobiResult).isEqualTo(MatchResult.LOSE);
         assertThat(qudaResult).isEqualTo(MatchResult.DRAW);
     }
+
+    @Test
+    @DisplayName("승리 시 배팅금액")
+    void 승리_시_배팅금액() {
+        //given
+        BettingMoney bettingMoney = new BettingMoney(1000);
+        Dealer dealer = new Dealer();
+        Gambler pobi = new Gambler("pobi", bettingMoney);
+
+        Card ten = new Card(CardRank.TEN, CardSuit.CLOVER);
+        Card eight = new Card(CardRank.EIGHT, CardSuit.CLOVER);
+        Card nine = new Card(CardRank.NINE, CardSuit.CLOVER);
+        Card seven = new Card(CardRank.SEVEN, CardSuit.CLOVER);
+
+        List<Card> pobiCards = List.of(ten, eight);
+        List<Card> dealerCards = List.of(nine, seven);
+
+        Deck pobiDeck = new FixedDeck(pobiCards);
+        Deck dealerDeck = new FixedDeck(dealerCards);
+
+        pobi.deal(pobiDeck);
+        dealer.deal(dealerDeck);
+        pobi.deal(pobiDeck);
+        dealer.deal(dealerDeck);
+
+        //when
+        int finalIncome = pobi.calculateFinalIncome(dealer);
+
+        //then
+        assertThat(finalIncome).isEqualTo(1000);
+    }
 }
diff --git a/src/test/java/domain/player/GamblersTest.java b/src/test/java/domain/player/GamblersTest.java
index 7bb01e59cb6..872ea0cf2cc 100644
--- a/src/test/java/domain/player/GamblersTest.java
+++ b/src/test/java/domain/player/GamblersTest.java
@@ -3,14 +3,14 @@
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
+import domain.BettingMoney;
 import domain.FixedDeck;
 import domain.card.Card;
 import domain.card.CardRank;
 import domain.card.CardSuit;
-import dto.BlackjackResult;
-import expcetion.BlackjackException;
-import java.util.ArrayList;
+import exception.BlackjackException;
 import java.util.List;
+import java.util.Map;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 
@@ -20,10 +20,12 @@ class GamblersTest {
     @DisplayName("이름이 중복되면 안된다.")
     void 이름이_중복될_시() {
         //given
-        List<String> names = new ArrayList<>(List.of("tobi", "tobi"));
+        Gambler tobiOriginal = new Gambler("tobi", new BettingMoney(1000));
+        Gambler tobiFake = new Gambler("tobi", new BettingMoney(1000));
+        List<Gambler> gamblers = List.of(tobiOriginal, tobiFake);
 
         //when & then
-        assertThatThrownBy(() -> new Gamblers(names))
+        assertThatThrownBy(() -> new Gamblers(gamblers))
                 .isInstanceOf(BlackjackException.class);
     }
 
@@ -32,7 +34,10 @@ class GamblersTest {
     void 딜러와_사용자_승패결과_도출() {
         //given
         Dealer dealer = new Dealer();
-        Gamblers gamblers = new Gamblers(List.of("tobi", "quda")); // 사용자 두명
+        Gambler tobi = new Gambler("tobi", new BettingMoney(1000));
+        Gambler quda = new Gambler("quda", new BettingMoney(1000));
+
+        Gamblers gamblers = new Gamblers(List.of(tobi, quda));// 사용자 두명
 
         Card jack = new Card(CardRank.JACK, CardSuit.CLOVER); // 딜러
         Card eight = new Card(CardRank.EIGHT, CardSuit.DIAMOND); // tobi
@@ -41,20 +46,19 @@ class GamblersTest {
         Card sevenClover = new Card(CardRank.SEVEN, CardSuit.CLOVER); // tobi
         Card nine = new Card(CardRank.NINE, CardSuit.DIAMOND); // quda
 
-        FixedDeck sd = new FixedDeck(List.of(jack, eight, ten, sevenDiamond, sevenClover, nine));
-        dealer.deal(sd);
-        gamblers.dealAll(sd);
-        dealer.deal(sd);
-        gamblers.dealAll(sd);
+        FixedDeck fixedDeck = new FixedDeck(List.of(jack, eight, ten, sevenDiamond, sevenClover, nine));
+        dealer.deal(fixedDeck);
+        gamblers.dealAll(fixedDeck);
+        dealer.deal(fixedDeck);
+        gamblers.dealAll(fixedDeck);
 
         //when
-        BlackjackResult result = gamblers.getResult(dealer);
+        Map<String, Integer> result = gamblers.getResult(dealer);
 
         //then
-        assertThat(result.winCount()).isEqualTo(1);
-        assertThat(result.lossCount()).isEqualTo(1);
-        assertThat(result.drawCount()).isEqualTo(0);
-        assertThat(result.logs().get(0)).isEqualTo("tobi:패");
-        assertThat(result.logs().get(1)).isEqualTo("quda:승");
+        assertThat(result)
+                .hasSize(2)
+                .containsEntry("tobi", -1000)
+                .containsEntry("quda", 1000);
     }
 }