condition.isSatisfiedBy(screening);
    ↑           ↑            ↑
 수신자    오퍼레이션명    인자(argument)

DiscountCondition condition = ...;  // 실제 타입은 모름
condition.isSatisfiedBy(screening);

// 같은 오퍼레이션 호출
DiscountCondition condition1 = new PeriodCondition(...);
DiscountCondition condition2 = new SequenceCondition(...);

condition1.isSatisfiedBy(screening);  // Period 메서드 실행
condition2.isSatisfiedBy(screening);  // Sequence 메서드 실행

public class ReservationAgency {
    public Reservation reserve(Screening screening, Customer customer,
                               int audienceCount) {
        // ❌ Screening의 내부 깊숙이 침투
        Movie movie = screening.getMovie();
        
        boolean discountable = false;
        for(DiscountCondition condition : movie.getDiscountConditions()) {
            if (condition.getType() == DiscountConditionType.PERIOD) {
                // ❌ 기차 충돌!
                discountable = 
                    screening.getWhenScreened().getDayOfWeek()
                             .equals(condition.getDayOfWeek()) &&
                    condition.getStartTime()
                             .compareTo(screening.getWhenScreened()
                                                 .toLocalTime()) <= 0 &&
                    condition.getEndTime()
                             .compareTo(screening.getWhenScreened()
                                                 .toLocalTime()) >= 0;
            } else {
                discountable = 
                    condition.getSequence() == screening.getSequence();
            }
            
            if (discountable) {
                break;
            }
        }
        // ...
    }
}

public class ReservationAgency {
    public Reservation reserve(Screening screening, Customer customer,
                               int audienceCount) {
        // ✅ Screening에게만 메시지 전송
        Money fee = screening.calculateFee(audienceCount);
        
        return new Reservation(customer, screening, fee, audienceCount);
    }
}

// ❌ 기차 충돌의 전형
screening.getMovie().getDiscountConditions();
    ↓         ↓              ↓
   1량차      2량차          3량차

// ❌ 더 심한 경우
screening.getMovie()
         .getDiscountConditions()
         .get(0)
         .getDayOfWeek()
         .getValue();

// ❌ Before: 기차 충돌
screening.getMovie().getDiscountConditions();

// ✅ After: 하나의 메시지
screening.calculateFee(audienceCount);

// Step 1: Screening에 메서드 추가
public class Screening {
    private Movie movie;
    
    // ✅ 내부에서 Movie에게 위임
    public Money calculateFee(int audienceCount) {
        return movie.calculateMovieFee(this).times(audienceCount);
    }
}

// Step 2: Movie에 메서드 추가
public class Movie {
    private List<DiscountCondition> discountConditions;
    
    // ✅ 내부에서 DiscountCondition들과 협력
    public Money calculateMovieFee(Screening screening) {
        if (isDiscountable(screening)) {
            return fee.minus(calculateDiscountAmount());
        }
        return fee;
    }
    
    private boolean isDiscountable(Screening screening) {
        return discountConditions.stream()
                .anyMatch(condition -> condition.isSatisfiedBy(screening));
    }
}

// 부끄럼타는 코드 = 필요한 것만 공개
public class Screening {
    private Movie movie;          // ❌ 보여주지 않음
    private LocalDateTime when;   // ❌ 보여주지 않음
    
    // ✅ 꼭 필요한 것만
    public Money calculateFee(int audienceCount) {
        return movie.calculateMovieFee(this).times(audienceCount);
    }
}

// 정보와 행동이 함께
public class Movie {
    private List<DiscountCondition> discountConditions;  // 정보
    
    // ✅ 정보를 사용하는 행동도 여기에
    private boolean isDiscountable(Screening screening) {
        return discountConditions.stream()
                .anyMatch(condition -> condition.isSatisfiedBy(screening));
    }
}

public class Theater {
    private TicketSeller ticketSeller;
    
    public void enter(Audience audience) {
        // ❌ 묻고 있다: "초대권 있니?"
        if (audience.getBag().hasInvitation()) {
            Ticket ticket = ticketSeller.getTicketOffice().getTicket();
            // ❌ 직접 조작
            audience.getBag().setTicket(ticket);
        } else {
            Ticket ticket = ticketSeller.getTicketOffice().getTicket();
            // ❌ 묻고, 판단하고, 조작
            audience.getBag().minusAmount(ticket.getFee());
            ticketSeller.getTicketOffice().plusAmount(ticket.getFee());
            audience.getBag().setTicket(ticket);
        }
    }
}

