diff --git a/README.md b/README.md
index 43ef453f1ce..21afe05dff0 100644
--- a/README.md
+++ b/README.md
@@ -23,15 +23,21 @@ pobi카드: 2하트, 8스페이드, A클로버
 1) 딜러와 각 플레이어의 카드 수령 결과를 출력한다.
 2) 딜러 카드의 합이 16이하인 경우, 카드 수령 메시지를 출력한다.
 3) 딜러와 플레이어의 수령한 카드와 카드의 합을 출력한다.
-4) 최종 승패 여부를 출력한다.
+4) 최종 수익을 출력한다.
 
 ### ▫ 실행 예시
 ```plaintext
 게임에 참여할 사람의 이름을 입력하세요.(쉼표 기준으로 분리)
 pobi,jason
 
+pobi의 배팅 금액은?
+10000
+
+jason의 배팅 금액은?
+20000
+
 딜러와 pobi, jason에게 2장을 나누었습니다.
-딜러카드: 3다이아몬드
+딜러: 3다이아몬드
 pobi카드: 2하트, 8스페이드
 jason카드: 7클로버, K스페이드
 
@@ -40,20 +46,21 @@ y
 pobi카드: 2하트, 8스페이드, A클로버
 pobi는 한장의 카드를 더 받겠습니까?(예는 y, 아니오는 n)
 n
-jason는 한장의 카드를 더 받겠습니까?(예는 y, 아니오는 n)
+pobi카드: 2하트, 8스페이드, A클로버
+jason은 한장의 카드를 더 받겠습니까?(예는 y, 아니오는 n)
 n
 jason카드: 7클로버, K스페이드
 
 딜러는 16이하라 한장의 카드를 더 받았습니다.
 
-딜러카드: 3다이아몬드, 9클로버, 8다이아몬드 - 결과: 20
+딜러 카드: 3다이아몬드, 9클로버, 8다이아몬드 - 결과: 20
 pobi카드: 2하트, 8스페이드, A클로버 - 결과: 21
 jason카드: 7클로버, K스페이드 - 결과: 17
 
-## 최종 승패
-딜러: 1승 1패
-pobi: 승 
-jason: 패
+## 최종 수익
+딜러: 10000
+pobi: 10000 
+jason: -20000
 ```
 
 ---
@@ -68,4 +75,7 @@ jason: 패
 7) 뽑힌 카드 제외하는 기능
 8) 카드 덱 만들어서 섞기
 9) 승패 여부 계산기능
-10) 딜러의 두번째 카드를 숨기는 기능
\ No newline at end of file
+10) 딜러의 두번째 카드를 숨기는 기능
+11) 배팅 금액을 관리하는 기능
+12) 블랙잭 여부 판정기능
+13) 최종 수익 계산 기능
\ No newline at end of file
diff --git a/src/main/java/controller/GameController.java b/src/main/java/controller/GameController.java
index 6c099a8fba0..99f9d598571 100644
--- a/src/main/java/controller/GameController.java
+++ b/src/main/java/controller/GameController.java
@@ -1,34 +1,69 @@
 package controller;
 
 import domain.BlackjackGame;
-import domain.Dealer;
-import domain.GameResultCalculator;
-import domain.Player;
-import domain.Players;
-import domain.TotalFinalResult;
-import dto.DealerFinalResultDto;
+import domain.participant.BettingMoney;
+import domain.participant.Dealer;
+import domain.participant.Name;
+import domain.participant.Player;
+import domain.participant.PlayerCreationInfo;
+import domain.participant.Players;
+import domain.ProfitCalculator;
 import dto.PlayerDto;
 import dto.PlayersDto;
 import dto.ResultDto;
-import dto.TotalFinalResultsDto;
 import view.InputView;
 import view.OutputView;
 
