인터페이스 활용

1. 다형성 (Polymorphism)

예제: 동물 소리

interface Animal {
    void makeSound();
}

class Dog implements Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof");
    }
}

class Cat implements Animal {
    @Override
    public void makeSound() {
        System.out.println("Meow");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        Animal myCat = new Cat();

        myDog.makeSound(); // Woof
        myCat.makeSound(); // Meow
    }
}

• 이 예제에서 Animal 인터페이스를 통해 Dog와 Cat 클래스가 각각의 방식으로 makeSound() 메서드를 구현했습니다. 인터페이스를 사용하여 Dog와 Cat을 동일한 타입인 Animal로 다룰 수 있으며, 각 클래스의 구체적인 구현은 런타임에 결정됩니다.

2. 코드의 느슨한 결합 (Loose Coupling)

예제: 결제 시스템

interface PaymentProcessor {
    void processPayment(double amount);
}

class CreditCardProcessor implements PaymentProcessor {
    @Override
    public void processPayment(double amount) {
        System.out.println("Processing credit card payment of $" + amount);
    }
}

class PayPalProcessor implements PaymentProcessor {
    @Override
    public void processPayment(double amount) {
        System.out.println("Processing PayPal payment of $" + amount);
    }
}

class CheckoutService {
    private PaymentProcessor processor;

    public CheckoutService(PaymentProcessor processor) {
        this.processor = processor;
    }

    public void checkout(double amount) {
        processor.processPayment(amount);
    }
}

public class Main {
    public static void main(String[] args) {
        PaymentProcessor creditCard = new CreditCardProcessor();
        PaymentProcessor paypal = new PayPalProcessor();

        CheckoutService service1 = new CheckoutService(creditCard);
        service1.checkout(100.0); // Processing credit card payment of $100.0

        CheckoutService service2 = new CheckoutService(paypal);
        service2.checkout(200.0); // Processing PayPal payment of $200.0
    }
}

• 이 예제에서 PaymentProcessor 인터페이스를 사용하여 CreditCardProcessor와 PayPalProcessor 클래스가 각각의 결제 방식을 구현했습니다. CheckoutService는 결제 방식을 알고 있을 필요 없이 PaymentProcessor 인터페이스만 의존합니다. 결제 방식이 추가되더라도 CheckoutService는 변경할 필요가 없습니다.

3. 전략 패턴 (Strategy Pattern)

예제: 정렬 전략

interface SortingStrategy {
    void sort(int[] numbers);
}

class BubbleSort implements SortingStrategy {
    @Override
    public void sort(int[] numbers) {
        System.out.println("Sorting array using bubble sort");
        // Bubble sort algorithm...
    }
}

class QuickSort implements SortingStrategy {
    @Override
    public void sort(int[] numbers) {
        System.out.println("Sorting array using quick sort");
        // Quick sort algorithm...
    }
}

class Sorter {
    private SortingStrategy strategy;

    public Sorter(SortingStrategy strategy) {
        this.strategy = strategy;
    }

    public void sort(int[] numbers) {
        strategy.sort(numbers);
    }
}

public class Main {
    public static void main(String[] args) {
        int[] numbers = {5, 3, 8, 1};

        Sorter bubbleSorter = new Sorter(new BubbleSort());
        bubbleSorter.sort(numbers); // Sorting array using bubble sort

        Sorter quickSorter = new Sorter(new QuickSort());
        quickSorter.sort(numbers); // Sorting array using quick sort
    }
}

• 여기서 SortingStrategy 인터페이스는 정렬 알고리즘을 정의하고 있습니다. BubbleSort와 QuickSort 클래스는 각각의 정렬 방식을 구현합니다. Sorter 클래스는 SortingStrategy 인터페이스에 의존하며, 정렬 알고리즘을 유연하게 교체할 수 있습니다.

4. 템플릿 메서드 패턴 (Template Method Pattern)과 함께 사용

예제: 요리 템플릿

interface Cooking {
    void prepareIngredients();
    void cook();
    void serve();
}

abstract class CookingTemplate implements Cooking {
    // 템플릿 메서드
    public final void prepareMeal() {
        prepareIngredients();
        cook();
        serve();
    }

    @Override
    public abstract void prepareIngredients();

    @Override
    public abstract void cook();

    @Override
    public abstract void serve();
}

class PastaCooking extends CookingTemplate {
    @Override
    public void prepareIngredients() {
        System.out.println("Preparing pasta and sauce ingredients");
    }

    @Override
    public void cook() {
        System.out.println("Cooking pasta and heating sauce");
    }

    @Override
    public void serve() {
        System.out.println("Serving pasta with sauce");
    }
}

class SteakCooking extends CookingTemplate {
    @Override
    public void prepareIngredients() {
        System.out.println("Preparing steak and seasoning");
    }

    @Override
    public void cook() {
        System.out.println("Grilling steak");
    }

    @Override
    public void serve() {
        System.out.println("Serving steak with vegetables");
    }
}

public class Main {
    public static void main(String[] args) {
        CookingTemplate pastaCooking = new PastaCooking();
        pastaCooking.prepareMeal();

        CookingTemplate steakCooking = new SteakCooking();
        steakCooking.prepareMeal();
    }
}

• 이 예제에서 CookingTemplate 추상 클래스는 요리의 골격을 정의하고, 각 요리 단계는 Cooking 인터페이스를 구현하여 서브클래스에서 구체적으로 구현됩니다. 이 방법은 템플릿 메서드 패턴과 인터페이스를 결합하여 유연성을 높이는 데 사용됩니다.

5. 디자인 패턴과의 결합

결론