오늘 ≤ 내일

옵저버 패턴에 대해 알아보자.

한 객체의 상태가 변경되면 그 객체에 의존하는 다른 객체들에게 자동으로 알림이 가고 업데이트가 이루어 지도록 하는 패턴

상태 변경 > 알림 > 업데이트 가 이루어진다.

기본 개념

Subject : 상태 변화를 감지하는 객체, 상태 변화가 발생했음을 알리는 역할을 함, 여러 옵저버를 등록하거나 해제함

Observer :  주체의 상태 변화를 듣고 이를 처리하는 객체, 업데이트 메서드를 통해 알림을 받는다.

동작 방식

1. 옵저버 등록 : 주체에 등록됨

2. 상태 변화 감지 : 주체가 상태 변화를 감지하면 등록된 모든 옵저버들에게 알림을 보냄

3. 업데이트 : 각 옵저버는 주체로부터 받은 알림을 통해 상태를 업데이트하거나 이에 따른 동작을 수행

장점

객체 간의 의존성이 줄어듬

옵저버 추가가 쉽고 독립적으로 처리 가능

단점

옵저버가 너무 많아지면 성능 저하가 발생

코드 복잡도가 증가함

이 패턴은 주로 이벤트 기반 시스템이나 GUI 애플리케이션에서 많이 사용된다.

예시 )

• 버튼 클릭, 마우스 이동, 키보드 입력과 같은 이벤트 발생 시 해당 이벤트를 감지하고 처리할 수 있도록 옵저버 패턴이 사용됨
• MVC 아키텍쳐에서 모델의 상태가 변경되면 뷰가 이를 자동으로 감지하고 갱신됨
• 구독자 들에게 자동으로 알림이 감
• 실시간 데이터 스트리밍 시스템으로 변화를 실시간으로 옵저버들에게 통지해 최신 정보 제공
• 캐릭터의 체력이 줄어들면 UI가 자동으로 업데이트 되어 체력바에 반영되고, 사운드가 재생

스레드 풀이란 무엇인가?

• 작업 요청이 들어오면 스레드를 재사용하여 작업을 처리하는 구조

미리 지정된 수의 스레드를 생성해 두고, 새로운 작업이 들어오면 기존에 생성된 스레드 중 하나를 할당

스레드가 작업을 완료하면, 해당 스레드는 소멸되지 않고 재사용될 수 있도록 대기 상태로 돌아감

보통 작업큐를 사용함

새로운 작업이 들어오면 작업은 큐에 저장되고, 풀에 있는 스레드 중 하나가 해당 작업을 처리함

만약 모든 스레드가 이미 바쁘다면 작업은 큐에 저장되어 기다림

자바에서 제공하는 스레드 풀은 동적으로 스레드의 수를 조절

예시
식당에 주방장이 3명 있다고 가정하면, 요리 주문이 들어올 때마다 새로운 주방장을 고용하는 대신 미리 잇는 3명의 주방장이 순서대로 일을 처리하고 다시 다음 주문을 기다리는 것과 같음. 주방장 수를 조절해서 리소스를 효율적으로 관리함

Maven이란 

자바 기반의 프로젝트 관리 도구

프로젝트 빌드, 의존성 관리, 프로젝트 배포 등을 자동화하는 데 사용 !

프로젝트의 모든 단계를 체계적으로 관리

ProjectObjectModel ( POM )

- Maven에서 가장 중요한 파일이다. (pom.xml)

프로젝트의 의존성, 빌드 설정, 플러그인 등의 정보를 포함

장점

의존성 관리. 
프로젝트에서 필요한 라이브러리를 자동으로 관리해주는 기능

LifeCycle

Maven은 프로젝트 빌드를 단계적으로 처리하는 라이프사이클을 가짐

1. Clean : 이전 빌드에서 생성된 파일을 삭제
2. validate : 프로젝트가 정상적으로 구성되었는지 확인
3. compile : 소스 코드를 컴파일
4. test :  단위 테스트를 실행 / 테스트 코드가 실행됨
5. package : 컴파일된 코드를 JAR 파일이나 WAR 파일 등의 형식으로 패키징함
6. verify : 통합 테스트 결과나 품질 기준 등을 검증
7. install : 패키징된 결과물을 로컬 Maven저장소에 설치
8. deploy : 패키징된 결과물을 원격 저장소에 배포
9. site : 프로젝트의 사이트 문서를 생성