+import java.util.ArrayList;
+import java.util.List;
+
 public class GameController {
 
     public void run() {
-        BlackjackGame blackjackGame = BlackjackGame.start(InputView.readParticipants());
+        BlackjackGame blackjackGame = startGame();
+        printInitialStatus(blackjackGame);
+        playGame(blackjackGame);
+        printGameResult(blackjackGame);
+    }
+
+    private BlackjackGame startGame() {
+        List<String> names = InputView.readParticipants();
+        List<PlayerCreationInfo> playerCreationInfos = createPlayerCreationInfos(names);
+        return BlackjackGame.start(playerCreationInfos);
+    }
+
+    private void printInitialStatus(BlackjackGame blackjackGame) {
         Dealer dealer = blackjackGame.getDealer();
         Players players = blackjackGame.getPlayers();
-
         PlayersDto playersDto = PlayersDto.from(players);
+
         OutputView.printHandOutMessage(playersDto);
         OutputView.printCardStatus(playersDto, ResultDto.fromDealerInitial(dealer));
+    }
 
+    private void playGame(BlackjackGame blackjackGame) {
+        Players players = blackjackGame.getPlayers();
         addPlayersCard(blackjackGame, players);
         addDealerCards(blackjackGame);
-        printCardResults(ResultDto.from(dealer), PlayersDto.from(players));
-        printFinalResults(players, dealer);
+    }
+
+    private void printGameResult(BlackjackGame blackjackGame) {
+        Dealer dealer = blackjackGame.getDealer();
+        Players players = blackjackGame.getPlayers();
+        PlayersDto afterPlayersDto = PlayersDto.from(players);
+
+        printCardResults(ResultDto.from(dealer), afterPlayersDto);
+        printProfitResults(players, dealer);
+    }
+
+    private List<PlayerCreationInfo> createPlayerCreationInfos(List<String> names) {
+        List<PlayerCreationInfo> playerCreationInfos = new ArrayList<>();
+        for (String name : names) {
+            Integer money = InputView.readBettingMoney(name);
+            System.out.println();
+            playerCreationInfos.add(PlayerCreationInfo.of(Name.from(name), BettingMoney.of(money)));
+        }
+        return playerCreationInfos;
     }
 
     private void addPlayersCard(BlackjackGame blackjackGame, Players players) {
@@ -51,15 +86,23 @@ private void addDealerCards(BlackjackGame blackjackGame) {
         }
     }
 
-    private void printCardResults(ResultDto resultDto, PlayersDto playersDto) {
-        OutputView.printCardResult(resultDto, playersDto);
+    private void printCardResults(ResultDto resultDto, PlayersDto afterPlayersDto) {
+        OutputView.printCardResult(resultDto, afterPlayersDto);
     }
 
-    private void printFinalResults(Players players, Dealer dealer) {
-        TotalFinalResult totalFinalResult = GameResultCalculator.checkGameResult(players, dealer);
-        DealerFinalResultDto dealerFinalResultDto = DealerFinalResultDto.from(totalFinalResult);
-        TotalFinalResultsDto totalFinalResultsDto = TotalFinalResultsDto.from(totalFinalResult);
+    private void printProfitResults(Players players, Dealer dealer) {
+        String dealerProfit = ProfitCalculator.formatProfit(
+                ProfitCalculator.calculateDealerProfit(players, dealer)
+        );
+
+        List<String> playerProfitResults = players.getPlayers().stream()
+                .map(player -> String.format("%s: %s%n",
+                        player.getNameValue(),
+                        ProfitCalculator.formatProfit(
+                                ProfitCalculator.calculatePlayerProfit(player, dealer)
+                        )))
+                .toList();
 
-        OutputView.printTotalResult(dealerFinalResultDto, totalFinalResultsDto);
+        OutputView.printTotalProfit(dealerProfit, playerProfitResults);
     }
 }
diff --git a/src/main/java/domain/BlackjackGame.java b/src/main/java/domain/BlackjackGame.java
index 0111fab8444..3df439b7d58 100644
--- a/src/main/java/domain/BlackjackGame.java
+++ b/src/main/java/domain/BlackjackGame.java
@@ -1,5 +1,10 @@
 package domain;
 
+import domain.card.Card;
+import domain.card.Deck;
+import domain.hand.Hand;
+import domain.participant.*;
+
 import java.util.ArrayList;
 import java.util.List;
 
@@ -14,13 +19,13 @@ private BlackjackGame(Deck deck, GameParticipants participants) {
         this.participants = participants;
     }
 
-    public static BlackjackGame start(List<String> names) {
-        return start(names, Deck.createDeck());
+    public static BlackjackGame start(List<PlayerCreationInfo> playerCreationInfos) {
+        return start(playerCreationInfos, Deck.createDeck());
     }
 
-    public static BlackjackGame start(List<String> names, Deck deck) {
+    public static BlackjackGame start(List<PlayerCreationInfo> playerCreationInfos, Deck deck) {
         Dealer dealer = Dealer.from(new Hand(initCards(deck)));
-        Players players = createPlayers(names, deck);
+        Players players = createPlayers(playerCreationInfos, deck);
         return new BlackjackGame(deck, GameParticipants.of(dealer, players));
     }
 
@@ -29,7 +34,7 @@ public void addPlayerCard(Player player) {
     }
 
     public boolean playDealerTurn() {
-        if (cannotDealerDraw()) {
+        if (participants.cannotDealerDraw()) {
             return false;
         }
         drawDealerCards();
@@ -44,8 +49,8 @@ public Players getPlayers() {
         return participants.getPlayers();
     }
 
-    private boolean cannotDealerDraw() {
-        return participants.isAllPlayersBust() || !getDealer().checkThreshold();
+    public List<Player> getPlayersValue() {
+        return participants.getPlayers().getPlayers();
     }
 
     private void drawDealerCards() {
@@ -54,16 +59,20 @@ private void drawDealerCards() {
         }
     }
 
-    private static Players createPlayers(List<String> names, Deck deck) {
+    private static Players createPlayers(List<PlayerCreationInfo> playerCreationInfos, Deck deck) {
         List<Player> players = new ArrayList<>();
-        for (String name : names) {
-            players.add(createPlayer(name, deck));
+        for (PlayerCreationInfo playerCreationInfo : playerCreationInfos) {
+            players.add(createPlayer(playerCreationInfo, deck));
         }
         return Players.from(players);
     }
 
-    private static Player createPlayer(String name, Deck deck) {
-        return Player.of(Name.from(name), new Hand(initCards(deck)));
+    private static Player createPlayer(PlayerCreationInfo playerCreationInfo, Deck deck) {
+        return Player.of(
+                playerCreationInfo.getName(),
+                new Hand(initCards(deck)),
+                playerCreationInfo.getBettingMoney()
+        );
     }
 
     private static List<Card> initCards(Deck deck) {
@@ -73,4 +82,4 @@ private static List<Card> initCards(Deck deck) {
         }
         return cards;
     }
-}
\ No newline at end of file
+}
diff --git a/src/main/java/domain/FinalResult.java b/src/main/java/domain/FinalResult.java
deleted file mode 100644
index 0292c6b43d5..00000000000
--- a/src/main/java/domain/FinalResult.java
+++ /dev/null
@@ -1,31 +0,0 @@
-package domain;
-
-public class FinalResult {
-    private final Name name;
-    private final ResultType resultType;
-
-    private FinalResult(Name name, ResultType resultType) {
-        this.name = name;
-        this.resultType = resultType;
-    }
-
-    public static FinalResult from(Name name, ResultType resultType) {
-        return new FinalResult(name, resultType);
-    }
-
-    public Name getName() {
-        return name;
-    }
-
-    public ResultType getResultType() {
-        return resultType;
-    }
-
-    public String getNameText() {
-        return name.getName();
-    }
-
-    public String getResultText() {
-        return resultType.getType();
-    }
-}
\ No newline at end of file
diff --git a/src/main/java/domain/GameResultCalculator.java b/src/main/java/domain/GameResultCalculator.java
deleted file mode 100644
index bb35b23a513..00000000000
--- a/src/main/java/domain/GameResultCalculator.java
+++ /dev/null
@@ -1,24 +0,0 @@
-package domain;
-
-public class GameResultCalculator {
-    public static TotalFinalResult checkGameResult(Players players, Dealer dealer) {
-        return TotalFinalResult.from(players.getPlayers().stream()
-                .map(player -> checkFinalResult(player, dealer))
-                .toList());
-    }
-
-    private static FinalResult checkFinalResult(Player player, Dealer dealer) {
-        return FinalResult.from(player.getName(),
-                getResultType(player.getScore(), dealer.getScore()));
-    }
-
-    private static ResultType getResultType(Score playerScore, Score dealerScore) {
-        if (playerScore.isBust() || (playerScore.value() < dealerScore.value() && !dealerScore.isBust())) {
-            return ResultType.LOSE;
-        }
-        if (dealerScore.isBust() || playerScore.value() > dealerScore.value()) {
-            return ResultType.WIN;
-        }
-        return ResultType.DRAW;
-    }
-}
diff --git a/src/main/java/domain/Player.java b/src/main/java/domain/Player.java
deleted file mode 100644
index 0e3c40fa39e..00000000000
--- a/src/main/java/domain/Player.java
+++ /dev/null
@@ -1,23 +0,0 @@
-package domain;
-
-
-public class Player extends Participant {
-    private final Name name;
-
-    private Player(Name name, Hand hand) {
-        super(hand);
-        this.name = name;
-    }
-
-    public static Player of(Name name, Hand hand) {
-        return new Player(name, hand);
-    }
-
-    public Name getName() {
-        return name;
-    }
-
-    public String getNameValue() {
-        return name.getName();
-    }
-}
diff --git a/src/main/java/domain/ProfitCalculator.java b/src/main/java/domain/ProfitCalculator.java
new file mode 100644
index 00000000000..a0219d891d6
--- /dev/null
+++ b/src/main/java/domain/ProfitCalculator.java
@@ -0,0 +1,51 @@
+package domain;
+
+import domain.participant.Dealer;
+import domain.participant.Player;
+import domain.participant.Players;
+
+public class ProfitCalculator {
+    private static final double BLACKJACK_PROFIT_RATE = 1.5;
+
+    public static double calculatePlayerProfit(Player player, Dealer dealer) {
+        int bettingMoney = player.getBettingMoneyValue();
+        int playerScore = player.getScoreValue();
+        int dealerScore = dealer.getScoreValue();
+
+        if (player.isBlackjack() && dealer.isBlackjack()) {
+            return 0;
+        }
+        if (player.isBlackjack()) {
+            return bettingMoney * BLACKJACK_PROFIT_RATE;
+        }
+        if (dealer.isBlackjack()) {
+            return -bettingMoney;
+        }
+        if (player.isBust()) {
+            return -bettingMoney;
+        }
+        if (dealer.isBust()) {
+            return bettingMoney;
+        }
+        if (playerScore > dealerScore) {
+            return bettingMoney;
+        }
+        if (playerScore < dealerScore) {
+            return -bettingMoney;
+        }
+        return 0;
+    }
+
+    public static double calculateDealerProfit(Players players, Dealer dealer) {
+        return -players.getPlayers().stream()
+                .mapToDouble(player -> calculatePlayerProfit(player, dealer))
+                .sum();
+    }
+
+    public static String formatProfit(double profit) {
+        if (profit == (long) profit) {
+            return String.valueOf((long) profit);
+        }
+        return String.valueOf(profit);
+    }
+}
diff --git a/src/main/java/domain/ResultType.java b/src/main/java/domain/ResultType.java
deleted file mode 100644
index fbc2e701327..00000000000
--- a/src/main/java/domain/ResultType.java
+++ /dev/null
@@ -1,17 +0,0 @@
-package domain;
-
-public enum ResultType {
-    WIN("승"),
-    DRAW("무"),
-    LOSE("패");
-
-    private final String type;
-
-    ResultType(String type) {
-        this.type = type;
-    }
-
-    public String getType() {
-        return type;
-    }
-}
diff --git a/src/main/java/domain/TotalFinalResult.java b/src/main/java/domain/TotalFinalResult.java
deleted file mode 100644
index 2862e0caa43..00000000000
--- a/src/main/java/domain/TotalFinalResult.java
+++ /dev/null
@@ -1,19 +0,0 @@
-package domain;
-
-import java.util.List;
-
-public class TotalFinalResult {
-    private final List<FinalResult> totalResult;
-
-    private TotalFinalResult(List<FinalResult> totalResult) {
-        this.totalResult = totalResult;
-    }
-
-    public static TotalFinalResult from(List<FinalResult> totalResult) {
-        return new TotalFinalResult(totalResult);
-    }
-
-    public List<FinalResult> getTotalResult() {
-        return totalResult;
-    }
-}
diff --git a/src/main/java/domain/Card.java b/src/main/java/domain/card/Card.java
similarity index 96%
rename from src/main/java/domain/Card.java
rename to src/main/java/domain/card/Card.java
index 75ceb65f3c8..e01e18088ff 100644
--- a/src/main/java/domain/Card.java
+++ b/src/main/java/domain/card/Card.java
@@ -1,4 +1,4 @@
-package domain;
+package domain.card;
 
 public class Card {
     private final CardNumber cardNumber;
diff --git a/src/main/java/domain/CardNumber.java b/src/main/java/domain/card/CardNumber.java
similarity index 96%
rename from src/main/java/domain/CardNumber.java
rename to src/main/java/domain/card/CardNumber.java
index f03d4561b06..d46c7b0a078 100644
--- a/src/main/java/domain/CardNumber.java
+++ b/src/main/java/domain/card/CardNumber.java
@@ -1,4 +1,4 @@
-package domain;
+package domain.card;
 
 public enum CardNumber {
     ACE("A", 1),
diff --git a/src/main/java/domain/CardShape.java b/src/main/java/domain/card/CardShape.java
similarity index 93%
rename from src/main/java/domain/CardShape.java
rename to src/main/java/domain/card/CardShape.java
index 98a12af1f05..63ab0d87bab 100644
--- a/src/main/java/domain/CardShape.java
+++ b/src/main/java/domain/card/CardShape.java
@@ -1,4 +1,4 @@
-package domain;
+package domain.card;
 
 public enum CardShape {
     HEART("하트"),
diff --git a/src/main/java/domain/Deck.java b/src/main/java/domain/card/Deck.java
similarity index 98%
rename from src/main/java/domain/Deck.java
rename to src/main/java/domain/card/Deck.java
index 94b144384aa..4d36f8cde1b 100644
--- a/src/main/java/domain/Deck.java
+++ b/src/main/java/domain/card/Deck.java
@@ -1,4 +1,4 @@
-package domain;
+package domain.card;
 
 import java.util.ArrayList;
 import java.util.Collections;
diff --git a/src/main/java/domain/Hand.java b/src/main/java/domain/hand/Hand.java
similarity index 77%
rename from src/main/java/domain/Hand.java
rename to src/main/java/domain/hand/Hand.java
index ae15e8b6b0d..da8164476bc 100644
--- a/src/main/java/domain/Hand.java
+++ b/src/main/java/domain/hand/Hand.java
@@ -1,4 +1,6 @@
-package domain;
+package domain.hand;
+
+import domain.card.Card;
 
 import java.util.List;
 
@@ -25,4 +27,8 @@ public boolean hasScoreLessThanOrEqual(int value) {
         return getScore().value() <= value;
     }
 
+    public boolean isBlackjack(){
+        return cards.size() == 2 && getScore().value()==21;
+    }
+
 }
diff --git a/src/main/java/domain/Score.java b/src/main/java/domain/hand/Score.java
similarity index 88%
rename from src/main/java/domain/Score.java
rename to src/main/java/domain/hand/Score.java
index 6737c751c29..9fa613baf4d 100644
--- a/src/main/java/domain/Score.java
+++ b/src/main/java/domain/hand/Score.java
@@ -1,4 +1,4 @@
-package domain;
+package domain.hand;
 
 public record Score(int value) {
     private static final int BUST_LIMIT_SCORE = 21;
diff --git a/src/main/java/domain/ScoreCalculator.java b/src/main/java/domain/hand/ScoreCalculator.java
similarity index 93%
rename from src/main/java/domain/ScoreCalculator.java
rename to src/main/java/domain/hand/ScoreCalculator.java
index db553277cab..8e88d3c3248 100644
--- a/src/main/java/domain/ScoreCalculator.java
+++ b/src/main/java/domain/hand/ScoreCalculator.java
@@ -1,4 +1,7 @@
-package domain;
+package domain.hand;
+
+import domain.card.Card;
+import domain.card.CardNumber;
 
 import java.util.List;
 
diff --git a/src/main/java/domain/participant/BettingMoney.java b/src/main/java/domain/participant/BettingMoney.java
new file mode 100644
index 00000000000..e30e8d76418
--- /dev/null
+++ b/src/main/java/domain/participant/BettingMoney.java
@@ -0,0 +1,24 @@
+package domain.participant;
+
+public class BettingMoney {
+    private final int money;
+
+    private BettingMoney(int money) {
+        validate(money);
+        this.money = money;
+    }
+
+    public static BettingMoney of(int money){
+        return new BettingMoney(money);
+    }
+
+    private void validate(int money){
+        if(money<=0){
+            throw new IllegalArgumentException("배팅 금액은 0보다 커야 합니다.");
+        }
+    }
+
+    public int getMoney(){
+        return money;
+    }
+}
diff --git a/src/main/java/domain/Dealer.java b/src/main/java/domain/participant/Dealer.java
similarity index 87%
rename from src/main/java/domain/Dealer.java
rename to src/main/java/domain/participant/Dealer.java
index 6665a387d2a..92f2303de4d 100644
--- a/src/main/java/domain/Dealer.java
+++ b/src/main/java/domain/participant/Dealer.java
@@ -1,4 +1,6 @@
-package domain;
+package domain.participant;
+
+import domain.hand.Hand;
 
 public class Dealer extends Participant {
     private static final int DEALER_CARD_SUM_THRESHOLD = 16;
diff --git a/src/main/java/domain/GameParticipants.java b/src/main/java/domain/participant/GameParticipants.java
similarity index 78%
rename from src/main/java/domain/GameParticipants.java
rename to src/main/java/domain/participant/GameParticipants.java
index 37a7bfb9a13..41e16656933 100644
--- a/src/main/java/domain/GameParticipants.java
+++ b/src/main/java/domain/participant/GameParticipants.java
@@ -1,4 +1,4 @@
-package domain;
+package domain.participant;
 
 public class GameParticipants {
     private final Dealer dealer;
@@ -21,7 +21,7 @@ public Players getPlayers() {
         return players;
     }
 
-    public boolean isAllPlayersBust() {
-        return players.isAllBust();
+    public boolean cannotDealerDraw() {
+        return players.isAllBust() || !dealer.checkThreshold();
     }
-}
\ No newline at end of file
+}
diff --git a/src/main/java/domain/Name.java b/src/main/java/domain/participant/Name.java
similarity index 97%
rename from src/main/java/domain/Name.java
rename to src/main/java/domain/participant/Name.java
index 07408b954dc..11c484f4110 100644
--- a/src/main/java/domain/Name.java
+++ b/src/main/java/domain/participant/Name.java
@@ -1,4 +1,4 @@
-package domain;
+package domain.participant;
 
 public class Name {
     private static final int NAME_LIMIT_LENGTH = 20;
diff --git a/src/main/java/domain/Participant.java b/src/main/java/domain/participant/Participant.java
similarity index 71%
rename from src/main/java/domain/Participant.java
rename to src/main/java/domain/participant/Participant.java
index ef612f92e09..2b5c24d8931 100644
--- a/src/main/java/domain/Participant.java
+++ b/src/main/java/domain/participant/Participant.java
@@ -1,4 +1,7 @@
-package domain;
+package domain.participant;
+
+import domain.hand.Hand;
+import domain.card.Card;
 
 import java.util.List;
 
@@ -13,9 +16,7 @@ public List<Card> getHandCards() {
         return hand.getCards();
     }
 
-    public Hand getHand() {
-        return hand;
-    }
+    protected Hand getHand() {return hand;}
 
     public void addHandCard(Card card) {
         hand.addCard(card);
@@ -25,11 +26,12 @@ public boolean isBust() {
         return hand.getScore().isBust();
     }
 
-    public Score getScore() {
-        return hand.getScore();
-    }
-
     public int getScoreValue() {
         return hand.getScore().value();
     }
+
+    public boolean isBlackjack(){
+        return hand.isBlackjack();
+    }
+
 }
diff --git a/src/main/java/domain/participant/Player.java b/src/main/java/domain/participant/Player.java
new file mode 100644
index 00000000000..b22093e8a43
--- /dev/null
+++ b/src/main/java/domain/participant/Player.java
@@ -0,0 +1,30 @@
+package domain.participant;
+
+
+import domain.hand.Hand;
+
+public class Player extends Participant {
+    private final Name name;
+    private final BettingMoney bettingMoney;
+    private Player(Name name, Hand hand , BettingMoney bettingMoney) {
+        super(hand);
+        this.name = name;
+        this.bettingMoney = bettingMoney;
+    }
+
+    public static Player of(Name name, Hand hand, BettingMoney bettingMoney) {
+        return new Player(name, hand, bettingMoney);
+    }
+
+    public Name getName() {
+        return name;
+    }
+
+    public String getNameValue() {
+        return name.getName();
+    }
+
+    public int getBettingMoneyValue(){
+        return bettingMoney.getMoney();
+    }
+}
diff --git a/src/main/java/domain/participant/PlayerCreationInfo.java b/src/main/java/domain/participant/PlayerCreationInfo.java
new file mode 100644
index 00000000000..bf59436e789
--- /dev/null
+++ b/src/main/java/domain/participant/PlayerCreationInfo.java
@@ -0,0 +1,24 @@
+package domain.participant;
+
+public class PlayerCreationInfo {
+    private final Name name;
+    private final BettingMoney bettingMoney;
+
+    private PlayerCreationInfo(Name name, BettingMoney bettingMoney){
+        this.name = name;
+        this.bettingMoney = bettingMoney;
+    }
+
+    public static PlayerCreationInfo of(Name name, BettingMoney bettingMoney){
+        return new PlayerCreationInfo(name, bettingMoney);
+    }
+
+    public Name getName(){
+        return name;
+    }
+
+    public BettingMoney getBettingMoney(){
+        return bettingMoney;
+    }
+
+}
diff --git a/src/main/java/domain/Players.java b/src/main/java/domain/participant/Players.java
similarity index 94%
rename from src/main/java/domain/Players.java
rename to src/main/java/domain/participant/Players.java
index 3efb19c5cdf..6cc17d6f020 100644
--- a/src/main/java/domain/Players.java
+++ b/src/main/java/domain/participant/Players.java
@@ -1,4 +1,4 @@
-package domain;
+package domain.participant;
 
 import java.util.List;
 
diff --git a/src/main/java/dto/DealerFinalResultDto.java b/src/main/java/dto/DealerFinalResultDto.java
deleted file mode 100644
index 80dc466c433..00000000000
--- a/src/main/java/dto/DealerFinalResultDto.java
+++ /dev/null
@@ -1,27 +0,0 @@
-package dto;
-
-import domain.ResultType;
-import domain.TotalFinalResult;
-
-public record DealerFinalResultDto(
-        String result
-) {
-    public static DealerFinalResultDto from(TotalFinalResult totalFinalResult) {
-        return new DealerFinalResultDto(checkDrawCount(countResult(totalFinalResult, ResultType.LOSE),
-                countResult(totalFinalResult, ResultType.DRAW),
-                countResult(totalFinalResult, ResultType.WIN)));
-    }
-
-    private static int countResult(TotalFinalResult totalFinalResult, ResultType resultType) {
-        return (int) totalFinalResult.getTotalResult().stream()
-                .filter(finalResult -> finalResult.getResultType().equals(resultType))
-                .count();
-    }
-
-    private static String checkDrawCount(int winCount, int drawCount, int loseCount) {
-        if (drawCount > 0) {
-            return String.format("딜러: %d승 %d무 %d패%n", winCount, drawCount, loseCount);
-        }
-        return String.format("딜러: %d승 %d패%n", winCount, loseCount);
-    }
-}
diff --git a/src/main/java/dto/PlayerDto.java b/src/main/java/dto/PlayerDto.java
index 466c62c1a98..d83b17be39a 100644
--- a/src/main/java/dto/PlayerDto.java
+++ b/src/main/java/dto/PlayerDto.java
@@ -1,6 +1,6 @@
 package dto;
 
-import domain.Player;
+import domain.participant.Player;
 
 public record PlayerDto(
         String name,
diff --git a/src/main/java/dto/PlayersDto.java b/src/main/java/dto/PlayersDto.java
index c62a3e5269e..5b468210524 100644
--- a/src/main/java/dto/PlayersDto.java
+++ b/src/main/java/dto/PlayersDto.java
@@ -1,6 +1,6 @@
 package dto;
 
-import domain.Players;
+import domain.participant.Players;
 
 import java.util.List;
 
diff --git a/src/main/java/dto/ResultDto.java b/src/main/java/dto/ResultDto.java
index 84df7101270..b7184b1f65e 100644
--- a/src/main/java/dto/ResultDto.java
+++ b/src/main/java/dto/ResultDto.java
@@ -1,8 +1,8 @@
 package dto;
 
-import domain.Card;
-import domain.Dealer;
-import domain.Participant;
+import domain.card.Card;
+import domain.participant.Dealer;
+import domain.participant.Participant;
 
 import java.util.List;
 
diff --git a/src/main/java/dto/TotalFinalResultsDto.java b/src/main/java/dto/TotalFinalResultsDto.java
deleted file mode 100644
index 0ad8bcf1a9d..00000000000
--- a/src/main/java/dto/TotalFinalResultsDto.java
+++ /dev/null
@@ -1,23 +0,0 @@
-package dto;
-
-import domain.FinalResult;
-import domain.TotalFinalResult;
-
-import java.util.ArrayList;
-import java.util.List;
-
-public record TotalFinalResultsDto(
-        List<String> totalResults
-) {
-    public static TotalFinalResultsDto from(TotalFinalResult totalFinalResult) {
-        List<FinalResult> finalResults = totalFinalResult.getTotalResult();
-        List<String> totalResults = new ArrayList<>();
-        for (FinalResult finalResult : finalResults) {
-            totalResults.add(String.format("%s: %s%n",
-                    finalResult.getNameText(),
-                    finalResult.getResultText()));
-        }
-
-        return new TotalFinalResultsDto(totalResults);
-    }
-}
diff --git a/src/main/java/view/InputView.java b/src/main/java/view/InputView.java
index f2e7af0632e..a85bac2c79d 100644
--- a/src/main/java/view/InputView.java
+++ b/src/main/java/view/InputView.java
@@ -10,11 +10,18 @@ public class InputView {
 
     public static List<String> readParticipants() {
         System.out.println("게임에 참여할 사람의 이름을 입력하세요.(쉼표 기준으로 분리)");
-        return NameParser.parse(scanner.nextLine());
+        String input = scanner.nextLine();
+        System.out.println();
+        return NameParser.parse(input);
     }
 
     public static boolean checkAddCard(String name) {
         System.out.printf("%s는 한장의 카드를 더 받겠습니까?(예는 y, 아니오는 n)%n", name);
         return scanner.nextLine().equalsIgnoreCase("y");
     }
+
+    public static Integer readBettingMoney(String name){
+        System.out.printf("%s의 배팅 금액은?%n",name);
+        return Integer.parseInt(scanner.nextLine());
+    }
 }
diff --git a/src/main/java/view/OutputView.java b/src/main/java/view/OutputView.java
index f98069db45c..090d3d00592 100644
--- a/src/main/java/view/OutputView.java
+++ b/src/main/java/view/OutputView.java
@@ -1,11 +1,8 @@
 package view;
 
-import dto.DealerFinalResultDto;
 import dto.PlayerDto;
 import dto.PlayersDto;
 import dto.ResultDto;
-import dto.TotalFinalResultsDto;
-
 import java.util.List;
 import java.util.stream.Collectors;
 
@@ -15,7 +12,7 @@ public static void printHandOutMessage(PlayersDto playersDto) {
                 .map(PlayerDto::name)
                 .collect(Collectors.joining(","));
 
-        System.out.print("\n딜러와 " + playersName + "에게 2장을 나누었습니다.");
+        System.out.print("딜러와 " + playersName + "에게 2장을 나누었습니다.");
     }
 
     public static void printDealerCardStatus(ResultDto resultDto) {
@@ -65,12 +62,11 @@ private static void printPlayerCardResult(PlayerDto playerDto) {
                 playerDto.resultDto().score());
     }
 
-    public static void printTotalResult(DealerFinalResultDto dealerFinalResultDto,
-                                        TotalFinalResultsDto totalFinalResultsDto) {
-        System.out.println("\n\n## 최종 승패");
-        System.out.print(dealerFinalResultDto.result());
-        for (String finalResult : totalFinalResultsDto.totalResults()) {
-            System.out.print(finalResult);
+    public static void printTotalProfit(String dealerProfit, List<String> playerProfitResults) {
+        System.out.println("\n\n## 최종 수익");
+        System.out.printf("딜러: %s%n", dealerProfit);
+        for (String playerProfitResult : playerProfitResults) {
+            System.out.print(playerProfitResult);
         }
     }
 }
diff --git a/src/test/java/domain/BettingMoneyTest.java b/src/test/java/domain/BettingMoneyTest.java
new file mode 100644
index 00000000000..ed9429855c6
--- /dev/null
+++ b/src/test/java/domain/BettingMoneyTest.java
@@ -0,0 +1,24 @@
+package domain;
+
+import domain.participant.BettingMoney;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+public class BettingMoneyTest {
+
+    @Test
+    void 베팅금액을_생성할_수_있다(){
+        BettingMoney bettingMoney = BettingMoney.of(1000);
+        assertThat(bettingMoney.getMoney()).isEqualTo(1000);
+    }
+
+    @Test
+    void 베팅금액이_0이하면_예외가_발생한다(){
+        assertThatThrownBy(() -> BettingMoney.of(0))
+                .isInstanceOf(IllegalArgumentException.class);
+        assertThatThrownBy(() -> BettingMoney.of(-1000))
+                .isInstanceOf(IllegalArgumentException.class);
+    }
+}
diff --git a/src/test/java/domain/BlackjackGameTest.java b/src/test/java/domain/BlackjackGameTest.java
index b3861e36ae1..9365c01cb2d 100644
--- a/src/test/java/domain/BlackjackGameTest.java
+++ b/src/test/java/domain/BlackjackGameTest.java
@@ -2,22 +2,33 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 import java.util.List;
+
+import domain.card.Card;
+import domain.card.CardNumber;
+import domain.card.CardShape;
+import domain.card.Deck;
+import domain.participant.*;
 import org.junit.jupiter.api.Test;
 
 class BlackjackGameTest {
 
     @Test
     void 게임_시작시_딜러와_플레이어에게_카드2장_배분() {
-        BlackjackGame blackjackGame = BlackjackGame.start(List.of("pobi", "jason"));
+        List<PlayerCreationInfo> playerCreationInfos = List.of(
+                PlayerCreationInfo.of(Name.from("pobi"), BettingMoney.of(1000)),
+                PlayerCreationInfo.of(Name.from("jason"), BettingMoney.of(2000))
+        );
+
+        BlackjackGame blackjackGame = BlackjackGame.start(playerCreationInfos);
 
         Dealer dealer = blackjackGame.getDealer();
         Players players = blackjackGame.getPlayers();
 
-        assertThat(dealer.getHand().getCards()).hasSize(2);
+        assertThat(dealer.getHandCards()).hasSize(2);
         assertThat(players.getPlayers()).hasSize(2);
 
         for (Player player : players.getPlayers()) {
-            assertThat(player.getHand().getCards()).hasSize(2);
+            assertThat(player.getHandCards()).hasSize(2);
         }
     }
 
@@ -31,14 +42,17 @@ class BlackjackGameTest {
                 Card.of(CardNumber.TWO, CardShape.SPADE)      // player draw
         ));
 
-        BlackjackGame blackjackGame = BlackjackGame.start(List.of("pobi"), deck);
-        Player player = blackjackGame.getPlayers().getPlayers().getFirst();
+        List<PlayerCreationInfo> playerCreationInfos = List.of(
+                PlayerCreationInfo.of(Name.from("pobi"), BettingMoney.of(1000))
+        );
 
-        int before = player.getHand().getCards().size();
+        BlackjackGame blackjackGame = BlackjackGame.start(playerCreationInfos, deck);
+        Player player = blackjackGame.getPlayersValue().getFirst();
 
+        int before = player.getHandCards().size();
         blackjackGame.addPlayerCard(player);
 
-        assertThat(player.getHand().getCards()).hasSize(before + 1);
+        assertThat(player.getHandCards()).hasSize(before + 1);
     }
 
     @Test
@@ -51,18 +65,21 @@ class BlackjackGameTest {
                 Card.of(CardNumber.THREE, CardShape.SPADE)    // player draw -> 22
         ));
 
-        BlackjackGame blackjackGame = BlackjackGame.start(List.of("pobi"), deck);
-        Player player = blackjackGame.getPlayers().getPlayers().getFirst();
+        List<PlayerCreationInfo> playerCreationInfos = List.of(
+                PlayerCreationInfo.of(Name.from("pobi"), BettingMoney.of(1000))
+        );
+        BlackjackGame blackjackGame = BlackjackGame.start(playerCreationInfos, deck);
+        Player player = blackjackGame.getPlayersValue().getFirst();
         Dealer dealer = blackjackGame.getDealer();
 
-        int dealerCardCountBefore = dealer.getHand().getCards().size();
+        int dealerCardCountBefore = dealer.getHandCards().size();
 
         blackjackGame.addPlayerCard(player);
         boolean result = blackjackGame.playDealerTurn();
 
         assertThat(player.isBust()).isTrue();
         assertThat(result).isFalse();
-        assertThat(dealer.getHand().getCards()).hasSize(dealerCardCountBefore);
+        assertThat(dealer.getHandCards()).hasSize(dealerCardCountBefore);
     }
 
     @Test
@@ -75,15 +92,18 @@ class BlackjackGameTest {
                 Card.of(CardNumber.TWO, CardShape.SPADE)      // dealer draw -> 18
         ));
 
-        BlackjackGame blackjackGame = BlackjackGame.start(List.of("pobi"), deck);
-        Dealer dealer = blackjackGame.getDealer();
+        List<PlayerCreationInfo> playerCreationInfos = List.of(
+                PlayerCreationInfo.of(Name.from("pobi"), BettingMoney.of(1000))
+        );
 
-        int dealerCardCountBefore = dealer.getHand().getCards().size();
+        BlackjackGame blackjackGame = BlackjackGame.start(playerCreationInfos, deck);
+        Dealer dealer = blackjackGame.getDealer();
 
+        int dealerCardCountBefore = dealer.getHandCards().size();
         boolean result = blackjackGame.playDealerTurn();
 
         assertThat(result).isTrue();
-        assertThat(dealer.getHand().getCards().size()).isGreaterThan(dealerCardCountBefore);
+        assertThat(dealer.getHandCards().size()).isGreaterThan(dealerCardCountBefore);
     }
 
     @Test
@@ -95,14 +115,17 @@ class BlackjackGameTest {
                 Card.of(CardNumber.SIX, CardShape.DIAMOND)    // player 2 -> 15
         ));
 
-        BlackjackGame blackjackGame = BlackjackGame.start(List.of("pobi"), deck);
-        Dealer dealer = blackjackGame.getDealer();
+        List<PlayerCreationInfo> playerCreationInfos = List.of(
+                PlayerCreationInfo.of(Name.from("pobi"), BettingMoney.of(1000))
+        );
 
-        int dealerCardCountBefore = dealer.getHand().getCards().size();
+        BlackjackGame blackjackGame = BlackjackGame.start(playerCreationInfos, deck);
+        Dealer dealer = blackjackGame.getDealer();
 
+        int dealerCardCountBefore = dealer.getHandCards().size();
         boolean result = blackjackGame.playDealerTurn();
 
         assertThat(result).isFalse();
-        assertThat(dealer.getHand().getCards()).hasSize(dealerCardCountBefore);
+        assertThat(dealer.getHandCards()).hasSize(dealerCardCountBefore);
     }
-}
\ No newline at end of file
+}
diff --git a/src/test/java/domain/DealerTest.java b/src/test/java/domain/DealerTest.java
index 1fed2102a43..939fa67d245 100644
--- a/src/test/java/domain/DealerTest.java
+++ b/src/test/java/domain/DealerTest.java
@@ -4,7 +4,12 @@
 
 import java.util.ArrayList;
 import java.util.List;
-import org.junit.jupiter.api.DisplayName;
+
+import domain.card.Card;
+import domain.card.CardNumber;
+import domain.card.CardShape;
+import domain.hand.Hand;
+import domain.participant.Dealer;
 import org.junit.jupiter.api.Test;
 
 class DealerTest {
@@ -29,4 +34,4 @@ class DealerTest {
         assertThat(underThreshold.getHandCards().size()).isEqualTo(3);
         assertThat(overThreshold.getHandCards().size()).isEqualTo(3);
     }
-}
\ No newline at end of file
+}
diff --git a/src/test/java/domain/DeckTest.java b/src/test/java/domain/DeckTest.java
index 95bef2ba378..500470470a2 100644
--- a/src/test/java/domain/DeckTest.java
+++ b/src/test/java/domain/DeckTest.java
@@ -1,6 +1,6 @@
 package domain;
 
-import org.junit.jupiter.api.DisplayName;
+import domain.card.Deck;
 import org.junit.jupiter.api.Test;
 
 import java.util.List;
diff --git a/src/test/java/domain/HandTest.java b/src/test/java/domain/HandTest.java
new file mode 100644
index 00000000000..5bfdebaaa24
--- /dev/null
+++ b/src/test/java/domain/HandTest.java
@@ -0,0 +1,42 @@
+package domain;
+
+import domain.card.Card;
+import domain.card.CardNumber;
+import domain.card.CardShape;
+import domain.hand.Hand;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class HandTest {
+
+    @Test
+    void 처음_두장_합이_21이면_블랙잭이다(){
+        Hand hand = new Hand(List.of(
+                Card.of(CardNumber.ACE, CardShape.CLOVER),
+                Card.of(CardNumber.J, CardShape.SPADE)
+        ));
+        assertThat(hand.isBlackjack()).isTrue();
+    }
+
+    @Test
+    void 카드가_세장이면_21이어도_블랙잭이_아니다(){
+        Hand hand = new Hand(List.of(
+                Card.of(CardNumber.ACE, CardShape.CLOVER),
+                Card.of(CardNumber.FIVE, CardShape.SPADE),
+                Card.of(CardNumber.FIVE, CardShape.DIAMOND)
+        ));
+        assertThat(hand.isBlackjack()).isFalse();
+    }
+
+    @Test
+    void 두장이지만_합이_21이_아니면_블랙잭이_아니다(){
+        Hand hand = new Hand(List.of(
+                Card.of(CardNumber.ACE, CardShape.CLOVER),
+                Card.of(CardNumber.FIVE, CardShape.DIAMOND)
+        ));
+        assertThat(hand.isBlackjack()).isFalse();
+    }
+}
diff --git a/src/test/java/domain/NameTest.java b/src/test/java/domain/NameTest.java
index 663dfc70f30..5df12fb33c2 100644
--- a/src/test/java/domain/NameTest.java
+++ b/src/test/java/domain/NameTest.java
@@ -2,7 +2,7 @@
 
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
-import org.junit.jupiter.api.DisplayName;
+import domain.participant.Name;
 import org.junit.jupiter.api.Test;
 
 class NameTest {
@@ -21,4 +21,4 @@ class NameTest {
         assertThatThrownBy(() -> Name.from(emptyName)).isInstanceOf(IllegalArgumentException.class);
     }
 
-}
\ No newline at end of file
+}
diff --git a/src/test/java/domain/PlayerCreationInfoTest.java b/src/test/java/domain/PlayerCreationInfoTest.java
new file mode 100644
index 00000000000..818273e514e
--- /dev/null
+++ b/src/test/java/domain/PlayerCreationInfoTest.java
@@ -0,0 +1,21 @@
+package domain;
+
+import domain.participant.BettingMoney;
+import domain.participant.Name;
+import domain.participant.PlayerCreationInfo;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class PlayerCreationInfoTest {
+
+    @Test
+    void 플레이어_생성정보를_만들_수_있다(){
+        Name name = Name.from("pobi");
+        BettingMoney bettingMoney = BettingMoney.of(1000);
+        PlayerCreationInfo playerCreationInfo = PlayerCreationInfo.of(name, bettingMoney);
+
+        assertThat(playerCreationInfo.getName()).isEqualTo(name);
+        assertThat(playerCreationInfo.getBettingMoney()).isEqualTo(bettingMoney);
+    }
+}
diff --git a/src/test/java/domain/PlayerTest.java b/src/test/java/domain/PlayerTest.java
index b90170fcdd4..5904c540860 100644
--- a/src/test/java/domain/PlayerTest.java
+++ b/src/test/java/domain/PlayerTest.java
@@ -5,18 +5,26 @@
 import java.util.ArrayList;
 import java.util.List;
 
-import org.junit.jupiter.api.DisplayName;
+import domain.card.Card;
+import domain.card.CardNumber;
+import domain.card.CardShape;
+import domain.hand.Hand;
+import domain.participant.BettingMoney;
+import domain.participant.Name;
+import domain.participant.Player;
 import org.junit.jupiter.api.Test;
 
 class PlayerTest {
     Player bustPlayer = Player.of(Name.from("pobi"), new Hand(new ArrayList<>(List.of(
             Card.of(CardNumber.J, CardShape.CLOVER),
             Card.of(CardNumber.K, CardShape.HEART),
-            Card.of(CardNumber.Q, CardShape.DIAMOND)))));
+            Card.of(CardNumber.Q, CardShape.DIAMOND)))),
+            BettingMoney.of(1000));
 
     Player normalPlayer = Player.of(Name.from("jason"), new Hand(new ArrayList<>(List.of(
             Card.of(CardNumber.J, CardShape.CLOVER),
-            Card.of(CardNumber.Q, CardShape.DIAMOND)))));
+            Card.of(CardNumber.Q, CardShape.DIAMOND)))),
+            BettingMoney.of(2000));
 
     @Test
     void 플레이어_카드_추가_확인() {
@@ -31,4 +39,4 @@ class PlayerTest {
         assertThat(bustPlayer.isBust()).isTrue();
         assertThat(normalPlayer.isBust()).isFalse();
     }
-}
\ No newline at end of file
+}
diff --git a/src/test/java/domain/PlayersTest.java b/src/test/java/domain/PlayersTest.java
index 1729bdf4a8f..2014ef7c739 100644
--- a/src/test/java/domain/PlayersTest.java
+++ b/src/test/java/domain/PlayersTest.java
@@ -1,23 +1,32 @@
 package domain;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.jupiter.api.Assertions.*;
 
 import java.util.ArrayList;
 import java.util.List;
 
