用最简单的例子说明设计模式（二）之模版方法、策略模式、组合模式、观察者模式
模板方法模式
提供一个抽象类，将部分逻辑以具体方法或构造器的形式实现，然后声明一些抽象方法来迫使子类实现剩余的逻辑。不同的子类可以以不同的方式实现这些抽象方法（多态实现），从而实现不同的业务逻辑。
使用场景
1)多个子类有公有的方法，并且逻辑基本相同时
2)重要、复杂的算法，可以把核心算法设计为模板方法
3)重构时，模板方法模式是一个经常使用的模式
public abstract class AbstractWork {
protected void getUp() {
System.out.println("起床啦！");
}
protected abstract void goToWork();
protected abstract void work();
protected abstract void getOffWork();
/*
* TemplateMethod，大家都拥有共同的执行步骤
*/
public final void newDay() {
getUp();
goToWork();
work();
getOffWork();
}
}
public class BossWork extends AbstractWork {
@Override
protected void goToWork() {
System.out.println("老板开车去上班");
}
@Override
protected void work() {
System.out.println("老板的分配工作给员工");
}
@Override
protected void getOffWork() {
System.out.println("老板开车去下班");
}
}
public class StaffWork extends AbstractWork {
@Override
protected void goToWork() {
System.out.println("员工做公交去上班");
}
@Override
protected void work() {
System.out.println("员工处理具体工作");
}
@Override
protected void getOffWork() {
System.out.println("员工做公交下班");
}
}
public class Test {
public static void main(String[] args) {
BossWork bossWork = new BossWork();
StaffWork staffWork = new StaffWork();
bossWork.newDay();
System.out.println("------------------------");
staffWork.newDay();
}
}
策略：它定义了算法家庭，分别封装起来。让它们之间可以互相替换，此模式让算法的变化，不会影响到使用算法的客户。
一个类定义了多种行为，并且这些行为在这个类的方法中以多个条件语句的形式出现，那么可以使用策略模式避免在类中使用大量的条件语句。
public interface AbstractStrategy {
//按距离来计算价格
int calculatePrice(int km);
}
public class BusStrategy implements AbstractStrategy {
@Override
public int calculatePrice(int km) {
int extraTotal = km - 10;
int extraFactor = extraTotal / 5;
int fraction = extraTotal % 5;
int price = 1 + extraTotal % 5;
return fraction > 0 ? ++price : price;
}
}
public class TaxiStrategy implements AbstractStrategy {
@Override
public int calculatePrice(int km) {
return km * 2;
}
}
public class Context {
private AbstractStrategy strategy;
public void setStrategy(AbstractStrategy strategy) {
this.strategy = strategy;
}
public int calclatePrice(int km) {
return strategy.calculatePrice(km);
}
public static void main(String[] strings) {
Context calculator = new Context();
calculator.setStrategy(new BusStrategy());
// calculator.setStrategy(new TaxiStrategy());
System.out.println("公交车20km价格：" + calculator.calclatePrice(20));
}
}
传统写法
//PriceCalculator 类很明显的问题就是并不是单一职责，首先它承担计算公交车和地铁乘坐价格的职责，
//另一个问题就是通过if-else的形式来判断使用哪种计算形式。当我们增加一种出行方式时，如出租车，
//那么我们就需要在PriceCalculator 中增加一个方法来计算出租车出行的价格，并且在calculatePrice(int km, int type)函数增加一个判断
public static class PriceCalculator {
private static final int TAXI = 3;
private static final int BUS = 1;
private static final int SUBWAY = 2;
public static void main(String[] strings) {
PriceCalculator calculator = new PriceCalculator();
System.out.println("做20km公交票价：" + calculator.calculatePrice(20, BUS));
System.out.println("做20km地铁票价：" + calculator.calculatePrice(20, SUBWAY));
}
private int busPrice(int km) {
return km * 1;
}
public int taxiPrice(int km) {
return km * 7;
}
/**
* 根据不同类型计算
*/
int calculatePrice(int km, int type) {
if (type == BUS) {
return busPrice(km);
} else if (type == SUBWAY) {
return taxiPrice(km);
}
return 0;
}
}
组合：组合模式使得用户对单个对象和组合对象的使用具有一致性。将对象组合成树形结构以表示“部分-整体”的层次结构。
Component : 组合中的对象声明接口，在适当的情况下，实现所有类共有接口的默认行为。
Leaf : 表示叶节点对象。叶子节点没有子节点。
Composite : 定义枝节点行为，用来存储子部件，在 Component 接口中实现与子部件相关的操作。例如 Add 和 Remove
public abstract class File {
private String name;
public File(String name) {
this.name = name;
}
//操作方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public abstract void watch();
//组合方法
public void add(File file) {
throw new UnsupportedOperationException();
}
public void remove(File file) {
throw new UnsupportedOperationException();
}
public File getChild(int position) {
throw new UnsupportedOperationException();
}
}
public class Folder extends File {
private List<File> mFileList;
public Folder(String name) {
super(name);
mFileList = new ArrayList<>();
}
@Override
public void watch() {
StringBuffer fileName = new StringBuffer();
for (File file : mFileList) {
fileName.append(file.getName() + "；");
}
System.out.println("组合模式:这是一个叫" + getName() + "文件夹，包含" + mFileList.size() + "个文件，分别是：" + fileName);
}
@Override
public void add(File file) {
mFileList.add(file);
}
@Override
public void remove(File file) {
mFileList.remove(file);
}
@Override
public File getChild(int position) {
return mFileList.get(position);
}
}
public class TextFile extends File {
public TextFile(String name) {
super(name);
}
@Override
public void watch() {
System.out.println("组合模式:这是一个叫" + getName() + "文本文件");
}
}
public class testComposite {
public static void main(String[] strings) {
TextFile textFileA = new TextFile("a.txt");
TextFile textFileB = new TextFile("b.txt");
TextFile textFileC = new TextFile("c.txt");
textFileA.watch();
// textFileA.add(textFileB);//调用会抛我们在抽象接口中写的异常
Folder folder = new Folder("学习资料");
folder.add(textFileA);
folder.add(textFileB);
folder.add(textFileC);
folder.watch();
folder.getChild(1).watch();
Folder folder1 = new Folder("个人资料");
folder1.add(textFileA);
folder1.add(textFileB);
//可以随便组合
Folder folder2 = new Folder("D盘资料");
folder2.add(folder);
folder2.add(folder1);
}
}
观察者模式：定义对象之间的一种一对多依赖关系，使得每当一个对象状态发生改变时，其相关依赖对象皆可得到通知并被自动更新。
观察者模式在android中的实际运用：回调模式
回调模式：实现了抽象类／接口的实例实现了父类的提供的抽象方法后，将该方法交还给父类来处理。
例如：通过 setOnClickListener() 方法，Button 持有 OnClickListener 的引用（这一过程没有在图上画出）；当用户点击时，Button 自动调用 OnClickListener 的 onClick() 方法。另外，如果把这张图中的概念抽象出来（Button（view） -> 被观察者、OnClickListener -> 观察者、setOnClickListener() -> 订阅，onClick() -> 事件），就由专用的观察者模式（例如只用于监听控件点击）转变成了通用的观察者模式。
public class ObserverPattern {
public interface Observer {
void update(String state);
}
public class ConcreteObserver implements Observer {
// 观察者状态
private String observerState;
@Override
public void update(String state) {
// 更新观察者状态，让它与目标状态一致
observerState = state;
System.out.println("ConcreteObserver State :" + observerState);
}
}
/**
* 抽象订阅者（目标者）
* 被观察者
*
*/
public abstract class Subject {
// 保存注册的观察者对象
private List<Observer> mObservers = new ArrayList<>();
//注册观察者对象
public void attach(Observer observer) {
mObservers.add(observer);
System.out.println("Attached an observer");
}
//注销观察者对象
public void detach(Observer observer) {
mObservers.remove(observer);
}
// 通知所有注册的观察者对象
public void nodifyObservers(String newState) {
for (Observer observer : mObservers) {
observer.update(newState);
}
}
}
public class ConcreteSubject extends Subject {
private String state;
public String getState() {
return state;
}
public void change(String newState) {
state = newState;
System.out.println("ConcreteSubject State:" + state);
//状态发生改变，通知观察者
nodifyObservers(state);
}
}
public static void main(String[] args) {
ObserverPattern observerPattern = new ObserverPattern();
ConcreteSubject concreteSubject = observerPattern.new ConcreteSubject();
Observer observer1 = observerPattern.new ConcreteObserver();
Observer observer2 = observerPattern.new ConcreteObserver();
// 将观察者对象注册到目标对象上
concreteSubject.attach(observer1);
concreteSubject.attach(observer2);
// 改变目标对象的状态
concreteSubject.change("I change");
}
}
相关源码：
https://github.com/peiniwan/DesignPattern.git
版权声明：本文为liuyu0529原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。