라이프사이클을 아는 것은 중요하다. 

태그

각 태그별 설명

groupId	프로젝트가 속한 그룹
artifactId	프로젝트의 이름
version	프로젝트의 버전
dependencies	프로젝트에서 필요한 외부 라이브러리를 정의
scope	의존성의 사용 범위를 정의함 ( 컴파일, 테스트 , 실행과 같은 범위)
build	프로젝트 빌드 관련 설정을 정의 ( 빌드 결과물에 대한 설정 )
finalName	빌드된 결과물의 최종 이름을 설정
plugins	Maven  빌드에 사용할 플러그인을 정의 ( 다양한 빌드 작업을 자동화 )
plugin	특정 작업을 수행할 때 사용 ( 컴파일러 플러그인 , 테스트 플러그인 등)
configuration	플러그인의 동작을 설정
properties	프로젝트에서 사용할 전역 속성을 정의

wait과 notify는 Object클래스에 정의 되어있는 스레드 간의 동기화를 위해 사용되는 메서드이다.

여러 스레드가 공유 자원에 접근할 때 효율적으로 자원을 사용할 수 있도록 도와준다.

wait()

현재 스레드를 일시 정지시킨다. 이 메서드를 호출한 스레드는 특정 조건이 충족될때까지 기다린다.

synchronized 블록 안에서만 사용이 가능한다. 메서드를 호출한 스레드는 공유 자원을 잠금 상태에서 해제하고 다른 스레드들이 해당 자원을 사용할 수 있게 된다.

notify()

wait()상태에 있는 스레드 중 하나를 깨워서 실행될 수 있도록 한다.

synchronized 블록안에서만 사용할 수 있다. 이 메서드를 호출한 스레드는 대기 중인 스레드를 깨워서 자원을 사용할 수 있게 만든다.

이번에 과제는 AST를 통한 계산기만들어보기이다.

만드는 과정에서 주어진 부분이 함수 리턴 값 , 함수명과 결과값, AST를 만들것이었다.

우선적으로 커스텀 Exception 을 만들고 수식 검사를 통해 수식이 잘못 입력되었으면 에러처리한다.

static Node generateAST(String expression) {}
static int evaluation(Node ast) { };

이 두개를 꼭 구현해야되고

System.out.println(generateAST(expression));

를 출력했을 때 

(((1),+,(((2),*,(3)),/,(4))),-,(5))

이런식으로 결과값이 나와야된다.

처음에 무작정 트리로 계산기를 만들다가 Node 를 출력했을때 이렇게 나오는 것을 보고 코드를 지우고 새로 다시 작성했다.

먼저 그림을 그려보면 중위 탐색으로 만들거라 중위 탐색으로 트리를 그렸다.

결과 값을 보고 그려본 결과

이렇게 생긴 구조였고 이것을 보고 Node에 트리를 구성하였다.

리프 노드는 무조건 숫자 라는 부분을 활용하였고 연산자를 삽입할때 루트의 연산자와 비교하여 연산자 우선순위가 높은 경우 오른쪽에 삽입하는 방식으로 구성하였다.

코드

import java.util.Scanner;

public class JBGW08_006_AST {

    static Node generateAST(String expression) throws InvalidExpressionException {
        return new Node(expression);
    }

    static int evaluation(Node ast) {
        return ast.evaluation();
    }

    public static void main(String[] arg) {
        Scanner scanner = new Scanner(System.in);

        while (true) {
            System.out.print("> ");
            String expression = scanner.nextLine();
            if (expression.equals("exit()")) {
                return;
            }
            try {
                System.out.println(generateAST(expression));
                System.out.println(evaluation(generateAST(expression)));
            } catch (InvalidExpressionException e) {
                e.printStackTrace();
                return;
            }
        }
    }
}




// 다른 파일


public class Node {
    String key;
    Node left, right;
    static Node root;
    static int result;

    private Node() {
        this.left = this.right = null;
    }

    public Node(String expression) throws InvalidExpressionException {
        root = null;
        makeTree(expression);
        result = calculate(root);
    }