-import org.junit.jupiter.api.DisplayName;
+import domain.card.Card;
+import domain.card.CardNumber;
+import domain.card.CardShape;
+import domain.hand.Hand;
+import domain.participant.BettingMoney;
+import domain.participant.Name;
+import domain.participant.Player;
+import domain.participant.Players;
 import org.junit.jupiter.api.Test;
 
 class PlayersTest {
     Player bustPlayer = Player.of(Name.from("pobi"), new Hand(new ArrayList<>(List.of(
-            Card.of(CardNumber.J, CardShape.CLOVER),
-            Card.of(CardNumber.K, CardShape.HEART),
-            Card.of(CardNumber.Q, CardShape.DIAMOND)))));
+                    Card.of(CardNumber.J, CardShape.CLOVER),
+                    Card.of(CardNumber.K, CardShape.HEART),
+                    Card.of(CardNumber.Q, CardShape.DIAMOND))))
+            , BettingMoney.of(1000)
+    );
 
     Player normalPlayer = Player.of(Name.from("jason"), new Hand(new ArrayList<>(List.of(
             Card.of(CardNumber.J, CardShape.CLOVER),
-            Card.of(CardNumber.Q, CardShape.DIAMOND)))));
+            Card.of(CardNumber.Q, CardShape.DIAMOND)))),
+            BettingMoney.of(2000));
 
     Players allBustPlayers = Players.from(List.of(bustPlayer, bustPlayer, bustPlayer));
     Players containBustPlayers = Players.from(List.of(bustPlayer, normalPlayer, normalPlayer));