// ✅ Theater: 시키기만 함
public class Theater {
    private TicketSeller ticketSeller;
    
    public void enter(Audience audience) {
        // ✅ TicketSeller에게 시킴
        ticketSeller.sellTo(audience);
    }
}

// ✅ TicketSeller: 자신의 일을 처리
public class TicketSeller {
    private TicketOffice ticketOffice;
    
    public void sellTo(Audience audience) {
        // ✅ Audience에게 시킴
        ticketOffice.plusAmount(
            audience.buy(ticketOffice.getTicket())
        );
    }
}

// ✅ Audience: 자신의 일을 처리
public class Audience {
    private Bag bag;
    
    public Long buy(Ticket ticket) {
        // ✅ Bag에게 시킴
        return bag.hold(ticket);
    }
}

// ✅ Bag: 자신의 상태를 스스로 관리
public class Bag {
    private Long amount;
    private Invitation invitation;
    private Ticket ticket;
    
    public Long hold(Ticket ticket) {
        // ✅ 스스로 판단하고 처리
        if (hasInvitation()) {
            this.ticket = ticket;
            return 0L;
        } else {
            this.ticket = ticket;
            minusAmount(ticket.getFee());
            return ticket.getFee();
        }
    }
    
    private boolean hasInvitation() {
        return invitation != null;
    }
    
    private void minusAmount(Long amount) {
        this.amount -= amount;
    }
}

// ❌ 어떻게 하는지를 나타냄
public class PeriodCondition {
    public boolean isSatisfiedByPeriod(Screening screening) {
        return dayOfWeek.equals(screening.getWhenScreened().getDayOfWeek()) &&
               startTime.compareTo(screening.getWhenScreened().toLocalTime()) <= 0 &&
               endTime.compareTo(screening.getWhenScreened().toLocalTime()) >= 0;
    }
}

public class SequenceCondition {
    public boolean isSatisfiedBySequence(Screening screening) {
        return sequence == screening.getSequence();
    }
}

// ✅ 무엇을 하는지를 나타냄
public interface DiscountCondition {
    boolean isSatisfiedBy(Screening screening);
}

public class PeriodCondition implements DiscountCondition {
    @Override
    public boolean isSatisfiedBy(Screening screening) {
        return dayOfWeek.equals(screening.getWhenScreened().getDayOfWeek()) &&
               startTime.compareTo(screening.getWhenScreened().toLocalTime()) <= 0 &&
               endTime.compareTo(screening.getWhenScreened().toLocalTime()) >= 0;
    }
}

public class SequenceCondition implements DiscountCondition {
    @Override
    public boolean isSatisfiedBy(Screening screening) {
        return sequence == screening.getSequence();
    }
}

public class TicketSeller {
    // ❌ 어떻게: "티켓을 설정한다"
    public void setTicket(Audience audience) {
        ticketOffice.plusAmount(
            audience.setTicket(ticketOffice.getTicket())
        );
    }
}

public class Audience {
    // ❌ 어떻게: "티켓을 설정한다"
    public Long setTicket(Ticket ticket) {
        return bag.setTicket(ticket);
    }
}

public class TicketSeller {
    // ✅ 무엇을: "관객에게 판매한다"
    public void sellTo(Audience audience) {
        ticketOffice.plusAmount(
            audience.buy(ticketOffice.getTicket())
        );
    }
}

public class Audience {
    // ✅ 무엇을: "티켓을 구매한다"
    public Long buy(Ticket ticket) {
        return bag.hold(ticket);
    }
}

public class Bag {
    // ✅ 무엇을: "티켓을 보관한다"
    public Long hold(Ticket ticket) {
        if (hasInvitation()) {
            this.ticket = ticket;
            return 0L;
        } else {
            this.ticket = ticket;
            minusAmount(ticket.getFee());
            return ticket.getFee();
        }
    }
}

// ❓ 이것은 디미터 법칙 위반인가?
IntStream.of(1, 15, 20, 3, 9)
         .filter(x -> x > 10)
         .distinct()
         .count();

// ❌ 디미터 법칙 위반
screening.getMovie().getDiscountConditions();
         ↓            ↓
      Movie를      DiscountCondition
      노출함        리스트를 노출함
      
→ Screening의 내부 구조(Movie 보유)가 드러남

// ✅ 디미터 법칙 위반 아님
IntStream.of(1, 2, 3).filter(x -> x > 1).count();
         ↓                ↓           ↓
    IntStream        IntStream    long
    