    private void makeTree(String expression) throws InvalidExpressionException {
        if (!isExpression(expression)) {
            throw new InvalidExpressionException("수식이 잘못됨");
        }
        String partOfExpression[] = expression.split(" ");

        for (int i = 0; i < partOfExpression.length; i++) {
            if (root == null) {
                root = new Node();
                root.setKey(partOfExpression[i]);
            } else if (isOperator(partOfExpression[i])) {
                if (LowOP(root.key) && HighOP(partOfExpression[i])) {
                    Node newnode = new Node();
                    newnode.setKey(partOfExpression[i]);
                    newnode.setLeftNode(root.right);
                    root.right = newnode;
                } else {
                    Node newnode = new Node();
                    newnode.setKey(partOfExpression[i]);
                    newnode.setLeftNode(root);
                    root = newnode;
                }
            } else {
                Node newnode = new Node();
                newnode.setKey(partOfExpression[i]);
                if (root.right == null) {
                    root.setRightNode(newnode);
                } else {
                    root.right.setRightNode(newnode);
                }
            }
        }
    }

    private int calculate(Node root) {
        if (root.left == null && root.right == null) {
            return Integer.parseInt(root.key);
        } else if (root.key.equals("+"))
            return calculate(root.left) + calculate(root.right);
        else if (root.key.equals("-"))
            return calculate(root.left) - calculate(root.right);
        else if (root.key.equals("*"))
            return calculate(root.left) * calculate(root.right);
        else if (root.key.equals("/"))
            return calculate(root.left) / calculate(root.right);

        return -1; // error
    }

    private boolean isExpression(String expression) {
        String[] seperate = expression.split(" ");

        if (seperate.length % 2 == 0)
            return false;

        for (int i = 0; i < seperate.length; i++) {
            if (i % 2 == 1 && isNumber(seperate[i])) {
                return false;
            } else if (i % 2 == 0 && isOperator(seperate[i])) {
                return false;
            }
        }

        return true;
    }

    private boolean isNumber(String number) {
        try {
            Integer.parseInt(number);
            return true;
        } catch (NumberFormatException e) {
            return false;
        }
    }

    private boolean isOperator(String operator) {
        return LowOP(operator) || HighOP(operator);
    }

    private boolean HighOP(String operator) {
        return operator.equals("*") || operator.equals("/");

    }

    private boolean LowOP(String operator) {
        return operator.equals("+") || operator.equals("-");
    }

    public int evaluation() {
        return result;
    }

    private void setKey(String input) {
        this.key = input;
    }

    private void setLeftNode(Node node) {
        this.left = node;
    }

    private void setRightNode(Node node) {
        this.right = node;
    }

    private String inorder(Node current) {
        if (current != null) {
            return "(" + inorder(current.left) + (isOperator(current.key) ? "," : "") + current.key
                    + (isOperator(current.key) ? "," : "") + inorder(current.right) + ")";
        }
        return "";
    }

    @Override
    public String toString() {
        return inorder(root);
    }
}

중위 순회를 통해 toString 메소드를 구성하였다.

오늘 배운 것은 디자인 패턴 중에 싱글톤 , 프로토타입 , 팩토리메서드 이다.

싱글톤은 인스턴스 하나만 사용하는 패턴으로  객체에 Static을 활용한다. 생성자를 외부에서 사용할 수 없게 private로 선언한다. 

프로토타입은 clone을 활용하여 객체를 복사하여 반환해주는 패턴이다.

팩토리 메서드는 어노테이션을 통하여 객체의 생성 방식을 싱글톤 또는 프로토타입을 정하는 방식으로 실습을 해보았다.

밑에 코드 처럼쓰는게 팩토리 메서드 느낌이다. 

• Product (제품): 생성될 객체의 인터페이스를 정의
• ConcreteProduct (구체적인 제품): 실제로 생성될 객체를 구현한 클래스
• Creator (생성자): 팩토리 메서드를 정의하는 상위 클래스이며, 객체를 생성하는 작업을 서브클래스에서 수행
• ConcreteCreator (구체적인 생성자): 팩토리 메서드를 실제로 구현하는 하위 클래스

코드

// Product 인터페이스
interface Product {
    void use();
}

// ConcreteProduct (구체적인 제품)
class ConcreteProductA implements Product {
    public void use() {
        System.out.println("Using product A");
    }
}

class ConcreteProductB implements Product {
    public void use() {
        System.out.println("Using product B");
    }
}

// Creator (생성자)
abstract class Creator {
    // 팩토리 메서드 (서브클래스에서 구현)
    public abstract Product createProduct();

