设计模式例子
策略模式（Strategy Pattern）
-
策略模式 (Strategy Pattern):
- 定义一系列算法，将每个算法都封装起来，并使它们之间可以互换。
- 例如：
java.util.Comparator
以下是一个简单的Java策略模式的例子，涉及一个商品的价格计算场景。我们将定义一个PriceCalculator类，它使用不同的价格计算策略来计算商品的最终价格。
import java.util.HashMap;
import java.util.Map;
// 策略接口
interface PricingStrategy {
double calculatePrice(double originalPrice);
}
// 具体策略1：打折策略
class DiscountPricingStrategy implements PricingStrategy {
private double discountRate;
public DiscountPricingStrategy(double discountRate) {
this.discountRate = discountRate;
}
@Override
public double calculatePrice(double originalPrice) {
return originalPrice * (1 - discountRate);
}
}
// 具体策略2：满减策略
class FullReductionPricingStrategy implements PricingStrategy {
private double threshold;
private double reductionAmount;
public FullReductionPricingStrategy(double threshold, double reductionAmount) {
this.threshold = threshold;
this.reductionAmount = reductionAmount;
}
@Override
public double calculatePrice(double originalPrice) {
return originalPrice >= threshold ? originalPrice - reductionAmount : originalPrice;
}
}
// 上下文类，用于设置和执行策略
class PriceCalculator {
private PricingStrategy pricingStrategy;
public void setPricingStrategy(PricingStrategy pricingStrategy) {
this.pricingStrategy = pricingStrategy;
}
public double calculateFinalPrice(double originalPrice) {
if (pricingStrategy == null) {
throw new IllegalStateException("Pricing strategy not set");
}
return pricingStrategy.calculatePrice(originalPrice);
}
}
public class StrategyPatternExample {
public static void main(String[] args) {
// 创建商品价格计算器
PriceCalculator priceCalculator = new PriceCalculator();
// 商品原始价格
double originalPrice = 100.0;
// 使用打折策略
PricingStrategy discountStrategy = new DiscountPricingStrategy(0.2);
priceCalculator.setPricingStrategy(discountStrategy);
double discountedPrice = priceCalculator.calculateFinalPrice(originalPrice);
System.out.println("Discounted Price: " + discountedPrice);
// 使用满减策略
PricingStrategy fullReductionStrategy = new FullReductionPricingStrategy(80.0, 10.0);
priceCalculator.setPricingStrategy(fullReductionStrategy);
double reducedPrice = priceCalculator.calculateFinalPrice(originalPrice);
System.out.println("Reduced Price: " + reducedPrice);
}
}
这个例子中，PricingStrategy是一个策略接口，具体的打折策略和满减策略分别实现了这个接口。PriceCalculator是上下文类，用于设置和执行不同的策略。在main方法中，我们创建了一个商品价格计算器，分别使用了打折策略和满减策略来计算最终价格。你可以运行这个例子，看到不同策略下的最终价格计算结果。
观察者模式（Observer Pattern）
- 定义了一种一对多的依赖关系，使得当一个对象改变状态时，所有依赖于它的对象都会得到通知并自动更新。
- 例如：
java.util.Observer和java.util.Observable
当涉及观察者模式时，通常会有一个主题对象（Subject），它会维护一个观察者（Observer）列表，并通知这些观察者当其状态发生改变。下面是一个简单的 Java 观察者模式示例，模拟了一个简单的新闻发布系统。
import java.util.ArrayList;
import java.util.List;
// 主题接口
interface Subject {
void registerObserver(Observer observer);
void removeObserver(Observer observer);
void notifyObservers(String news);
}
// 具体主题类
class NewsPublisher implements Subject {
private List observers;
private String latestNews;
public NewsPublisher() {
this.observers = new ArrayList<>();
}
@Override
public void registerObserver(Observer observer) {
observers.add(observer);
}
@Override
public void removeObserver(Observer observer) {
observers.remove(observer);
}
@Override
public void notifyObservers(String news) {
for (Observer observer : observers) {
observer.update(news);
}
}
// 模拟新闻发布
public void publishNews(String news) {
this.latestNews = news;
notifyObservers(news);
}
}
// 观察者接口
interface Observer {
void update(String news);
}
// 具体观察者类
class NewsSubscriber implements Observer {
private String subscriberName;
public NewsSubscriber(String subscriberName) {
this.subscriberName = subscriberName;
}
@Override
public void update(String news) {
System.out.println(subscriberName + " received news: " + news);
}
}
public class ObserverPatternExample {
public static void main(String[] args) {
// 创建新闻发布者
NewsPublisher publisher = new NewsPublisher();
// 创建订阅者
Observer subscriber1 = new NewsSubscriber("Subscriber 1");
Observer subscriber2 = new NewsSubscriber("Subscriber 2");
// 订阅新闻
publisher.registerObserver(subscriber1);
publisher.registerObserver(subscriber2);
// 发布新闻
publisher.publishNews("Breaking News: Observers pattern example!");
// 移除一个订阅者
publisher.removeObserver(subscriber2);
// 再次发布新闻
publisher.publishNews("Second Edition: More updates!");
}
}
这个示例中，NewsPublisher 是主题类，负责管理观察者列表并通知它们有关最新新闻的更新。NewsSubscriber 是具体的观察者类，实现了 Observer 接口。在 main 方法中，创建了一个新闻发布者，并添加了两个订阅者。当发布者发布新闻时，所有订阅者都会收到相应的新闻更新。可以运行这个示例来查看观察者模式的效果。
模板方法模式（Template Method Pattern）
- 定义一个算法的骨架，将一些步骤延迟到子类中。
- 例如：
java.util.Collections#sort()
模板方法模式通常涉及一个抽象类定义了一个算法的骨架，将一些步骤延迟到子类中。以下是一个简单的 Java 模板方法模式的例子，模拟了一种饮料制作的过程。
// 模板方法抽象类
abstract class BeverageTemplate {
// 模板方法，定义了饮料制作的步骤
public final void makeBeverage() {
boilWater();
brew();
pourInCup();
addCondiments();
System.out.println("Beverage is ready!");
}
// 具体步骤1：烧水
private void boilWater() {
System.out.println("Boiling water");
}
// 具体步骤2：冲泡
protected abstract void brew();
// 具体步骤3：倒入杯中
private void pourInCup() {
System.out.println("Pouring into cup");
}
// 具体步骤4：加调料
protected abstract void addCondiments();
}
// 具体类1：制作咖啡
class Coffee extends BeverageTemplate {
@Override
protected void brew() {
System.out.println("Brewing coffee grounds");
}
@Override
protected void addCondiments() {
System.out.println("Adding sugar and milk");
}
}
// 具体类2：制作茶
class Tea extends BeverageTemplate {
@Override
protected void brew() {
System.out.println("Steeping the tea");
}
@Override
protected void addCondiments() {
System.out.println("Adding lemon");
}
}
public class TemplateMethodPatternExample {
public static void main(String[] args) {
// 制作咖啡
BeverageTemplate coffee = new Coffee();
System.out.println("Making coffee...");
coffee.makeBeverage();
System.out.println();
// 制作茶
BeverageTemplate tea = new Tea();
System.out.println("Making tea...");
tea.makeBeverage();
}
}
在这个例子中，BeverageTemplate 是模板方法抽象类，它定义了一个 makeBeverage 模板方法，其中包含了制作饮料的通用步骤，如烧水、冲泡、倒入杯中和加调料。Coffee 和 Tea 是具体的子类，分别实现了 brew 和 addCondiments 方法以定制制作咖啡和茶的具体步骤。
在 main 方法中，创建了一个咖啡对象和一个茶对象，并分别调用它们的 makeBeverage 方法。你可以运行这个示例来查看模板方法模式的实际应用。