→ 같은 타입의 변환만 수행
→ 내부 구조 노출 없음

// ❓ 이것을 어떻게 개선할까?
for (Movie each : movies) {
    total += each.getFee();
}

// ✅ 응집도는 높아지지만...
public class Movies {
    private List<Movie> movies;
    
    public Money calculateTotalFee() {
        Money total = Money.ZERO;
        for (Movie each : movies) {
            total = total.plus(each.getFee());
        }
        return total;
    }
}

// ✅ 때로는 묻는 것이 나을 수 있다
for (Movie each : movies) {
    total += each.getFee();
}

// 자료구조 - 묻는 것이 자연스러움
public class Point {
    public double x;
    public double y;
}

double distance = Math.sqrt(
    Math.pow(p1.x - p2.x, 2) + 
    Math.pow(p1.y - p2.y, 2)
);

// 객체 - 시켜야 함
public class Point {
    public double distanceTo(Point other) {
        return Math.sqrt(
            Math.pow(x - other.x, 2) + 
            Math.pow(y - other.y, 2)
        );
    }
}

double distance = p1.distanceTo(p2);

public class Event {
    private String subject;
    private LocalDateTime from;
    private Duration duration;
    
    // ❌ 명령과 쿼리가 섞여있음!
    public boolean isSatisfied(RecurringSchedule schedule) {
        if (from.getDayOfWeek() != schedule.getDayOfWeek() ||
            !from.toLocalTime().equals(schedule.getFrom()) ||
            !duration.equals(schedule.getDuration())) {
            
            // ❌ 쿼리인 척 하지만 상태를 변경!
            reschedule(schedule);
            return false;
        }
        
        return true;
    }
    
    private void reschedule(RecurringSchedule schedule) {
        // 상태 변경!
        from = LocalDateTime.of(
            from.toLocalDate().plusDays(daysDistance(schedule)),
            schedule.getFrom()
        );
        duration = schedule.getDuration();
    }
}

// 반복 일정: 매주 수요일 10:30~11:00
RecurringSchedule schedule = new RecurringSchedule(
    "회의", 
    DayOfWeek.WEDNESDAY,
    LocalTime.of(10, 30),
    Duration.ofMinutes(30)
);

// 이벤트: 2019년 5월 8일 (수요일) 10:30~11:00
Event meeting = new Event(
    "회의",
    LocalDateTime.of(2019, 5, 8, 10, 30),
    Duration.ofMinutes(30)
);

// 🐛 버그 발생!
assert meeting.isSatisfied(schedule) == true;   // ✅ 통과 (조건 만족)
assert meeting.isSatisfied(schedule) == true;   // ❌ 실패!

// 이벤트: 2019년 5월 9일 (목요일) 10:30~11:00
Event meeting = new Event(
    "회의",
    LocalDateTime.of(2019, 5, 9, 10, 30),  // 목요일!
    Duration.ofMinutes(30)
);

// 첫 번째 호출
boolean result1 = meeting.isSatisfied(schedule);
// 1. 조건 체크: 불일치 (목요일 != 수요일)
// 2. reschedule() 호출 → 수요일로 변경!
// 3. return false
// result1 = false ✅

// 두 번째 호출
boolean result2 = meeting.isSatisfied(schedule);
// 1. 조건 체크: 일치! (이미 수요일로 변경됨)
// 2. reschedule() 호출 안 됨
// 3. return true
// result2 = true ✅

// 🐛 같은 메서드, 다른 결과!

public class Event {
    private String subject;
    private LocalDateTime from;
    private Duration duration;
    
    // ✅ 쿼리: 상태 변경 없음
    public boolean isSatisfied(RecurringSchedule schedule) {
        if (from.getDayOfWeek() != schedule.getDayOfWeek() ||
            !from.toLocalTime().equals(schedule.getFrom()) ||
            !duration.equals(schedule.getDuration())) {
            return false;
        }
        return true;
    }
    
    // ✅ 명령: 명확하게 분리
    public void reschedule(RecurringSchedule schedule) {
        from = LocalDateTime.of(
            from.toLocalDate().plusDays(daysDistance(schedule)),
            schedule.getFrom()
        );
        duration = schedule.getDuration();
    }
    
    private long daysDistance(RecurringSchedule schedule) {
        return schedule.getDayOfWeek().getValue() - 
               from.getDayOfWeek().getValue();
    }
}

// ✅ 의도가 명확
Event meeting = new Event(
    "회의",
    LocalDateTime.of(2019, 5, 9, 10, 30),  // 목요일
    Duration.ofMinutes(30)
);