    // 클라이언트는 이 메서드를 통해 객체를 사용할 수 있음
    public void useProduct() {
        Product product = createProduct();
        product.use();
    }
}

// ConcreteCreator (구체적인 생성자)
class ConcreteCreatorA extends Creator {
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

class ConcreteCreatorB extends Creator {
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

컬렉션은 요소로 구성된 개체이다.

배열은 요소를 메모리상에 연속적으로 저장한다. 

컬렉션은 요소의 저장 방식을 추상화 한다.

키워드 : 추상화 , ADT

자바 컬렉션 프레임워크 구성은 철저히 테스트된 다양한 인터페이스 와 클래스로 구성

Iterable<T> : 반복할수있음 ( Interface )

Collection<E> : 컬렉션이 구현해야 할 공통적인 메소드를 가지고 있음 ( Interface ) (Iterable을 확장)

Iterator : 반복을 어떻게할것인지 정의

Comparable : 비교 가능 ( 정렬 할 수 있음 ) 

Comparator : 정렬 기준

List는 인터페이스 : 중복을 허용 / 저장 순서가 유지 되는 자료 구조

List를 구현한 클래스 : 링크드 리스트 , 어레이 리스트, 벡터 , 스택

LinkedList : 노드로 연결하는 방식 

큐 : 인터페이스이며 LinkedList로 구현

Vector는 레거시 클래스로 더 이상 사용할 필요가 없으나 코드 호환성을 위해 남아 있음 (ArrayList 사용하면됨)

스택은 스택이다.

오늘은 과제를 정말 열심히했다.

포커 게임을 간단하게 구현하는 과제다.

열심히 구현했는데 로티플 뽑고 자야겠다.

import java.util.Scanner;
import java.util.Random;
import java.util.List;
import java.util.ArrayList;
import java.util.Collections;

enum Pattern {
    SPADE("♠"), DIAMOND("◆"), HEART("♥"), CLUB("♣");

    private String pattern;

    Pattern(String pattern) {
        this.pattern = pattern;
    }

    String getPattern() {
        return this.pattern;
    }
}

enum Number {
    TWO("2"),
    THREE("3"),
    FOUR("4"),
    FIVE("5"),
    SIX("6"),
    SEVEN("7"),
    EIGHT("8"),
    NINE("9"),
    TEN("10"),
    JACK("J"),
    QUEEN("Q"),
    KING("K"),
    ACE("A");

    private String value;

    Number(String value) {
        this.value = value;
    }

    public String getValue() {
        return this.value;
    }

}

enum Rank {
    StraightFlush,
    FourCard,
    FullHouse,
    Flush,
    Straight,
    Treple,
    TwoPairs,
    OnePairs,
    HighCard;

}

class Card implements Comparable<Card> { // 카드관리
    private Pattern pattern;
    private Number number;

    public Card(Pattern pattern, Number number) {
        this.pattern = pattern;
        this.number = number;
    }

    public Pattern getPattern() {
        return this.pattern;
    }

    public Number getNumber() {
        return this.number;
    }

    @Override
    public int compareTo(Card o) {
        if (this.getNumber().ordinal() == o.getNumber().ordinal())
            return o.getPattern().ordinal() - this.getPattern().ordinal();
        return this.getNumber().ordinal() - o.getNumber().ordinal();
    }

    @Override
    public String toString() {
        return this.pattern.getPattern() + " " + this.number.getValue();
    }
}

class Deck { // 전체 52장관리
    private boolean deckList[][];
    private static Deck deck;

    private Deck() {
        deckList = new boolean[4][13];
    }

    public static Deck getInstance() {
        if (deck == null) {
            deck = new Deck();
        }
        return deck;
    }

    public Card draw() { // 카드 뽑기
        Random random = new Random();
        Pattern[] patterns = Pattern.values();
        Pattern cardpattern;
        Number[] numbers = Number.values();
        Number cardNumber;
        while (true) {
            cardpattern = patterns[random.nextInt(patterns.length)];
            cardNumber = numbers[random.nextInt(numbers.length)];
            if (!deckList[cardpattern.ordinal()][cardNumber.ordinal()]) {
                deckList[cardpattern.ordinal()][cardNumber.ordinal()] = true;
                return new Card(cardpattern, cardNumber);
            }
        }
    }

}

class Player implements Comparable<Player> {
    protected String name;
    protected List<Card> cardList;
    protected Rank rank;
    protected Card top;

