[레벨 1] 06. 2단계 - 블랙잭(베팅)

`럿고`: `System.lineSeparator()` 이걸 한번 알아보면 어떠신가요?

public class PrintStream extends FilterOutputStream
    implements Appendable, Closeable
{
    ...
    public void println(String x) {
        synchronized (this) {
            print(x);
            newLine(); // <- 클릭
        }
    }
    ...
}

public class PrintStream extends FilterOutputStream
    implements Appendable, Closeable
{
    ...
    private void newLine() {
        try {
            synchronized (this) {
                ensureOpen();
                textOut.newLine(); // <- 클릭
                textOut.flushBuffer();
                charOut.flushBuffer();
                if (autoFlush)
                    out.flush();
            }
        }
        catch (InterruptedIOException x) {
            Thread.currentThread().interrupt();
        }
        catch (IOException x) {
            trouble = true;
        }
    }
    ...
}

public class BufferedWriter extends Writer {
    ...
    public void newLine() throws IOException {
        write(System.lineSeparator()); // 사용되는 것을 확인
    }
    ...
}

`럿고`: findFirst()가 더 맞지 않을까요?

`럿고`: BigDecimal을 선택하신 이유가 있나요?

`매트`: 배팅 머니라서 돈이라는 도메인을 다루기 위해 BigDecimal을 사용하였습니다. Java에서 실수는 기본적으로 `부동 소수점 방식`을 활용하기 때문에 `연산 시 정확한 답을 보장하지 않는다`고 학습한 경험이 있습니다. 다양한 승리 조건에 따라 1.5, 1, 0 등을 곱해야 하기 때문에 단순히 double로 연산하게 될 경우 소중한 돈이 변경될 것을 우려하여 BigDecimal을 사용하였습니다! 

`럿고`: 좋은 근거입니다~ 👍

public class BettingMoney {

    private static final int MONEY_SCALE = 0;
    private static final int MONEY_LENGTH = 4;
    private static final String MONEY_DIVIDE_STANDARD = "000";

    public static final BettingMoney ZERO = new BettingMoney(BigDecimal.ZERO);

    private final BigDecimal amount;

    private BettingMoney(BigDecimal bigDecimal) {
        this.amount = bigDecimal.setScale(MONEY_SCALE, RoundingMode.FLOOR);
    }

    public static BettingMoney of(String amount) {
        validateLength(amount);
        validateDivide(amount);
        return new BettingMoney(new BigDecimal(amount));
    }

    private static void validateLength(String amount) {
        if (amount.length() < MONEY_LENGTH) {
            throw new IllegalArgumentException("배팅 금액은 1000원 이상입니다.");
        }
    }

    private static void validateDivide(String amount) {
        if (!amount.endsWith(MONEY_DIVIDE_STANDARD)) {
            throw new IllegalArgumentException("배팅 금액은 1000으로 나누어 떨어져야 합니다.");
        }
    }

    public BettingMoney times(double percent) {
        BigDecimal multiplied = BigDecimal.valueOf(percent);
        BigDecimal result = amount.multiply(multiplied);
        return new BettingMoney(result);
    }

    public BettingMoney add(BettingMoney otherBettingMoney) {
        BigDecimal add = amount.add(otherBettingMoney.amount);
        return new BettingMoney(add);
    }

    public String getAmount() {
        return amount.toString();
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        BettingMoney that = (BettingMoney) o;
        return Objects.equals(amount.toString(), that.amount.toString());
    }

    @Override
    public int hashCode() {
        return Objects.hash(amount);
    }
}

`럿고`: `new Name("딜러");` 자체를 상수로 관리해도 될듯 한데, 혹시 어떻게 생각하실까요?

상태 패턴은 특정 기능을 수행한 뒤 다음 상태를 반환하는 것이다. 동일한 메서드가 상태에 따라 다르게 동작할 수 있도록 별도의 하위 타입으로 구현한다. 같은 기능을 단순히 조건문을 활용할 경우 상태가 추가될 때마다 조건문도 함께 추가된다. 하지만 상태 패턴을 사용하게 될 경우 코드의 복잡도가 증가하지 않고 상태를 추가할 수 있다.

public interface State {

    State draw(Card card);

    State stay();

    boolean isRunning();

    boolean isFinished();

    Cards cards();

    double earningRate(State state);
}

public class Blackjack extends Finished {

    protected Blackjack(Cards cards) {
        super(cards);
    }
    ...
}

public abstract class Finished extends Started {

    protected static final double BLACKJACK_WIN_RATE = 1.5;
    protected static final int WIN_RATE = 1;
    protected static final int TIE_RATE = 0;
    protected static final int LOW_RATE = -1;

    protected Finished(Cards cards) {
        super(cards);
    }

    @Override
    public final State draw(Card card) {
        throw new IllegalStateException("카드를 뽑을 수 없는 상태입니다.");
    }

    @Override
    public final State stay() {
        throw new IllegalStateException("스테이 상태로 변경할 수 없습니다.");
    }

    @Override
    public final boolean isRunning() {
        return false;
    }

    @Override
    public final boolean isFinished() {
        return true;
    }
}

`럿고`: `this(Collections.emptyList());` 이런식으로 작성이 불가능 할까요?