RecurringSchedule schedule = new RecurringSchedule(
    "회의",
    DayOfWeek.WEDNESDAY,
    LocalTime.of(10, 30),
    Duration.ofMinutes(30)
);

// 조건 확인 (쿼리)
if (!meeting.isSatisfied(schedule)) {
    // 일정 변경 (명령)
    meeting.reschedule(schedule);
}

// 몇 번을 호출해도 같은 결과
assert meeting.isSatisfied(schedule) == true;
assert meeting.isSatisfied(schedule) == true;  // ✅ 통과!

// 쿼리는 몇 번 호출해도 안전
boolean result1 = meeting.isSatisfied(schedule);
boolean result2 = meeting.isSatisfied(schedule);
boolean result3 = meeting.isSatisfied(schedule);
// result1 == result2 == result3 ✅

// 순서를 바꿔도 결과가 같음
boolean a = meeting.isSatisfied(schedule);
meeting.getDuration();
boolean b = meeting.isSatisfied(schedule);
// a == b ✅

// ❌ 명령과 쿼리가 섞인 경우
boolean result = meeting.isSatisfied(schedule);  // 상태 변경!
// 디버거로 확인하려고 호출 → 상태가 바뀜 → 버그!

// ✅ 분리된 경우
boolean result = meeting.isSatisfied(schedule);  // 상태 변경 없음
// 디버거로 몇 번을 확인해도 안전

// ✅ 이름만 봐도 알 수 있음
boolean isValid = order.isValid();        // 쿼리
order.cancel();                           // 명령
Money total = order.calculateTotal();     // 쿼리
order.confirm();                          // 명령

// ✅ 불변 객체
public final class Money {
    private final BigDecimal amount;
    
    public Money plus(Money other) {
        // 자신을 변경하지 않고 새 객체 반환
        return new Money(amount.add(other.amount));
    }
    
    public Money minus(Money other) {
        return new Money(amount.subtract(other.amount));
    }
}

// 사용
Money m1 = Money.wons(1000);
Money m2 = m1.plus(Money.wons(500));  // m1은 변하지 않음

// 참조 투명성
Money result1 = m1.plus(Money.wons(500)).times(2);
Money result2 = m1.plus(Money.wons(500)).times(2);
// result1 == result2 항상 성립

// ✅ 좋은 명령 메서드
public void cancel() {
    this.status = OrderStatus.CANCELLED;
    // return 없음
}

public void addItem(Item item) {
    this.items.add(item);
    // return 없음
}

// ⚠️ 예외: 편의를 위한 반환
public Order placeOrder() {
    this.status = OrderStatus.PLACED;
    return this;  // 메서드 체이닝을 위한 this 반환은 OK
}

// ✅ 좋은 쿼리 메서드
public boolean isEmpty() {
    return items.isEmpty();
    // 상태 변경 없음
}

public Money calculateTotal() {
    return items.stream()
                .map(Item::getPrice)
                .reduce(Money.ZERO, Money::plus);
    // 상태 변경 없음
}

// ❌ 나쁜 쿼리 메서드
public int getSize() {
    this.accessCount++;  // 상태 변경!
    return items.size();
}

public class OrderService {
    public void processOrder(Order order) {
        // ❌ 기차 충돌
        Customer customer = order.getCustomer();
        Address address = customer.getAddress();
        String city = address.getCity();
        
        if (city.equals("서울")) {
            // 서울 배송
        }
        
        // ❌ 상태를 묻고 판단
        if (order.getItems().size() > 5) {
            order.setDiscountRate(0.1);
        }
        
        // ❌ 직접 계산
        BigDecimal total = BigDecimal.ZERO;
        for (OrderItem item : order.getItems()) {
            total = total.add(
                item.getPrice().multiply(
                    new BigDecimal(item.getQuantity())
                )
            );
        }
    }
}

public class OrderService {
    public void processOrder(Order order) {
        // ✅ 묻지 말고 시켜라
        if (order.isSeoulDelivery()) {
            // 서울 배송
        }
        
        // ✅ 객체에게 책임 부여
        order.applyBulkDiscount();
        
        // ✅ 계산 책임은 Order에게
        Money total = order.calculateTotal();
    }
}

public class Order {
    private Customer customer;
    private List<OrderItem> items;
    private BigDecimal discountRate = BigDecimal.ZERO;
    
    // ✅ 쿼리: 상태 변경 없음
    public boolean isSeoulDelivery() {
        return customer.isSeoulResident();
    }
    