    Player(String name) {
        this.name = name;
        cardList = new ArrayList<>();
        rank = Rank.HighCard;
    }

    @Override
    public int compareTo(Player o) {
        if (this.rank.ordinal() == o.rank.ordinal()) {
            if (top.getNumber().ordinal() == o.top.getNumber().ordinal()) {
                return top.getPattern().ordinal() - o.top.getPattern().ordinal();
            }
            return o.top.getNumber().ordinal() - top.getNumber().ordinal();
        }
        return this.rank.ordinal() - o.rank.ordinal();
    }

    String getName() {
        return this.name;
    }

    void addCard(Card card) {
        cardList.add(card);
    }

    void sortCard() {
        Collections.sort(cardList);
        this.top = cardList.get(4);
    }

    boolean isStraight() {
        for (int i = 0; i < 3; i++) {
            if (cardList.get(i).getNumber().ordinal() + 1 != cardList.get(i + 1).getNumber().ordinal())
                return false;
        }
        Number lastValue = cardList.get(4).getNumber();
        if (cardList.get(0).getNumber().getValue() == "2" && lastValue.getValue() == "A") {
            this.top = cardList.get(3);
            return true;
        } else if (lastValue.ordinal() == cardList.get(3).getNumber().ordinal() + 1) {
            this.top = cardList.get(4);
            return true;
        }
        return false;
    }

    boolean isFlush() {
        for (int i = 1; i < cardList.size(); i++) {
            if (cardList.get(0).getPattern() != cardList.get(i).getPattern())
                return false;
        }
        this.top = cardList.get(4);
        return true;
    }

    boolean isPair(Card card1, Card card2) {
        return card1.getNumber() == card2.getNumber();
    }

    boolean isTreple(Card card1, Card card2, Card card3) {
        return isPair(card1, card2) && isPair(card2, card3);
    }

    boolean isFour(Card card1, Card card2, Card card3, Card card4) {
        return isTreple(card1, card2, card3) && isPair(card3, card4);
    }

    boolean isFullHouse() {
        if (isTreple(cardList.get(0), cardList.get(1), cardList.get(2))
                && isPair(cardList.get(3), cardList.get(4))) {
            this.top = cardList.get(2);
            return true;
        } else if (isTreple(cardList.get(4), cardList.get(3), cardList.get(2))
                && isPair(cardList.get(1), cardList.get(0))) {
            this.top = cardList.get(4);
            return true;
        }
        return false;

    }

    boolean isFourCard() {
        if (isFour(cardList.get(0), cardList.get(1), cardList.get(2), cardList.get(3))) {
            this.top = cardList.get(3);
            return true;
        } else if (isFour(cardList.get(1), cardList.get(2), cardList.get(3), cardList.get(4))) {
            this.top = cardList.get(4);
            return true;
        }
        return false;
    }

    boolean isTrepleCard() {
        if (isTreple(cardList.get(0), cardList.get(1), cardList.get(2))) {
            this.top = cardList.get(2);
            return true;
        } else if (isTreple(cardList.get(1), cardList.get(2), cardList.get(3))) {
            this.top = cardList.get(3);
            return true;
        } else if (isTreple(cardList.get(2), cardList.get(3), cardList.get(4))) {
            this.top = cardList.get(4);
            return true;
        }
        return false;

    }

    int PairCount() {
        int count = 0;
        for (int i = 0; i < cardList.size() - 1; i++) {
            if (isPair(cardList.get(i), cardList.get(i + 1))) {
                this.top = cardList.get(i + 1);
                count++;
            }
        }
        return count;
    }

    boolean isTwoPair() {
        return PairCount() == 2;
    }

    boolean isOnePair() {
        return PairCount() == 1;
    }

    void printCard() {
        System.out.println("Player: " + this.name + "\n" + rank.name() + " " + top);

        for (Card card : cardList) {
            System.out.print(card + " ");
        }

        System.out.println();
    }