@@ -29,4 +38,4 @@ class PlayersTest {
         assertThat(containBustPlayers.isAllBust()).isFalse();
         assertThat(allNormalPlayers.isAllBust()).isFalse();
     }
-}
\ No newline at end of file
+}
diff --git a/src/test/java/domain/ProfitCalculatorTest.java b/src/test/java/domain/ProfitCalculatorTest.java
new file mode 100644
index 00000000000..1ef6e3349cd
--- /dev/null
+++ b/src/test/java/domain/ProfitCalculatorTest.java
@@ -0,0 +1,158 @@
+package domain;
+
+import domain.card.Card;
+import domain.card.CardNumber;
+import domain.card.CardShape;
+import domain.hand.Hand;
+import domain.participant.*;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class ProfitCalculatorTest {
+
+    @Test
+    void 플레이어가_버스트면_배팅금액만큼_잃는다() {
+        Player player = player("pobi",1000,
+                card(CardNumber.K, CardShape.SPADE),
+                card(CardNumber.Q, CardShape.HEART),
+                card(CardNumber.TWO, CardShape.CLOVER));
+
+        Dealer dealer = dealer(
+                card(CardNumber.TEN, CardShape.DIAMOND),
+                card(CardNumber.SEVEN, CardShape.CLOVER));
+
+        double profit = ProfitCalculator.calculatePlayerProfit(player, dealer);
+
+        assertThat(profit).isEqualTo(-1000);
+    }
+
+    @Test
+    void 플레이어가_블랙잭이면_배팅금액의_1점5배를_번다(){
+        Player player = player("pobi",1000,
+                card(CardNumber.ACE, CardShape.DIAMOND),
+                card(CardNumber.K, CardShape.CLOVER));
+
+        Dealer dealer = dealer(
+                card(CardNumber.TEN, CardShape.CLOVER),
+                card(CardNumber.EIGHT, CardShape.DIAMOND));
+
+        double profit = ProfitCalculator.calculatePlayerProfit(player, dealer);
+        assertThat(profit).isEqualTo(1500);
+    }
+
+    @Test
+    void 플레이어와_딜러가_모두_블랙잭이면_무승부다(){
+        Player player = player("pobi",1000,
+                card(CardNumber.ACE, CardShape.SPADE),
+                card(CardNumber.K, CardShape.HEART));
+
+        Dealer dealer = dealer(
+                card(CardNumber.ACE, CardShape.DIAMOND),
+                card(CardNumber.Q, CardShape.CLOVER));
+
+        double profit = ProfitCalculator.calculatePlayerProfit(player, dealer);
+
+        assertThat(profit).isEqualTo(0);
+    }
+
+    @Test
+    void 딜러가_버스트면_플레이어는_배팅금액만큼_수익(){
+        Player player = player("pobi",1000,
+                card(CardNumber.TEN, CardShape.SPADE),
+                card(CardNumber.NINE, CardShape.HEART));
+
+        Dealer dealer = dealer(
+                card(CardNumber.K, CardShape.DIAMOND),
+                card(CardNumber.TWO, CardShape.CLOVER),
+                card(CardNumber.Q, CardShape.HEART));
+
+        double profit = ProfitCalculator.calculatePlayerProfit(player, dealer);
+
+        assertThat(profit).isEqualTo(1000);
+    }
+
+    @Test
+    void 플레이어_점수가_더_크면_배팅금액만큼_수익(){
+        Player player = player("pobi",1000,
+                card(CardNumber.EIGHT, CardShape.DIAMOND),
+                card(CardNumber.K, CardShape.SPADE));
+
+        Dealer dealer = dealer(
+                card(CardNumber.TEN, CardShape.CLOVER),
+                card(CardNumber.SEVEN, CardShape.HEART));
+
+        double profit = ProfitCalculator.calculatePlayerProfit(player, dealer);
+        assertThat(profit).isEqualTo(1000);
+    }
+    @Test
+    void 플레이어_점수가_더_작으면_배팅금액만큼_잃는다() {
+        Player player = player("pobi",1000,
+                card(CardNumber.TEN, CardShape.SPADE),
+                card(CardNumber.SEVEN, CardShape.HEART));
+
+        Dealer dealer = dealer(
+                card(CardNumber.TEN, CardShape.DIAMOND),
+                card(CardNumber.NINE, CardShape.CLOVER));
+
+        double profit = ProfitCalculator.calculatePlayerProfit(player, dealer);
+
+        assertThat(profit).isEqualTo(-1000);
+    }
+
+    @Test
+    void 점수가_같으면_무승부다() {
+        Player player = player("pobi",1000,
+                card(CardNumber.TEN, CardShape.SPADE),
+                card(CardNumber.EIGHT, CardShape.HEART));
+
+        Dealer dealer = dealer(
+                card(CardNumber.NINE, CardShape.DIAMOND),
+                card(CardNumber.NINE, CardShape.CLOVER));
+
+        double profit = ProfitCalculator.calculatePlayerProfit(player, dealer);
+
+        assertThat(profit).isEqualTo(0);
+    }
+
+    @Test
+    void 딜러_수익은_모든_플레이어_수익의_반대값이다() {
+        Player winPlayer = player("pobi", 1000,
+                card(CardNumber.TEN, CardShape.SPADE),
+                card(CardNumber.NINE, CardShape.HEART));
+
+        Player losePlayer = player("jason", 2000,
+                card(CardNumber.TEN, CardShape.CLOVER),
+                card(CardNumber.SEVEN, CardShape.DIAMOND));
+
+        Dealer dealer = dealer(
+                card(CardNumber.TEN, CardShape.DIAMOND),
+                card(CardNumber.EIGHT, CardShape.CLOVER));
+
+        Players players = Players.from(List.of(winPlayer, losePlayer));
+
+        double dealerProfit = ProfitCalculator.calculateDealerProfit(players, dealer);
+
+        assertThat(dealerProfit).isEqualTo(1000);
+    }
+
+
+    private Player player(String name, int bettingMoney, Card... cards) {
+        return Player.of(
+                Name.from(name),
+                new Hand(List.of(cards)),
+                BettingMoney.of(bettingMoney)
+        );
+    }
+
+    private Dealer dealer(Card... cards) {
+        return Dealer.from(new Hand(List.of(cards)));
+    }
+
+    private Card card(CardNumber cardNumber, CardShape cardShape){
+        return Card.of(cardNumber, cardShape);
+    }
+
+}
diff --git a/src/test/java/domain/ScoreCaculatorTest.java b/src/test/java/domain/ScoreCalculatorTest.java
similarity index 70%
rename from src/test/java/domain/ScoreCaculatorTest.java
rename to src/test/java/domain/ScoreCalculatorTest.java
index 6c0a863ff1f..75bb1c98fed 100644
--- a/src/test/java/domain/ScoreCaculatorTest.java
+++ b/src/test/java/domain/ScoreCalculatorTest.java
@@ -1,14 +1,16 @@
 package domain;
 
-import org.junit.jupiter.api.DisplayName;
+import domain.card.Card;
+import domain.card.CardNumber;
+import domain.card.CardShape;
+import domain.hand.ScoreCalculator;
 import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
-public class ScoreCaculatorTest {
-    @DisplayName("점수 계산 테스트")
+public class ScoreCalculatorTest {
     @Test
     void 점수_계산_테스트() {
         List<Card> cards = List.of(Card.of(CardNumber.J, CardShape.CLOVER), Card.of(CardNumber.Q, CardShape.CLOVER));