    // ✅ 명령: 명확한 이름, void 반환
    public void applyBulkDiscount() {
        if (items.size() > 5) {
            this.discountRate = new BigDecimal("0.1");
        }
    }
    
    // ✅ 쿼리: 계산만 수행
    public Money calculateTotal() {
        Money subtotal = items.stream()
            .map(OrderItem::calculatePrice)
            .reduce(Money.ZERO, Money::plus);
            
        return subtotal.minus(
            subtotal.times(discountRate.doubleValue())
        );
    }
}

public class Customer {
    private Address address;
    
    // ✅ 의도를 드러내는 이름
    public boolean isSeoulResident() {
        return address.isInCity("서울");
    }
}

public class OrderItem {
    private Money price;
    private int quantity;
    
    // ✅ 자신의 책임
    public Money calculatePrice() {
        return price.times(quantity);
    }
}

// Theater
public void enter(Audience audience) {
    ticketSeller.setTicket(audience);  // ✅ 1단계 개선
}

// TicketSeller
public void setTicket(Audience audience) {
    ticketOffice.plusAmount(
        audience.setTicket(ticketOffice.getTicket())
    );
}

// Audience
public Long setTicket(Ticket ticket) {
    return bag.setTicket(ticket);  // ✅ Bag에게 위임
}

// Bag
public Long setTicket(Ticket ticket) {
    if (hasInvitation()) {
        this.ticket = ticket;
        return 0L;
    } else {
        this.ticket = ticket;
        minusAmount(ticket.getFee());
        return ticket.getFee();
    }
}

public class OrderProcessor {
    public void process(Order order) {
        // ❌ 디미터 법칙 위반 (기차 충돌)
        String city = order.getCustomer()
                          .getAddress()
                          .getCity();
        
        // ❌ 묻지 말고 시켜라 위반
        if (order.getStatus() == OrderStatus.PENDING) {
            if (order.getItems().size() > 0) {
                // ❌ 상태를 묻고 직접 변경
                order.setStatus(OrderStatus.CONFIRMED);
                
                BigDecimal total = BigDecimal.ZERO;
                for (OrderItem item : order.getItems()) {
                    // ❌ 구현 노출, 직접 계산
                    total = total.add(
                        item.getPrice()
                            .multiply(new BigDecimal(item.getQuantity()))
                    );
                }
                order.setTotalAmount(total);
            }
        }
        
        // ❌ 명령-쿼리 분리 위반
        boolean wasProcessed = order.markAsProcessed();  // 상태 변경 + 반환
        if (wasProcessed) {
            sendNotification(order);
        }
    }
}

public class OrderProcessor {
    public void process(Order order) {
        // ✅ 디미터 법칙: Order에게만 메시지
        if (order.isSeoulDelivery()) {
            applySeoulDiscount(order);
        }
        
        // ✅ 묻지 말고 시켜라: Order가 스스로 처리
        order.confirm();
        
        // ✅ 명령-쿼리 분리
        if (order.isProcessed()) {  // 쿼리
            order.markAsProcessed();  // 명령
            sendNotification(order);
        }
    }
}

public class Order {
    private Customer customer;
    private List<OrderItem> items;
    private OrderStatus status;
    private Money totalAmount;
    
    // ✅ 의도를 드러내는 인터페이스
    public boolean isSeoulDelivery() {
        return customer.livesInSeoul();
    }
    
    // ✅ 명령: void 반환
    public void confirm() {
        validateConfirmable();
        this.status = OrderStatus.CONFIRMED;
        this.totalAmount = calculateTotal();
    }
    
    // ✅ 쿼리: 상태 변경 없음
    public boolean isProcessed() {
        return status == OrderStatus.PROCESSED;
    }
    
    // ✅ 명령: 명확하게 분리
    public void markAsProcessed() {
        if (status != OrderStatus.CONFIRMED) {
            throw new IllegalStateException("주문이 확정되지 않았습니다");
        }
        this.status = OrderStatus.PROCESSED;
    }
    
    // ✅ 정보 전문가: Order가 자신의 총액 계산
    private Money calculateTotal() {
        return items.stream()
                   .map(OrderItem::calculateAmount)
                   .reduce(Money.ZERO, Money::plus);
    }
}

public class Customer {
    private Address address;
    
    // ✅ 의도를 드러내는 메서드
    public boolean livesInSeoul() {
        return address.isInCity("서울");
    }
}

public class OrderItem {
    private Money price;
    private int quantity;
    