    void rankHands() {
        if (isFlush() && isStraight()) {
            this.rank = Rank.StraightFlush;
        } else if (isFourCard()) {
            this.rank = Rank.FourCard;
        } else if (isFullHouse()) {
            this.rank = Rank.FullHouse;
        } else if (isFlush()) {
            this.rank = Rank.Flush;
        } else if (isStraight()) {
            this.rank = Rank.Straight;
        } else if (isTrepleCard()) {
            this.rank = Rank.Treple;
        } else if (isTwoPair()) {
            this.rank = Rank.TwoPairs;
        } else if (isOnePair()) {
            this.rank = Rank.OnePairs;
        } else
            this.rank = Rank.HighCard;
    }
}

public class JBGW08_006_Poker {

    public static void GameStart(List<Player> players) {

        Deck deck = Deck.getInstance();

        for (int i = 0; i < 5; i++) {
            for (Player player : players) {
                player.addCard(deck.draw());
            }
        }

        for (Player player : players) {
            player.sortCard();
            player.rankHands();
        }
        Collections.sort(players);

        for (Player player : players) {
            player.printCard();
            System.out.println();
        }

        System.out.print("Winner : " + players.get(0).getName());
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        Player[] palyerlist = {
                new Player("Stive"),
                new Player("Mama"),
                new Player("Choco"),
                new Player("Jimmy")
        };
        System.out.print("플레이어가 몇 명 인가요? (2 ~ 5명 ) : ");
        int numberOfPlayer = sc.nextInt();

        if (numberOfPlayer < 2 || numberOfPlayer > 5) {
            throw new IllegalArgumentException("2 ~ 5명만 가능합니다.");
        }
        System.out.print("사용자의 이름을 입력해주세요 : ");
        String username = sc.next();

        List<Player> players = new ArrayList<>();
        players.add(new Player(username));
        for (int i = 1; i < numberOfPlayer; i++) {
            players.add(palyerlist[i - 1]);
        }
        GameStart(players);
    }
}

클래스란 객체에 대한 정의를 해 놓은것 (자동차 설계도)

객체란 클래스를 생성한것 (자동차)

인스턴스란 클래스를 생성한 것을 낱개로 나눈것 (자동차 1, 자동차 2)

추상화란 불필요한 것을 선택하고 제거하는 것

캡슐화란 캡슐처럼 하나로 묶는 것

캡슐화 하는 이유는 경계를 확실히 하여 외부에서 내부를 건들지 못하게 막는 것

정적 데이터 란 클래스에서 호출됨. ( 객체가 공유한다. )

인스턴스 생성은 new 키워드를 사용

참조 타입은 주소를 통한 객체를 다룬다

참조 타입 변수 해제는 null을 사용

컴파일은 코드를 실행가능하게 바꾸는 과정

런타임은 코드를 실행하는 중

참조타입 비교연산은 항상 주의

데이터 중에 몇 가지로 한정된 값 만을 갖는 경우 enum을 사용

Exception 객체를 생성하거나 던져서 예외를 발생시킴

String 클래스에 다양한 기능이 있음

Object 타입은 조상님

슈퍼 클래스는 부모님이상

Object의 메소드 toString , equals , clone , finalize

패키지는 디렉토리

instanceof연산자는 객체의 타입을 확인

싱글톤 패턴의 목적은 클래스가 단 하나의 인스턴스만 가지도록 보장하고 이에 대한 전역 액세스 지점을 제공

static 생성자는 객체 인스턴스가 생성되기 전에 동작(JAVA는 지원하지 않음)

객체 제거는 가비지 컬렉터가 자동으로

mark-and-sweep방식으로 제거   >  마크 하고 마크 되지 않는 메모리들을 한번에 스윕~!

오늘은 과제하는날.

먼저 과제는 틱택토게임 만들기

1. 3x3 보드를 만든다.

2. 컴퓨터가 랜덤으로 둔다.

3. 승리 확인을 한다.

4. 사용자가 위치를 지정한다.

5. 잘못된 위치면 오류 처리 / 잘 둔 위치면 승리 확인으로 넘어간다.

6. 판이 다찰때까지 2,3,4,5를 반복한다. 판이 다차면 무승부

여기서 사용자 정의 예외처리 만드는 방법을 보고 예외처리를 했다.

그리고 컴퓨터가 랜덤으로 두는게 너무 빨라서 Sleep함수를 검색해서 넣어보았다.

import java.util.Random;
import java.util.Scanner;




class InputException extends Exception{
    public InputException(){}
    public InputException(String message){super(message);}
}

public class Tictactoe
{
    static char[][] board={
        {' ', ' ', ' '},
        {' ', ' ', ' '},
        {' ', ' ', ' '}
    };

