diff --git a/src/main/java/chess/ChessApplication.java b/src/main/java/chess/ChessApplication.java
new file mode 100644
index 0000000000..d0fb239029
--- /dev/null
+++ b/src/main/java/chess/ChessApplication.java
@@ -0,0 +1,44 @@
+package chess;
+
+import chess.piece.Board;
+import chess.piece.Piece;
+import chess.view.InputView;
+import chess.view.OutputView;
+import java.util.function.Supplier;
+
+public class ChessApplication {
+
+    public static void main(String[] args) {
+        final Board board = Board.emptyBoard();
+        board.gameSetUp();
+        tryCatchLoop(() -> gameStart(board));
+    }
+
+    public static void gameStart(final Board board) {
+        OutputView.printBoard(board.getMapView());
+        final Position startPosition = tryCatchLoop(InputView::readStartPosition);
+        final Position endPosition = tryCatchLoop(InputView::readEndPosition);
+        final Piece targetPiece = board.move(startPosition, endPosition);
+        OutputView.printEndPiece(targetPiece);
+        gameStart(board);
+    }
+
+    private static void tryCatchLoop(final Runnable runnable) {
+        try {
+            runnable.run();
+        } catch (IllegalArgumentException | IllegalStateException e) {
+            System.out.println(e.getMessage());
+            runnable.run();
+        }
+    }
+
+    private static <T> T tryCatchLoop(Supplier<T> callBack) {
+        try {
+            return callBack.get();
+        } catch (IllegalStateException | IllegalArgumentException e) {
+            System.out.println(e.getMessage());
+            return tryCatchLoop(callBack);
+        }
+    }
+
+}
diff --git a/src/main/java/chess/Column.java b/src/main/java/chess/Column.java
index b64b4dc77a..d102daccb3 100644
--- a/src/main/java/chess/Column.java
+++ b/src/main/java/chess/Column.java
@@ -1,15 +1,30 @@
 package chess;
 
+import java.util.Arrays;
+
 public enum Column {
 
-    A,
-    B,
-    C,
-    D,
-    E,
-    F,
-    G,
-    H;
+    A(0),
+    B(1),
+    C(2),
+    D(3),
+    E(4),
+    F(5),
+    G(6),
+    H(7);
+
+    private final int value;
+
+    Column(final int value) {
+        this.value = value;
+    }
+
+    public static Column parseToColumnByNumber(final int number) {
+        return Arrays.stream(Column.values())
+                .filter(column -> column.value == number)
+                .findAny()
+                .orElseThrow(() -> new IllegalArgumentException("유효하지 않은 위치 : " + number));
+    }
 
     public boolean isFarLeft() {
         return ordinal() == 0;
@@ -50,4 +65,15 @@ public Column moveRight(final int step) {
 
         throw new IllegalStateException("움직일 수 없는 위치입니다.");
     }
+
+    public boolean isAvailableColumn() {
+        return this.value >= 0 && this.value <= 7;
+    }
+
+    @Override
+    public String toString() {
+        return "Column{" +
+                "value=" + value +
+                '}';
+    }
 }
diff --git a/src/main/java/chess/Position.java b/src/main/java/chess/Position.java
index 3ebeb0ea18..9410e4a341 100644
--- a/src/main/java/chess/Position.java
+++ b/src/main/java/chess/Position.java
@@ -167,4 +167,20 @@ public Position moveHorizontal(final int step) {
         }
         return this;
     }
+
+    public Position copyOf() {
+        return new Position(this.row, this.column);
+    }
+
+    public boolean isAvailableMovePosition() {
+        return this.row.isAvailableRow() && this.column.isAvailableColumn();
+    }
+
+    @Override
+    public String toString() {
+        return "Position{" +
+                "row=" + row +
+                ", column=" + column +
+                '}';
+    }
 }
diff --git a/src/main/java/chess/Row.java b/src/main/java/chess/Row.java
index 126ed048da..9ed63d8908 100644
--- a/src/main/java/chess/Row.java
+++ b/src/main/java/chess/Row.java
@@ -1,15 +1,30 @@
 package chess;
 
