전략 패턴을 언제, 어떻게 사용할 것인가

// 전략(변경되는 알고리즘)
interface Strategy {
    void operation();
}

interface StrategyImplA implements Strategy {
    public void operation(){};
}

interface StrategyImplB implements Strategy {
    public void operation(){};
}

// 컨텍스트(전략을 사용하는 객체)
class Context {
    private Strategy strategy;

    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;
    }

    public void invoke() {
        strategy.operation();
    }
}

// 클라이언트
class Client {
    public static void main(String[] args) {
        Context context = new Context(); // 1. 컨텍스트 생성
        context.setStrategy(new StrategyImplA()); // 2. 전략 주입
        context.invoke(); // 3. 전략 실행
    }
}

// 결제 전략 인터페이스
public interface PaymentStrategy {
    void processPayment(double amount);
}

// 신용카드 결제 전략
public class CreditCardStrategy implements PaymentStrategy {
    @Override
    public void processPayment(double amount) {
        // 신용카드 결제 처리 로직
    }
}

// PayPal 결제 전략
public class PayPalStrategy implements PaymentStrategy {
    @Override
    public void processPayment(double amount) {
        // PayPal 결제 처리 로직
    }
}

// 결제를 처리하는 컨텍스트 클래스
public class PaymentContext {
    private PaymentStrategy strategy;

    public void setPaymentStrategy(PaymentStrategy strategy) {
        this.strategy = strategy;
    }

    public void processPayment(double amount) {
        strategy.processPayment(amount);
    }
}

// 클라이언트
public class PaymentClient {
    public static void main(String[] args) {
        PaymentContext context = new PaymentContext();

        // 신용카드로 결제
        context.setPaymentStrategy(new CreditCardStrategy());
        context.processPayment(100.0);

        // PayPal로 결제 방식 변경
        context.setPaymentStrategy(new PayPalStrategy());
        context.processPayment(200.0);
    }
}

// 팩토리 패턴
public class PaymentFactory {
    private HashMap<String, PaymentStrategy> strategies;
    
    public PaymentFactory() {
        strategies = new HashMap<>();
        strategies.put("credit", new CreditCardStrategy());
        strategies.put("paypal", new PayPalStrategy());
    }

    public PaymentStrategy getPaymentStrategy(String type) {
        return strategies.get(type);
    }
}

public class PaymentProcessor {
    public void processPayment(String paymentType, double amount) {
        if (paymentType.equals("CREDIT_CARD")) {
            processCreditCardPayment(amount);
        } else if (paymentType.equals("PAYPAL")) {
            processPayPalPayment(amount);
        } else {
            throw new IllegalArgumentException("Unknown payment type");
        }
    }

    private void processCreditCardPayment(double amount) {
        // 신용카드 결제 처리 로직
        System.out.println("Processing credit card payment: " + amount);
    }

    private void processPayPalPayment(double amount) {
        // PayPal 결제 처리 로직
        System.out.println("Processing PayPal payment: " + amount);
    }
}

class Main {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("A");
        list.add("C");
        list.add("B");

        // 정렬 전략을 주입
        list.sort(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        });

        System.out.println(list); // [A, B, C]
    }
}

// 전략
interface Strategy {
    int operation(int x, int y);
}

class ConcreteStrategyA implements Strategy {
    public void operation(int x, int y) {
       return x + y; 
    }
}

class ConcreteStrategyB implements Strategy {
    public void operation(int x, int y) {
       return x - y; 
    }
}

// 컨텍스트
class Context {
    public int executeStrategy(Strategy strategy, int x, int y) {
        return strategy.operation(x, y);
    }
}

// 클라이언트
class Client {
    public static void main(String[] args) {
        Context context = new Context();
        context.executeStrategy(new ConcreteStrategyA(), 3, 4); // 7
        context.executeStrategy(new ConcreteStrategyB(), 3, 4); // -1
    }
}

// 콜백
interface Callback {
    int execute(int x, int y);
}

// 템플릿
class Template {
    public int execute(Callback callback, int x, int y) {
        return callback.execute(x, y);
    }
}

// 클라이언트
class Client {
    public static void main(String[] args) {
        Template template = new Template();
        template.execute((x, y) -> x + y, 3, 4); // 7
        template.execute((x, y) -> x - y, 3, 4); // -1
    }
}