    static boolean isUsed[] = new boolean[9];

    static int winConditions[][] ={
        {0,1,2},{0,4,8},{0,3,6},
        {1,4,7},{2,5,8},{3,4,5},
        {6,7,8},{2,4,6}
    };

    public static void printBoard()
    {
        System.out.println();
        for(int j=0; j<3; j++){
            int index = 0;
            for(int i = 0 ; i < 10; i++)
            {
                if(( i +1 ) % 4 == 0)
                {
                    System.out.print("|");
                }
                else if( ( i + 1 ) % 2 == 0)
                {
                    System.out.print(board[j][index++]);

                }
                else 
                {
                    System.out.print(" ");
                }
            }
            System.out.println();
            if(j<2)
            System.out.println("-----------");
        }
        System.out.println();
    }


    

    public static void userInput(String input)
    {
        
        try
        {
            int place[] = new int[2];
            for(int i = 0,index= 0 ; i<input.length(); i++)
            {
                if(input.charAt(i) >= '0' && input.charAt(i)<='9')
                place[index++] = input.charAt(i) - '0';
            }
            if(board[place[0]][place[1]] != ' ')
            {
                throw new InputException();
            }

            board[place[0]][place[1]] = 'O';
            isUsed[place[0]*3+place[1]] = true;

            
        }
        catch(InputException e)
            {
                System.out.println("사용중인 칸입니다.");
                retryInput();
            }
        catch(Exception e)
        {
                System.out.println("칸을 벗어났습니다.");
                retryInput();
        }
    

    }

    private static void retryInput() {
        Scanner scanner = new Scanner(System.in);
        System.out.print("입력 (x,y): ");
        String newInput = scanner.nextLine();
        userInput(newInput);
    }

    public static boolean isEnd(){
        
        
        for(int i = 0 ; i < 8 ; i ++)
        {
            int checkPoint[] = winConditions[i];
            boolean isFound = true;

            if(board[checkPoint[0]/3][checkPoint[0]%3] == ' ')continue;

            char checkValue = board[checkPoint[0]/3][checkPoint[0]%3];

            for(int j= 1 ; j <3; j++)
            {
                if(checkValue != board[checkPoint[j]/3][checkPoint[j]%3])
                {
                    isFound = false;
                    break;
                }
            }
            if(isFound) return true;
        }
        return false;
    }

    public static void computerInput()
    {
        System.out.print("Considering.");
        try{
            for(int i = 0 ; i < 3; i++){
                Thread.sleep(1000);
                System.out.print(".");
            }
        }
        catch(Exception e)
        {

        }
        
        System.out.println();
        Random random = new Random();
        int randomInt = random.nextInt(9);
        while(isUsed[randomInt]) randomInt=random.nextInt(9);
        board[randomInt/3][randomInt%3] = 'X';
        isUsed[randomInt]=true;
    }

    public static boolean isDraw()
    {
        for(int i = 0 ; i <3 ; i ++)
        {
            for(int j = 0 ; j < 3; j ++)
            {
                if(board[i][j] == ' ')
                {
                    return false;
                }
            }
        }
        return true;
    }
    public static void main(String[] args)
    {
        Scanner scanner = new Scanner(System.in);

        
        while(true){

        printBoard();
        
       

        System.out.println("Computer Turn\n");
        computerInput();
        printBoard();
        if(isEnd())
        {
            System.out.println("Computer Win");
            break;
        }

        System.out.println("User Turn\n");
        System.out.print("입력 (x,y): ");
        String input = scanner.nextLine();
        userInput(input);
        
        
        if(isEnd())
        {
            printBoard();
            System.out.println("You Win");
            break;
        }
        
        if(isDraw())
        {
            System.out.println("Draw");
            break;
        }


        }

        
    }
    
}

2일차 오늘 배운것은 JAVA 중에서 조건문, 콜스택과 Primitive type, Reference type에 대해 배웠다.

Statement (문) 과 Expression 에 대한 차이도 배웠다.

간단한 정리로

Statement와 Expression의 차이는 Expression은 수식 과 같은 표현식 이고 Statement는 Expression도 Statement로 볼 수 있고 다양한 구문들이 Statement로 불린다. 그냥 적당히 한줄의 코드 또는 한 코드 문장을 뜻한다.