+import java.util.Arrays;
+
 public enum Row {
 
-    EIGHT,
-    SEVEN,
-    SIX,
-    FIVE,
-    FOUR,
-    THREE,
-    TWO,
-    ONE;
+    EIGHT(7),
+    SEVEN(6),
+    SIX(5),
+    FIVE(4),
+    FOUR(3),
+    THREE(2),
+    TWO(1),
+    ONE(0);
+
+    private final int value;
+
+    Row(final int value) {
+        this.value = value;
+    }
+
+    public static Row parseToRowByNumber(final int number) {
+        return Arrays.stream(Row.values())
+                .filter(row -> row.value == number)
+                .findAny()
+                .orElseThrow(() -> new IllegalArgumentException("유효하지 않은 위치 : " + number));
+    }
 
     public boolean isTop() {
         return ordinal() == 0;
@@ -50,4 +65,19 @@ public Row moveDown(final int step) {
 
         throw new IllegalStateException("움직일 수 없는 위치입니다.");
     }
+
+    public int getValue() {
+        return value;
+    }
+
+    public boolean isAvailableRow() {
+        return this.value >= 0 && this.value <= 7;
+    }
+
+    @Override
+    public String toString() {
+        return "Row{" +
+                "value=" + value +
+                '}';
+    }
 }
diff --git a/src/main/java/chess/piece/Bishop.java b/src/main/java/chess/piece/Bishop.java
index b14ab70f98..508b5c3b85 100644
--- a/src/main/java/chess/piece/Bishop.java
+++ b/src/main/java/chess/piece/Bishop.java
@@ -1,5 +1,83 @@
 package chess.piece;
 
-public class Bishop {
+import chess.Color;
+import chess.Column;
+import chess.Position;
+import chess.Row;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Function;
 
+public class Bishop extends Piece {
+
+    private static final List<Position> WHITE_BISHOP_POSITIONS = List.of(
+            new Position(Row.ONE, Column.C), new Position(Row.ONE, Column.F)
+    );
+
+    private static final List<Position> BLACK_BISHOP_POSITIONS = List.of(
+            new Position(Row.EIGHT, Column.C), new Position(Row.EIGHT, Column.F)
+    );
+
+    private static final List<Function<Position, Position>> MOVEMENTS = List.of(
+            Position::moveLeftUp,
+            Position::moveLeftDown,
+            Position::moveRightUp,
+            Position::moveRightDown
+    );
+
+    public Bishop(final Position position, final Color color) {
+        super(position, color);
+    }
+
+    public static List<Piece> initialize() {
+        final List<Piece> pieces = new ArrayList<>();
+        final List<Bishop> whiteBishops = WHITE_BISHOP_POSITIONS.stream()
+                .map(position -> new Bishop(position, Color.WHITE))
+                .toList();
+        final List<Bishop> blackBishops = BLACK_BISHOP_POSITIONS.stream()
+                .map(position -> new Bishop(position, Color.BLACK))
+                .toList();
+        pieces.addAll(whiteBishops);
+        pieces.addAll(blackBishops);
+        return pieces;
+    }
+
+    @Override
+    public List<Position> calculateAvailablePositions(final Board board) {
+        final List<Position> positions = new ArrayList<>();
+        for (Function<Position, Position> movement : MOVEMENTS) {
+            addAvailablePositions(board, getPosition(), movement, positions);
+        }
+        return positions;
+    }
+
+    @Override
+    public Piece copyOf(final Position position) {
+        return new Bishop(position, getColor());
+    }
+
+    @Override
+    public PieceType getType() {
+        return PieceType.BISHOP;
+    }
+
+    private void addAvailablePositions(final Board board, final Position position, final Function<Position, Position> function, final List<Position> positions) {
+        Position movedPosition;
+        try {
+            movedPosition = function.apply(position);
+        } catch (IllegalStateException e) {
+            return;
+        }
+        if (!isAvailablePosition(board, movedPosition)) {
+            return;
+        }
+        if (!board.isEmptyPosition(movedPosition)) {
+            if (board.isEnemy(movedPosition, this)) {
+                positions.add(movedPosition);
+            }
+            return;
+        }
+        positions.add(movedPosition);
+        addAvailablePositions(board, movedPosition, function, positions);
+    }
 }
diff --git a/src/main/java/chess/piece/Board.java b/src/main/java/chess/piece/Board.java
new file mode 100644
index 0000000000..3d40d4f1b1
--- /dev/null
+++ b/src/main/java/chess/piece/Board.java
@@ -0,0 +1,75 @@
+package chess.piece;
+
+import chess.Position;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class Board {
+
+    private final Map<Position, Piece> mapView;
+
+    public static Board emptyBoard() {
+        return new Board(new HashMap<>());
+    }
+
+    public void gameSetUp() {
+        final List<Piece> pawns = Pawn.initialize();
+        final List<Piece> knights = Knight.initialize();
+        final List<Piece> rooks = Rook.initialize();
+        final List<Piece> bishops = Bishop.initialize();
+        final List<Piece> kings = King.initialize();
+        final List<Piece> queens = Queen.initialize();
+        locatePiece(pawns, knights, rooks, bishops, kings, queens);
+    }
+
+    private void locatePiece(final List<Piece> ...piecesGroup) {
+        for (List<Piece> pieces : piecesGroup) {
+            for (Piece piece : pieces) {
+                mapView.put(piece.getPosition(), piece);
+            }
+        }
+    }
+
+    public Board(final Map<Position, Piece> mapView) {
+        this.mapView = mapView;
+    }
+
+    public boolean isSameTeam(final Position position, final Piece piece) {
+        return mapView.get(position).getColor() == piece.getColor();
+    }
+
+    public boolean isEmptyPosition(final Position position) {
+        return mapView.get(position) == null;
+    }
+
+    public boolean isEnemy(final Position position, final Piece piece) {
+        return !isEmptyPosition(position) && (mapView.get(position).getColor() != piece.getColor());
+    }
+
+    public Map<Position, Piece> getMapView() {
+        return mapView;
+    }
+
+    public Piece move(final Position startPosition, final Position endPosition) {
+        validateStartPosition(startPosition);
+        validateEndPosition(startPosition, endPosition);
+        final Piece startPiece = mapView.remove(startPosition);
+        final Piece endPiece = mapView.get(endPosition);
+        mapView.put(endPosition, startPiece.copyOf(endPosition));
+        return endPiece;
+    }
+
+    private void validateStartPosition(final Position position) {
+        if (mapView.get(position) == null) {
+            throw new IllegalArgumentException("해당 위치에는 기물이 없습니다.");
+        }
+    }
+
+    private void validateEndPosition(final Position startPosition, final Position endPosition) {
+        final Piece startPiece = mapView.get(startPosition);
+        if (!startPiece.calculateAvailablePositions(this).contains(endPosition)) {
+            throw new IllegalArgumentException("해당 위치로는 이용할 수 없습니다.");
+        }
+    }
+}
diff --git a/src/main/java/chess/piece/King.java b/src/main/java/chess/piece/King.java
index d64210cad1..01be2383fd 100644
--- a/src/main/java/chess/piece/King.java
+++ b/src/main/java/chess/piece/King.java
@@ -1,5 +1,63 @@
 package chess.piece;
 
-public class King {
+import chess.Color;
+import chess.Column;
+import chess.Position;
+import chess.Row;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Function;
 
+public class King extends Piece {
+
+    private static final Position WHITE_KING_POSITION = new Position(Row.ONE, Column.E);
+    private static final Position BLACK_KING_POSITION = new Position(Row.EIGHT, Column.E);
+
+    private static final List<Function<Position, Position>> MOVEMENTS = List.of(
+            Position::moveUp,
+            Position::moveDown,
+            Position::moveLeft,
+            Position::moveRight,
+            Position::moveLeftUp,
+            Position::moveLeftDown,
+            Position::moveRightUp,
+            Position::moveRightDown
+    );
+
+    public King(final Position position, final Color color) {
+        super(position, color);
+    }
+
+    public static List<Piece> initialize() {
+        List<Piece> kings = new ArrayList<>();
+        kings.add(new King(WHITE_KING_POSITION, Color.WHITE));
+        kings.add(new King(BLACK_KING_POSITION, Color.BLACK));
+        return kings;
+    }
+
+    @Override
+    public PieceType getType() {
+        return PieceType.KING;
+    }
+
+    @Override
+    public List<Position> calculateAvailablePositions(final Board board) {
+        final List<Position> positions = new ArrayList<>();
+        for (Function<Position, Position> function : MOVEMENTS) {
+            Position movedPosition;
+            try {
+                movedPosition = function.apply(getPosition());
+                if (isAvailablePosition(board, movedPosition)) {
+                    positions.add(movedPosition);
+                }
+            } catch (IllegalStateException ignored) {
+            }
+        }
+        return positions;
+    }
+
+    @Override
+    public Piece copyOf(final Position position) {
+        return new King(position, getColor());
+    }
 }
diff --git a/src/main/java/chess/piece/Knight.java b/src/main/java/chess/piece/Knight.java
index 2ee7c47a3b..42a463f1ee 100644
--- a/src/main/java/chess/piece/Knight.java
+++ b/src/main/java/chess/piece/Knight.java
@@ -1,5 +1,83 @@
 package chess.piece;
 
-public class Knight {
+import chess.Color;
+import chess.Column;
+import chess.Position;
+import chess.Row;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Function;
 
+public class Knight extends Piece {
+
+    private static final List<Position> WHITE_KNIGHT_POSITIONS = List.of(
+            new Position(Row.ONE, Column.B), new Position(Row.ONE, Column.G)
+    );
+    private static final List<Position> BLACK_KNIGHT_POSITIONS = List.of(
+            new Position(Row.EIGHT, Column.B), new Position(Row.EIGHT, Column.G)
+    );
+
+    private static final List<List<Function<Position,Position>>> MOVEMENTS = List.of(
+            List.of(Position::moveUp, Position::moveLeftUp),
+            List.of(Position::moveUp, Position::moveRightUp),
+            List.of(Position::moveDown, Position::moveLeftDown),
+            List.of(Position::moveDown, Position::moveRightDown),
+            List.of(Position::moveLeft, Position::moveLeftUp),
+            List.of(Position::moveLeft, Position::moveRightUp),
+            List.of(Position::moveRight, Position::moveLeftUp),
+            List.of(Position::moveRight, Position::moveRightDown)
+    );
+
+    public Knight(final Position position, final Color color) {
+        super(position, color);
+    }
+
+    public static List<Piece> initialize() {
+        final List<Piece> pieces = new ArrayList<>();
+        final List<Knight> whiteKnights = WHITE_KNIGHT_POSITIONS.stream()
+                .map(position -> new Knight(position, Color.WHITE))
+                .toList();
+        final List<Knight> blackKnights = BLACK_KNIGHT_POSITIONS.stream()
+                .map(position -> new Knight(position, Color.BLACK))
+                .toList();
+        pieces.addAll(whiteKnights);
+        pieces.addAll(blackKnights);
+        return pieces;
+    }
+
+    @Override
+    public List<Position> calculateAvailablePositions(final Board board) {
+        List<Position> positions = new ArrayList<>();
+        for (List<Function<Position, Position>> movement : MOVEMENTS) {
+            Position tmp = getPosition().copyOf();
+            boolean flag = true;
+            for (Function<Position, Position> function : movement) {
+                Position movedPosition;
+                try {
+                    movedPosition = function.apply(tmp);
+                } catch (IllegalStateException e) {
+                    break;
+                }
+                if (!isAvailablePosition(board, movedPosition)) {
+                    flag = false;
+                    break;
+                }
+                tmp = movedPosition.copyOf();
+            }
+            if (flag) {
+                positions.add(tmp);
+            }
+        }
+        return positions;
+    }
+
+    @Override
+    public Piece copyOf(final Position position) {
+        return new Knight(position, getColor());
+    }
+
+    @Override
+    public PieceType getType() {
+        return PieceType.KNIGHT;
+    }
 }
diff --git a/src/main/java/chess/piece/Pawn.java b/src/main/java/chess/piece/Pawn.java
index c8b6cafa51..449d2e7ef8 100644
--- a/src/main/java/chess/piece/Pawn.java
+++ b/src/main/java/chess/piece/Pawn.java
@@ -1,5 +1,105 @@
 package chess.piece;
 
-public class Pawn {
+import chess.Color;
+import chess.Column;
+import chess.Position;
+import chess.Row;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
 
+public class Pawn extends Piece {
+
+    private static final Row WHITE_PAWN_ROW_POSITION = Row.TWO;
+    private static final Row BLACK_PAWN_ROW_POSITION = Row.SEVEN;
+
+    private static final Map<Color, List<Function<Position, Position>>> ONE_STEP_MOVEMENTS = Map.of(
+            Color.WHITE, List.of(
+                    Position::moveUp
+            ),
+            Color.BLACK, List.of(
+                    Position::moveDown
+            )
+    );
+
+    private static final Map<Color, Function<Position, Position>> TWO_STEP_MOVEMENTS = Map.of(
+            Color.WHITE, position -> position.moveUp().moveUp (),
+            Color.BLACK, position -> position.moveDown().moveDown()
+    );
+
+    private static final Map<Color, List<Function<Position, Position>>> DIAGONAL_STEP_MOVEMENTS = Map.of(
+            Color.WHITE, List.of(
+                    Position::moveLeftUp, Position::moveRightUp
+            ),
+            Color.BLACK, List.of(
+                    Position::moveLeftDown, Position::moveRightDown
+            )
+    );
+
+
+    private boolean isMoved;
+
+    public Pawn(final Position position, final Color color, final boolean isMoved) {
+        super(position, color);
+        this.isMoved = isMoved;
+    }
+
+    public static List<Piece> initialize() {
+        final List<Piece> pawns = new ArrayList<>();
+        for (Column column : Column.values()) {
+            pawns.add(new Pawn(new Position(WHITE_PAWN_ROW_POSITION, column), Color.WHITE, false));
+            pawns.add(new Pawn(new Position(BLACK_PAWN_ROW_POSITION, column), Color.BLACK, false));
+        }
+        return pawns;
+    }
+
+    @Override
+    public List<Position> calculateAvailablePositions(final Board board) {
+        final List<Position> positions = new ArrayList<>();
+        Position movedPosition;
+        for (Function<Position, Position> function : ONE_STEP_MOVEMENTS.get(getColor())) {
+            try {
+                movedPosition = function.apply(getPosition());
+            } catch (IllegalStateException e) {
+                continue;
+            }
+            if (!isAvailablePosition(board, movedPosition)) {
+                continue;
+            }
+            positions.add(movedPosition);
+        }
+
+        for (Function<Position, Position> function : DIAGONAL_STEP_MOVEMENTS.get(getColor())) {
+            try {
+                movedPosition = function.apply(getPosition());
+            } catch (IllegalStateException e) {
+                continue;
+            }
+            if (!board.isEnemy(movedPosition, this)) {
+                continue;
+            }
+            positions.add(movedPosition);
+        }
+
+        final Function<Position, Position> function = TWO_STEP_MOVEMENTS.get(getColor());
+        try {
+            movedPosition = function.apply(getPosition());
+            if (!isMoved && isAvailablePosition(board, movedPosition)) {
+                positions.add(movedPosition);
+            }
+        } catch (IllegalStateException ignored) {
+        }
+        return positions;
+    }
+
+    @Override
+    public Piece copyOf(final Position position) {
+        return new Pawn(position, getColor(), true);
+    }
+
+    @Override
+    public PieceType getType() {
+        return PieceType.PAWN;
+    }
 }
diff --git a/src/main/java/chess/piece/Piece.java b/src/main/java/chess/piece/Piece.java
new file mode 100644
index 0000000000..b696c8c5df
--- /dev/null
+++ b/src/main/java/chess/piece/Piece.java
@@ -0,0 +1,34 @@
+package chess.piece;
+
+import chess.Color;
+import chess.Position;
+import java.util.List;
+
+public abstract class Piece {
+
+    private final Position position;
+    private final Color color;
+
+    protected Piece(final Position position, final Color color) {
+        this.position = position;
+        this.color = color;
+    }
+
+    public Position getPosition() {
+        return position;
+    }
+
+    public abstract List<Position>  calculateAvailablePositions(final Board board);
+
+    public boolean isAvailablePosition(final Board board, final Position position) {
+        return position.isAvailableMovePosition() && (board.isEmptyPosition(position) || !board.isSameTeam(position, this));
+    }
+
+    public Color getColor() {
+        return color;
+    }
+
+    public abstract Piece copyOf(final Position position);
+
+    public abstract PieceType getType();
+}
diff --git a/src/main/java/chess/piece/PieceType.java b/src/main/java/chess/piece/PieceType.java
new file mode 100644
index 0000000000..674c478f32
--- /dev/null
+++ b/src/main/java/chess/piece/PieceType.java
@@ -0,0 +1,20 @@
+package chess.piece;
+
+public enum PieceType {
+    BISHOP("B"),
+    KNIGHT("K"),
+    PAWN("P"),
+    QUEEN("Q"),
+    KING("왕"),
+    ROOK("R");
+
+    private final String name;
+
+    PieceType(final String name) {
+        this.name = name;
+    }
+
+    public String getName() {
+        return name;
+    }
+}
diff --git a/src/main/java/chess/piece/Queen.java b/src/main/java/chess/piece/Queen.java
index 9b547261c4..a78baad7d4 100644
--- a/src/main/java/chess/piece/Queen.java
+++ b/src/main/java/chess/piece/Queen.java
@@ -1,5 +1,76 @@
 package chess.piece;
 
-public class Queen {
+import chess.Color;
+import chess.Column;
+import chess.Position;
+import chess.Row;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Function;
 
+public class Queen extends Piece {
+
+    private static final Position WHITE_QUEEN_POSITION = new Position(Row.ONE, Column.D);
+    private static final Position BLACK_QUEEN_POSITION = new Position(Row.EIGHT, Column.D);
+
+    private static final List<Function<Position, Position>> MOVEMENTS = List.of(
+            Position::moveUp,
+            Position::moveDown,
+            Position::moveLeft,
+            Position::moveRight,
+            Position::moveLeftUp,
+            Position::moveLeftDown,
+            Position::moveRightUp,
+            Position::moveRightDown
+    );
+
+    public Queen(final Position position, final Color color) {
+        super(position, color);
+    }
+
+    public static List<Piece> initialize() {
+        List<Piece> queens = new ArrayList<>();
+        queens.add(new Queen(WHITE_QUEEN_POSITION, Color.WHITE));
+        queens.add(new Queen(BLACK_QUEEN_POSITION, Color.BLACK));
+        return queens;
+    }
+
+    @Override
+    public List<Position> calculateAvailablePositions(final Board board) {
+        final List<Position> positions = new ArrayList<>();
+        for (Function<Position, Position> movement : MOVEMENTS) {
+            addAvailablePositions(board, getPosition(), movement, positions);
+        }
+        return positions;
+    }
+
+    private void addAvailablePositions(final Board board, final Position position, final Function<Position, Position> function, final List<Position> positions) {
+        Position movedPosition;
+        try {
+            movedPosition = function.apply(position);
+        } catch (IllegalStateException e) {
+            return;
+        }
+        if (!isAvailablePosition(board, movedPosition)) {
+            return;
+        }
+        if (!board.isEmptyPosition(movedPosition)) {
+            if (board.isEnemy(movedPosition, this)) {
+                positions.add(movedPosition);
+            }
+            return;
+        }
+        positions.add(movedPosition);
+        addAvailablePositions(board, movedPosition, function, positions);
+    }
+
+    @Override
+    public Piece copyOf(final Position position) {
+        return new Queen(position, getColor());
+    }
+
+    @Override
+    public PieceType getType() {
+        return PieceType.QUEEN;
+    }
 }
diff --git a/src/main/java/chess/piece/Rook.java b/src/main/java/chess/piece/Rook.java
index 7ed4d08bf0..2aa0250ed2 100644
--- a/src/main/java/chess/piece/Rook.java
+++ b/src/main/java/chess/piece/Rook.java
@@ -1,5 +1,83 @@
 package chess.piece;
 
-public class Rook {
+import chess.Color;
+import chess.Column;
+import chess.Position;
+import chess.Row;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Function;
 
+public class Rook extends Piece {
+
+    private static final List<Position> WHITE_ROOK_POSITIONS = List.of(
+            new Position(Row.ONE, Column.A), new Position(Row.ONE, Column.H)
+    );
+
+    private static final List<Position> BLACK_ROOK_POSITIONS = List.of(
+            new Position(Row.EIGHT, Column.A), new Position(Row.EIGHT, Column.H)
+    );
+
+    private static final List<Function<Position, Position>> MOVEMENTS = List.of(
+            Position::moveUp,
+            Position::moveDown,
+            Position::moveLeft,
+            Position::moveRight
+    );
+
+    public Rook(final Position position, final Color color) {
+        super(position, color);
+    }
+
+    @Override
+    public List<Position> calculateAvailablePositions(final Board board) {
+        final List<Position> positions = new ArrayList<>();
+        for (Function<Position, Position> movement : MOVEMENTS) {
+            addAvailablePositions(board, getPosition(), movement, positions);
+        }
+        return positions;
+    }
+
+    public static List<Piece> initialize() {
+        final List<Piece> pieces = new ArrayList<>();
+        final List<Rook> whiteRooks = WHITE_ROOK_POSITIONS.stream()
+                .map(position -> new Rook(position, Color.WHITE))
+                .toList();
+        final List<Rook> blackRooks = BLACK_ROOK_POSITIONS.stream()
+                .map(position -> new Rook(position, Color.BLACK))
+                .toList();
+        pieces.addAll(whiteRooks);
+        pieces.addAll(blackRooks);
+        return pieces;
+    }
+
+    @Override
+    public Piece copyOf(final Position position) {
+        return new Rook(position, getColor());
+    }
+
+    @Override
+    public PieceType getType() {
+        return PieceType.ROOK;
+    }
+
+    private void addAvailablePositions(final Board board, final Position position, final Function<Position, Position> function, final List<Position> positions) {
+        Position movedPosition;
+        try {
+            movedPosition = function.apply(position);
+        } catch (IllegalStateException e) {
+            return;
+        }
+        if (!isAvailablePosition(board, movedPosition)) {
+            return;
+        }
+        if (!board.isEmptyPosition(movedPosition)) {
+            if (board.isEnemy(movedPosition, this)) {
+                positions.add(movedPosition);
+            }
+            return;
+        }
+        positions.add(movedPosition);
+        addAvailablePositions(board, movedPosition, function, positions);
+    }
 }
diff --git a/src/main/java/chess/view/InputView.java b/src/main/java/chess/view/InputView.java
new file mode 100644
index 0000000000..f757051218
--- /dev/null
+++ b/src/main/java/chess/view/InputView.java
@@ -0,0 +1,41 @@
+package chess.view;
+
+import chess.Column;
+import chess.Position;
+import chess.Row;
+import java.util.Scanner;
+
+public class InputView {
+
+    private static final int ROW_INDEX = 0;
+    private static final int COLUMN_INDEX = 1;
+
+    private InputView() {
+    }
+
+    public static Position readStartPosition() {
+        System.out.println("시작 위치를 입력해주세요");
+        return getPosition();
+    }
+
+    public static Position readEndPosition() {
+        System.out.println("끝 위치를 입력해주세요");
+        return getPosition();
+    }
+
+    private static Position getPosition() {
+        final Scanner scanner = new Scanner(System.in);
+        final String[] split = scanner.nextLine().split(",");
+        final Row row = Row.parseToRowByNumber(parseToNumber(split[ROW_INDEX]));
+        final Column column = Column.parseToColumnByNumber(parseToNumber(split[COLUMN_INDEX]));
+        return new Position(row, column);
+    }
+
+    private static int parseToNumber(String input) {
+        try {
+            return Integer.parseInt(input);
+        } catch (NumberFormatException e) {
+            throw new IllegalArgumentException("위치는 숫자만 가능 합니다.");
+        }
+    }
+}
diff --git a/src/main/java/chess/view/OutputView.java b/src/main/java/chess/view/OutputView.java
new file mode 100644
index 0000000000..e268a8d33f
--- /dev/null
+++ b/src/main/java/chess/view/OutputView.java
@@ -0,0 +1,39 @@
+package chess.view;
+
+import chess.Column;
+import chess.Position;
+import chess.Row;
+import chess.piece.Piece;
+import java.util.Map;
+import java.util.Objects;
+
+public class OutputView {
+
+    private OutputView() {
+    }
+
+    public static void printEndPiece(final Piece piece) {
+        if (!Objects.equals(piece, null)) {
+            System.out.println(String.format("%s를 잡았습니다!", piece.getType().getName()));
+        }
+        System.out.println("이동 성공");
+    }
+
+    public static void printBoard(final Map<Position, Piece> mapView) {
+        final StringBuilder boardMessage = new StringBuilder();
+        for (int r = 7; r >= 0; r--) {
+            final StringBuilder sb = new StringBuilder();
+            for (int c = 0; c < 8; c++) {
+                final Position position = new Position(Row.parseToRowByNumber(r), Column.parseToColumnByNumber(c));
+                String message = "- ";
+                if (mapView.get(position) != null) {
+                    message = mapView.get(position).getType().getName() + " ";
+                }
+                sb.append(message);
+            }
+            boardMessage.append(sb)
+                    .append(System.lineSeparator());
+        }
+        System.out.println(boardMessage);
+    }
+}
diff --git a/src/test/java/chess/piece/BishopTest.java b/src/test/java/chess/piece/BishopTest.java
new file mode 100644
index 0000000000..52c5b9b0a6
--- /dev/null
+++ b/src/test/java/chess/piece/BishopTest.java
@@ -0,0 +1,37 @@
+package chess.piece;
+
+import chess.Color;
+import chess.Column;
+import chess.Position;
+import chess.Row;
+import java.util.List;
+import java.util.Map;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+class BishopTest {
+
+
+    @Test
+    @DisplayName("비숍의 이동 경로를 계산 한다")
+    void test1() {
+        //given
+        final Position position = new Position(Row.FIVE, Column.E);
+        final Map<Position, Piece> positionKnightMap = Map.of(new Position(Row.SIX, Column.F),
+                new Knight(new Position(Row.SIX, Column.F), Color.BLACK));
+        final Board board = new Board(positionKnightMap);
+
+        //when
+        final Bishop bishop1 = new Bishop(position, Color.WHITE);
+        final Bishop bishop2 = new Bishop(position, Color.BLACK);
+        final List<Position> positions1 = bishop1.calculateAvailablePositions(board);
+        final List<Position> positions2 = bishop2.calculateAvailablePositions(board);
+
+        //then
+        System.out.println(positions1);
+        System.out.println(positions1.size());
+        System.out.println(positions2);
+        System.out.println(positions2.size());
+    }
+
+}
diff --git a/src/test/java/chess/piece/BoardTest.java b/src/test/java/chess/piece/BoardTest.java
new file mode 100644
index 0000000000..0b18803c82
--- /dev/null
+++ b/src/test/java/chess/piece/BoardTest.java
@@ -0,0 +1,27 @@
+package chess.piece;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import chess.Position;
+import java.util.Map;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+class BoardTest {
+
+    @Test
+    @DisplayName("보드 게임 셋업 테스트")
+    void test1() {
+        //given
+        //when
+        final Board board = Board.emptyBoard();
+        board.gameSetUp();
+        final Map<Position, Piece> mapView = board.getMapView();
+        //then
+        for (Map.Entry<Position, Piece> entry :mapView.entrySet()) {
+            System.out.println(entry);
+        }
+
+    }
+
+}
diff --git a/src/test/java/chess/piece/KingTest.java b/src/test/java/chess/piece/KingTest.java
new file mode 100644
index 0000000000..8318229dbc
--- /dev/null
+++ b/src/test/java/chess/piece/KingTest.java
@@ -0,0 +1,40 @@
+package chess.piece;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import chess.Color;
+import chess.Column;
+import chess.Position;
+import chess.Row;
+import java.util.List;
+import java.util.Map;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+class KingTest {
+
+
+    @Test
+    @DisplayName("킹의 이동 경로를 계산 한다")
+    void test1() {
+        //given
+        final Position position = new Position(Row.FIVE, Column.E);
+        final Map<Position, Piece> positionKnightMap = Map.of(new Position(Row.SIX, Column.E),
+                new Knight(new Position(Row.SIX, Column.E), Color.BLACK));
+        final Board board = new Board(positionKnightMap);
+
+        //when
+        final King king1 = new King(position, Color.BLACK);
+        final King king2 = new King(position, Color.WHITE);
+        final List<Position> positions1 = king1.calculateAvailablePositions(board);
+        final List<Position> positions2 = king2.calculateAvailablePositions(board);
+
+        //then
+        System.out.println(positions1);
+        System.out.println(positions1.size());
+        System.out.println(positions2);
+        System.out.println(positions2.size());
+
+    }
+
+}
diff --git a/src/test/java/chess/piece/KnightTest.java b/src/test/java/chess/piece/KnightTest.java
new file mode 100644
index 0000000000..3db0be2649
--- /dev/null
+++ b/src/test/java/chess/piece/KnightTest.java
@@ -0,0 +1,33 @@
+package chess.piece;
+
+import chess.Color;
+import chess.Column;
+import chess.Position;
+import chess.Row;
+import java.util.List;
+import java.util.Map;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+class KnightTest {
+
+    @Test
+    @DisplayName("나이트의 이동 경로를 계산한다")
+    void test1() {
+        //given
+        final Position position = new Position(Row.FIVE, Column.E);
+        final Map<Position, Piece> positionKnightMap = Map.of(new Position(Row.FIVE, Column.F),
+                new Knight(new Position(Row.FIVE, Column.F), Color.BLACK));
+        final Board board = new Board(positionKnightMap);
+
+        //when
+        final Knight knight = new Knight(position, Color.BLACK);
+        final List<Position> positions = knight.calculateAvailablePositions(board);
+
+        //then
+        System.out.println(positions);
+        System.out.println(positions.size());
+
+    }
+
+}
diff --git a/src/test/java/chess/piece/PawnTest.java b/src/test/java/chess/piece/PawnTest.java
new file mode 100644
index 0000000000..85329f9b12
--- /dev/null
+++ b/src/test/java/chess/piece/PawnTest.java
@@ -0,0 +1,41 @@
+package chess.piece;
+
+import chess.Color;
+import chess.Column;
+import chess.Position;
+import chess.Row;
+import java.util.List;
+import java.util.Map;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+class PawnTest {
+
+    @Test
+    @DisplayName("폰의 이동 경로를 계산 한다")
+    void test1() {
+        //given
+        final Position position = new Position(Row.FIVE, Column.E);
+        final Map<Position, Piece> positionKnightMap = Map.of(new Position(Row.SIX, Column.F),
+                new Knight(new Position(Row.SIX, Column.F), Color.BLACK));
+        final Board board = new Board(positionKnightMap);
+
+        //when
+        final Pawn pawn1 = new Pawn(position, Color.BLACK, false);
+        final Pawn pawn2 = new Pawn(position, Color.BLACK, true);
+        final Pawn pawn3 = new Pawn(position, Color.WHITE, false);
+        final List<Position> positions1 = pawn1.calculateAvailablePositions(board);
+        final List<Position> positions2 = pawn2.calculateAvailablePositions(board);
+        final List<Position> positions3 = pawn3.calculateAvailablePositions(board);
+
+        //then
+        System.out.println(positions1);
+        System.out.println(positions1.size());
+        System.out.println(positions2);
+        System.out.println(positions2.size());
+        System.out.println(positions3);
+        System.out.println(positions3.size());
+
+    }
+
+}
diff --git a/src/test/java/chess/piece/QueenTest.java b/src/test/java/chess/piece/QueenTest.java
new file mode 100644
index 0000000000..640c1d96b7
--- /dev/null
+++ b/src/test/java/chess/piece/QueenTest.java
@@ -0,0 +1,40 @@
+package chess.piece;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import chess.Color;
+import chess.Column;
+import chess.Position;
+import chess.Row;
+import java.util.List;
+import java.util.Map;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+class QueenTest {
+
+    @Test
+    @DisplayName("퀸의 이동 경로를 계산한다")
+    void test1() {
+        //given
+        final Position position = new Position(Row.FIVE, Column.E);
+        final Map<Position, Piece> positionKnightMap = Map.of(new Position(Row.EIGHT, Column.E),
+                new Knight(new Position(Row.SIX, Column.E), Color.BLACK));
+        final Board board = new Board(positionKnightMap);
+
+        //when
+        final Queen queen1 = new Queen(position, Color.BLACK);
+        final Queen queen2 = new Queen(position, Color.WHITE);
+        final List<Position> positions1 = queen1.calculateAvailablePositions(board);
+        final List<Position> positions2 = queen2.calculateAvailablePositions(board);
+
+
+        //then
+        System.out.println(positions1);
+        System.out.println(positions1.size());
+        System.out.println(positions2);
+        System.out.println(positions2.size());
+
+    }
+
+}
diff --git a/src/test/java/chess/piece/RookTest.java b/src/test/java/chess/piece/RookTest.java
new file mode 100644
index 0000000000..a435a84bad
--- /dev/null
+++ b/src/test/java/chess/piece/RookTest.java
@@ -0,0 +1,39 @@
+package chess.piece;
+
+import chess.Color;
+import chess.Column;
+import chess.Position;
+import chess.Row;
+import java.util.List;
+import java.util.Map;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+class RookTest {
+
+
+    @Test
+    @DisplayName("룩의 이동 경로를 계산한다")
+    void test1() {
+        //given
+        final Position position = new Position(Row.FIVE, Column.E);
+        final Map<Position, Piece> positionKnightMap = Map.of(new Position(Row.EIGHT, Column.E),
+                new Knight(new Position(Row.SIX, Column.E), Color.BLACK));
+        final Board board = new Board(positionKnightMap);
+
+        //when
+        final Rook rook1 = new Rook(position, Color.WHITE);
+        final Rook rook2 = new Rook(position, Color.BLACK);
+        final List<Position> positions1 = rook1.calculateAvailablePositions(board);
+        final List<Position> positions2 = rook2.calculateAvailablePositions(board);
+
+
+        //then
+        System.out.println(positions1);
+        System.out.println(positions1.size());
+        System.out.println(positions2);
+        System.out.println(positions2.size());
+
+    }
+
+}