옵서버와 전략 패턴
의존성을 관리하는 옵서버와 교체 가능한 알고리즘을 구현하는 전략 패턴을 익힙니다.
옵서버와 전략 패턴은(는) CoddyKit의 무료 Clean Architecture & Design Patterns in Practice 강의입니다. 이것은 4개 중 1번째 강의입니다. 아래에서 전체 강의를 무료로 읽을 수 있으며, 내장 코드 에디터와 24/7 AI 튜터와 함께 브라우저에서 직접 실습할 수 있습니다. 이 강의는 Clean Architecture & Design Patterns in Practice 학습 경로의 일부이며, 진행 상황이 웹과 CoddyKit 앱에 동기화됩니다. Clean Architecture & Design Patterns in Practice 강의에는 총 4개의 강의가 포함되어 있습니다.
이 강의의 일부는 아직 번역되지 않았으며 영어로 표시됩니다.
Behavioral Patterns: Actions & Interactions
Welcome to the world of Behavioral Design Patterns! These patterns focus on how objects interact and communicate, helping distribute responsibilities effectively.
They describe common communication patterns between objects, making your system more flexible and manageable.
Observer Pattern: Notifying Changes
First up is the Observer Pattern. Imagine you subscribe to a newsletter – when a new edition is out, you get notified! This pattern works similarly.
- It defines a one-to-many dependency between objects.
- When one object (the Subject) changes state, all its dependents (Observers) are notified and updated automatically.
It's great for event handling and distributed systems.
Observer Components: The Subject
The Subject (also known as Observable) is the object being watched. It has two main jobs:
- Maintain a list of its observers.
- Provide methods to attach (add) or detach (remove) observers.
- Notify all attached observers when its state changes.
Think of it as the news publisher.
Observer Components: The Observer
The Observer is any object that wants to be notified of changes in the Subject. It defines an update() method.
- When the Subject notifies, it calls each Observer's
update()method. - This method allows the Observer to react to the change, perhaps by fetching new data or updating its display.
These are your newsletter subscribers!
Observer Pattern: Publisher & Subscribers
Let's see the Observer pattern in action with a simple news publisher and readers. The NewsPublisher is our Subject, and NewsReaders are our Observers.
Try running the code to see how readers get updates!
import java.util.ArrayList;
import java.util.List;
// Observer Interface
interface Subscriber {
void update(String news);
}
// Subject Class
class NewsPublisher {
private List<Subscriber> subscribers = new ArrayList<>();
private String latestNews;
public void addSubscriber(Subscriber s) {
subscribers.add(s);
}
public void removeSubscriber(Subscriber s) {
subscribers.remove(s);
}
public void publishNews(String news) {
this.latestNews = news;
notifySubscribers();
}
private void notifySubscribers() {
for (Subscriber s : subscribers) {
s.update(latestNews);
}
}
}
// Concrete Observer
class NewsReader implements Subscriber {
private String name;
public NewsReader(String name) {
this.name = name;
}
@Override
public void update(String news) {
System.out.println(name + " received: " + news);
}
}
public class Main {
public static void main(String[] args) {
NewsPublisher publisher = new NewsPublisher();
NewsReader reader1 = new NewsReader("Alice");
NewsReader reader2 = new NewsReader("Bob");
publisher.addSubscriber(reader1);
publisher.addSubscriber(reader2);
publisher.publishNews("Breaking: New programming course released!");
System.out.println("\nAlice unsubscribes...");
publisher.removeSubscriber(reader1);
publisher.publishNews("Update: Course enrollment extended!");
}
}Strategy Pattern: Choosing Algorithms
Next, we have the Strategy Pattern. This pattern allows you to define a family of algorithms, encapsulate each one, and make them interchangeable.
It lets the algorithm vary independently from clients that use it. Think of choosing different payment methods (credit card, PayPal, bank transfer) at checkout.
Strategy Components: The Strategy
The Strategy is an interface or abstract class that declares a common operation for all supported algorithms.
- Each specific algorithm (e.g.,
CreditCardPayment,PayPalPayment) implements this interface. - This ensures they all have the same method signature, making them interchangeable.
Strategy Components: The Context
The Context is the class that holds a reference to a Strategy object. It defines an interface for clients to interact with.
- The Context does not know which concrete strategy it is using.
- It delegates the execution of the algorithm to its current Strategy object.
This keeps the Context simple and flexible, as it doesn't need to change when new strategies are added.
Strategy Pattern: Payment Methods
Here's a practical example of the Strategy pattern. We have different payment strategies (Credit Card, PayPal) and a ShoppingCart as our Context.
Notice how the ShoppingCart can easily switch between payment methods without changing its own core logic.
interface PaymentStrategy {
void pay(int amount);
}
class CreditCardPayment implements PaymentStrategy {
private String cardNumber;
public CreditCardPayment(String card) { this.cardNumber = card; }
@Override
public void pay(int amount) {
System.out.println("Paid " + amount + " using Credit Card " + cardNumber);
}
}
class PayPalPayment implements PaymentStrategy {
private String email;
public PayPalPayment(String email) { this.email = email; }
@Override
public void pay(int amount) {
System.out.println("Paid " + amount + " using PayPal account: " + email);
}
}
class ShoppingCart {
private PaymentStrategy strategy;
public void setPaymentStrategy(PaymentStrategy strategy) {
this.strategy = strategy;
}
public void checkout(int amount) {
if (strategy == null) {
System.out.println("Please set a payment strategy first.");
return;
}
strategy.pay(amount);
}
}
public class Main {
public static void main(String[] args) {
ShoppingCart cart = new ShoppingCart();
// Pay with Credit Card
cart.setPaymentStrategy(new CreditCardPayment("1234-5678-9012-3456"));
cart.checkout(100);
// Pay with PayPal
cart.setPaymentStrategy(new PayPalPayment("user@example.com"));
cart.checkout(50);
}
}Quick Check: Observer or Strategy?
Consider a stock trading application. It needs to calculate trading fees using different methods (e.g., a flat fee, a percentage of trade value, or a tiered system) based on the user's account type. The application should be able to easily switch between these methods.
Recap: Notifying & Swapping
Great job! You've explored two powerful behavioral design patterns:
- Observer Pattern: Manages one-to-many dependencies, where a Subject notifies multiple Observers of state changes. It promotes loose coupling between components.
- Strategy Pattern: Allows you to define a family of algorithms, encapsulate each one, and make them interchangeable. It helps in swapping algorithms at runtime, promoting flexibility and clean code.
These patterns help make your code more modular, flexible, and easier to maintain!
자주 묻는 질문
“옵서버와 전략 패턴” 강의는 무료인가요?
네 — “옵서버와 전략 패턴” 전체 내용을 이 웹사이트에서 무료로 읽을 수 있습니다. 인터랙티브하게 실습하려면(내장 코드 에디터와 24/7 AI 튜터), CoddyKit PRO로 업그레이드하면 Clean Architecture & Design Patterns in Practice 강의 전체를 잠금 해제할 수 있습니다. Clean Architecture & Design Patterns in Practice 강의에는 총 4개의 강의가 포함되어 있습니다.
“옵서버와 전략 패턴”에서 뭘 배우나요?
의존성을 관리하는 옵서버와 교체 가능한 알고리즘을 구현하는 전략 패턴을 익힙니다. 브라우저에서 직접 실행하는 실습 코드로 Clean Architecture & Design Patterns in Practice을(를) 배우며, 24/7 AI 튜터가 강의를 진행하면서 질문에 답변해줍니다.
Clean Architecture & Design Patterns in Practice을(를) 시작하는 데 경험이 필요한가요?
사전 경험은 필요하지 않습니다. CoddyKit의 Clean Architecture & Design Patterns in Practice은(는) 초급자부터 고급 학습자까지를 위해 구성되어 있으므로, 여기서 시작하거나 처음부터 시작할 수 있으며 자신의 속도대로 진행할 수 있습니다. 이것은 4개 중 1번째 강의입니다.
“옵서버와 전략 패턴” 강의는 얼마나 걸리나요?
대부분의 CoddyKit 강의는 약 5~10분이 소요됩니다. 각 강의는 간결하고 인터랙티브하여 꾸준한 진행이 가능하며, 웹과 앱에서 중단한 부분부터 바로 시작할 수 있습니다.
이 Clean Architecture & Design Patterns in Practice 강의에서 코드를 작성하고 실행할 수 있나요?
네. 모든 Clean Architecture & Design Patterns in Practice 강의에는 내장 코드 에디터가 포함되어 있으므로, 브라우저에서 바로 실제 코드를 작성하고 실행한 후 즉시 AI 피드백을 받을 수 있습니다 — 로컬 설정이 필요 없습니다.