    // ✅ 정보 전문가: 자신의 금액 계산
    public Money calculateAmount() {
        return price.times(quantity);
    }
}

public class PostService {
    public void updatePost(Long postId, PostUpdateRequest request) {
        Post post = postRepository.findById(postId)
            .orElseThrow(() -> new PostNotFoundException());
        
        // ❌ 상태를 묻고 판단
        if (post.getAuthor().getId().equals(request.getUserId())) {
            // ❌ 직접 상태 변경
            post.setTitle(request.getTitle());
            post.setContent(request.getContent());
            post.setUpdatedAt(LocalDateTime.now());
            
            // ❌ 비즈니스 로직이 서비스에
            if (post.getContent().length() > 10000) {
                throw new ContentTooLongException();
            }
            
            postRepository.save(post);
        } else {
            throw new UnauthorizedException();
        }
    }
}

public class PostService {
    public void updatePost(Long postId, PostUpdateRequest request) {
        Post post = postRepository.findById(postId)
            .orElseThrow(() -> new PostNotFoundException());
        
        // ✅ 묻지 말고 시켜라
        post.update(
            request.getUserId(),
            request.getTitle(),
            request.getContent()
        );
        
        postRepository.save(post);
    }
}

public class Post {
    private Long id;
    private User author;
    private String title;
    private String content;
    private LocalDateTime createdAt;
    private LocalDateTime updatedAt;
    
    // ✅ 모든 로직이 Post 내부에
    public void update(Long userId, String newTitle, String newContent) {
        // ✅ 권한 검증도 Post가 수행
        validateAuthor(userId);
        
        // ✅ 비즈니스 규칙도 Post가 관리
        validateContent(newContent);
        
        this.title = newTitle;
        this.content = newContent;
        this.updatedAt = LocalDateTime.now();
    }
    
    private void validateAuthor(Long userId) {
        if (!author.hasId(userId)) {
            throw new UnauthorizedException("작성자만 수정할 수 있습니다");
        }
    }
    
    private void validateContent(String content) {
        if (content.length() > 10000) {
            throw new ContentTooLongException("내용이 너무 깁니다");
        }
    }
}

public class User {
    private Long id;
    
    // ✅ 의도를 드러내는 인터페이스
    public boolean hasId(Long id) {
        return this.id.equals(id);
    }
}

// 코드 리뷰 체크리스트
□ 연속된 getter 호출이 있는가?
□ 3단계 이상 접근하는가?
□ 중간 객체의 타입을 알아야 하는가?

// Before
String street = person.getAddress().getStreet();

// After
String street = person.getStreet();

// Person에 추가
public String getStreet() {
    return address.getStreet();
}

// 패턴 찾기
if (object.getState() == SOME_STATE) {
    object.setState(NEW_STATE);
}

// Before
if (order.getStatus() == OrderStatus.PENDING) {
    order.setStatus(OrderStatus.CONFIRMED);
}

// After
order.confirm();

public void confirm() {
    if (status != OrderStatus.PENDING) {
        throw new IllegalStateException(
            "대기 중인 주문만 확정할 수 있습니다"
        );
    }
    this.status = OrderStatus.CONFIRMED;
}

// ❌ 구현이 드러나는 이름
public boolean isSatisfiedByPeriod(Screening screening)
public boolean checkSequenceCondition(Screening screening)
public Money calculateAmountDiscount()
public Money calculatePercentDiscount()

// ✅ 의도가 드러나는 이름
public boolean isSatisfiedBy(Screening screening)
public boolean isSatisfiedBy(Screening screening)
public Money calculateDiscountAmount()
public Money calculateDiscountAmount()

public interface DiscountCondition {
    boolean isSatisfiedBy(Screening screening);
}

public interface DiscountPolicy {
    Money calculateDiscountAmount();
}

// ❌ 명령과 쿼리가 섞임
public boolean isSatisfied(RecurringSchedule schedule) {
    if (/* 조건 불만족 */) {
        reschedule(schedule);  // 상태 변경!
        return false;
    }
    return true;
}

// ✅ 쿼리: 상태 변경 없음
public boolean isSatisfied(RecurringSchedule schedule) {
    return /* 조건 체크만 */;
}

// ✅ 명령: 명확하게 분리
public void reschedule(RecurringSchedule schedule) {
    // 상태 변경
}

// Before (혼합)
if (!event.isSatisfied(schedule)) {
    // 이미 재스케줄링됨
}

// After (분리)
if (!event.isSatisfied(schedule)) {
    event.reschedule(schedule);
}