依赖它的对象都会得到通知并自动更新这里的对象指的是Observable目标依赖目标的对象是Observer观察者Observer观察者必须调用addObserver方法将Observer观察者注册到Observable目标的容器中Observable目标监听到事件发生会调用notify方法通知所有的Observer观察者自动更新观察者模式又叫做发布订阅模式它的优点是如果新增一个功能监听事件发生可以创建一个新的Observer观察者不需要修改Observable目标耦合性小

分析在点击页面的代码前后加上这两个逻辑硬编码如果不同公司的用户点击页面的行为不一样呢

优化思路采用观察者模式定义Observer接口每次添加一个逻辑会创建一个观察者对象观察者对象需要先注册到Customer对象中的容器然后调用notify方法会发布消息会循环调用每个观察者对象的update方法Java提供了Observer观察者对象和Observable目标

public

{customer.addObserver(observer);}customer.clickPage();}public

class

必须先设置changedtrue才会循环调用Observer的update方法//

Observable类的setChanged方法是protected只能在这个包下或者子类调用setChanged方法//

每个业务对变化的定义不同因此它是由子类判断是否变化super.setChanged();super.notifyObservers();}}public

class

{System.out.println(观察者Observer

WelcomLetter向目标

{System.out.println(观察者Observer

AddVerify向目标

发送一个验证消费者的地址);}}}Java包含了观察者模式的类Observer类是观察者Observable类是目标

创建WelcomeLetter、AddVerify两个Observer观察者对象重写update方法

创建Customer类继承Observable类创建clickPage方法当用户点击页面会先调用setChanged方法然后调用notifyObservers方法通知所有的观察者对象

public

}Observer接口包含update方法入参是Observable目标和参数arg

public

obs.toArray();clearChanged();}for

(int

i--)((Observer)arrLocal[i]).update(this,

arg);}public

{obs.removeAllElements();}protected

synchronized

}Observable类包含changed表示是否变化的标志和obs这个Vector容器它保存了Observer集合addObserver方法可以将Observer观察者对象添加到Vector容器中

notifyObservers方法会先判断changed必须是true才会复制Vector容器的元素到一个数组中然后从后向前逆序遍历数组并调用Observer观察者对象的update方法逆序是因为防止并发场景如果正序遍历在循环遍历的时候某个观察者对象从Vector容器中取消了会导致数组的索引变化了导致并发修改异常

setChanged方法是protected类型的因为每个业务都变化的定义都不相同因此可以创建一个子类继承Observable类自己定义什么时候需要调用setChanged方法表示数据变化了

public

ObservableFactory();ObservableFactory.Customer

customer

Customer();ObservableFactory.WelcomeLetter

welcomeLetter

WelcomeLetter();ObservableFactory.AddVerify

addVerify

ArrayList(2);list.add(welcomeLetter);list.add(addVerify);observableFactory.clickPage(customer,

list);}

}TaskController是创建Customer对象、WelcomeLetter、AddVerify调用clickPage方法可以发布并且观察者可以得到通知并自动更新

测试结果

状态模式是对象有多种状态不同状态之间的变化封装在不同的状态类中思路是定义一个状态接口和多个状态实现类每个状态实现类都重写转换到其他状态的方法最后定义一个活动类通过map.get得到对应的状态类并调用方法

public

ActivityStartedState());map.put(暂停,

new

ActivityResumedState());map.put(结束,

new

{map.get(state).startActivity(this);}public

void

{map.get(state).resumeActivity(this);}public

void

{map.get(state).endActivity(this);}}public

interface

{System.out.println(活动已经启动了不能重复启动);}Overridepublic

void

{System.out.println(活动暂停);activity.setState(暂停);System.out.println(state

activity.getState());}Overridepublic

void

{System.out.println(活动结束);activity.setState(结束);System.out.println(state

class

{System.out.println(活动重新启动);activity.setState(启动);System.out.println(state

activity.getState());}Overridepublic

void

{System.out.println(活动已经暂停了不能重复暂停);}Overridepublic

void

{System.out.println(活动结束);activity.setState(结束);System.out.println(state

class

{System.out.println(活动启动);activity.setState(启动);System.out.println(state

activity.getState());}Overridepublic

void

{System.out.println(活动已经结束不能暂停);}Overridepublic

void

{System.out.println(活动已经结束不能重复结束);}}}定义一个状态接口和多个状态实现类每个状态类都重写转换到其他状态的方法还定义了一个活动类封装了state状态表示活动的当前状态封装了一个Map可以存放不同的state和对应的状态对象通过map.get方法得到状态对象并调用状态对象的方法

Test

StateFactory();StateFactory.Activity

activity

Activity();activity.startActivity();activity.resumeActivity();activity.endActivity();

}创建一个活动对象活动对象的状态初始化是结束状态先调用活动对象的start方法可以从结束状态转换到启动状态然后调用活动对象的resume方法可以从启动状态转换到暂停状态最后调用活动对象的end方法可以从暂停状态转换到结束状态

测试结果

责任链模式是允许多个对象都可以处理请求会将这些对象连成一个链直到有一个对象可以处理请求为止思路是定义一个抽象类组合一个对象因为每个对象都持有下一个对象的引用

public

{System.out.println(打印debug日志);}

else

{nextLogger.log(logLevel);}}}public

class

{System.out.println(打印info日志);}

else

{nextLogger.log(logLevel);}}}public

class

{System.out.println(打印error日志);}

else

{nextLogger.log(logLevel);}}}}定义一个抽象类它组合了下一个对象抽象方法log方法用来打印日志多个继承类可以重写log方法如果条件不满足就调用下一个对象的log方法

Test

LoggerFactory();LoggerFactory.DebugLogger

debugLogger

DebugLogger();LoggerFactory.InfoLogger

infoLogger

InfoLogger();LoggerFactory.ErrorLogger

errorLogger

ErrorLogger();debugLogger.setNextLogger(infoLogger);infoLogger.setNextLogger(errorLogger);debugLogger.log(2);debugLogger.log(1);debugLogger.log(0);

}创建一个对象链如果这个对象满足条件会打印日志如果不满足条件会沿着对象链调用下一个对象的打印日志方法

输出结果

第一个方法打印日志是error第二个方法打印日志是info第三个方法打印日志是debug

2.4

策略模式是定义多个算法它们可以相互替换定义一个抽象类和多个实现类寻找可变的参数并封装到这个抽象类中

分析直接if

优化思路计算税用一个抽象类定义一个抽象方法多个实现类重写这个方法就可以计算不同国家的税

public

price);System.out.println(calcTax.getClass()

total

1.5;}}}CalcTax抽象类和继承类都封装在SalesOrder类中CalcTax抽象类作为SalesOrder类的process方法的入参

public

USTax();salesOrder.process(usTax,

canTax

CanTax();salesOrder.process(canTax,

15);}

}TaskController类的f1方法创建SalesOrder类的对象和成员内部类的对象USTax和CanTax最后SalesOrder对象调用process方法入参传入成员内部类的对象USTax和CanTax

2.5

模板方法模式是定义算法的骨架将一些步骤推迟到子类中实现父类定义多个抽象方法子类实现这些抽象方法父类还定义了一个普通方法这个普通方法封装了这些抽象方法

分析对每个数据库都创建一个方法重复代码多

优化思路创建一个抽象类封装了连接数据库的抽象方法和查询数据库的抽象方法还封装了一个普通方法这个普通方法封装了这些抽象方法每个数据库都创建一个实现类重写连接数据库的抽象方法和查询数据库的抽象方法

public

{queryDBTemplate.doQuery();}abstract

public

{getConnection();selectFromDB();}}public

class

{System.out.println(MysqlDB获取连接);}Overridepublic

void

{System.out.println(MysqlDB查询数据库的数据);}}public

class

{System.out.println(OracleDB获取连接);}Overridepublic

void

{System.out.println(OracleDB查询数据库的数据);}}}定义一个抽象类QueryDBTemplate定义抽象方法getConnection和selectFromDB抽象类中还定义了一个普通方法doQuerydoQuery方法封装了这两个抽象方法可以减少重复代码

public

QueryDBFactory();QueryDBFactory.QueryDBTemplate

queryDBTemplate

MysqlDB();queryDBFactory.doQuery(queryDBTemplate);System.out.println();queryDBTemplate

queryDBFactory.new

OracleDB();queryDBFactory.doQuery(queryDBTemplate);}

测试结果

模板模式在抽象类中定义普通方法是每个数据库都先获取连接然后查询数据库的数据

2.6

命令模式是将请求和执行解耦合使得请求不知道执行的具体实现用于封装操作并延迟执行这些操作思路是创建一个命令接口创建多个命令类实现这个接口命令类中组合了请求对象

public

{System.out.println(工作);}public

void

{System.out.println(运动);}public

void

{System.out.println(睡觉);}}public

class

{person.sleep();}}}创建一个命令接口Command创建多个实现类作为命令组合了Person对象

Test

CommandFactory();CommandFactory.Person

person

Person();CommandFactory.WorkCommand

workCommand

WorkCommand(person);CommandFactory.SportCommand

sportCommand

SportCommand(person);CommandFactory.SleepCommand

sleepCommand

SleepCommand(person);workCommand.execute();sportCommand.execute();sleepCommand.execute();

}测试结果

迭代器模式是顺序遍历数组的所有元素不用关心数组的实现可以将遍历和数组的实现解耦合

public

arr[index];}}}通过迭代器遍历数组需要先创建迭代器接口创建一个类实现迭代器接口

Test

String[]{a,b,c,d,e};IteratorFactory.Hobbies

hobbies

{System.out.println(hobbies.next());}

测试结果

中介者模式是用一个中介者对象封装对象之间的交互可以降低对象之间的耦合

public

{System.out.println(sender.getName()

send

msg);}}}用户对象之间的交互需要通过QQ这个中介者对象进行交互因此用户对象应该持有中介者对象QQ

Test

MediatorFactory();MediatorFactory.QQ

mediatorFactory.new

备忘录模式是在破坏对象封装性的前提下恢复状态思路是创建备忘录对象来保存对象状态

public

memento.getState();}}}创建备忘录类MementoActivity活动类在修改活动状态的时候会返回备忘录对象通过restore方法可以恢复活动对象的状态

Test

MementoFactory();MementoFactory.Activity

activity

Activity();MementoFactory.Memento

beginMemento

activity.begin();MementoFactory.Memento

resumeMemento

activity.resume();MementoFactory.Memento

endMemento

activity.end();activity.restore(endMemento);System.out.println(activity.getState());activity.restore(resumeMemento);System.out.println(activity.getState());activity.restore(beginMemento);System.out.println(activity.getState());

}创建活动对象创建备忘录对象通过restore方法可以恢复活动状态

测试结果

解释器模式是解释执行语言的表达式会将每个表达式抽象成一个类通过组合表达式可以构建复杂的表达式

public

number2.interpreter();}}}解释器模式会定义一个解释器接口定义数字解释器和相加操作的解释器重写interpreter方法

Test

InterpreterFactory();InterpreterFactory.NumberInterpreter

number1

NumberInterpreter(3);InterpreterFactory.NumberInterpreter

number2

NumberInterpreter(6);InterpreterFactory.AddInterpreter

addInterpreter

number2);System.out.println(addInterpreter.interpreter());

测试结果

访问者模式是在不改变元素类的前提下定义这些元素的操作将数据结构和操作分离开使得操作可以独立的变化

public

{element1.log1();}Overridepublic

void

{visitor.visitElement1(this);}public

void

{System.out.println(打印元素1的日志);}}public

class

{visitor.visitElement2(this);}public

void

{System.out.println(打印元素2的日志);}}}定义元素定义访问者接口和实现类

Test

VisitorFactory();VisitorFactory.Element1

element1

Element1();VisitorFactory.Element2

element2

Element2();VisitorFactory.RealVisitor

realVisitor

RealVisitor();element1.accept(realVisitor);element2.accept(realVisitor);

}调用元素的accept方法可以调用访问者visitor的方法

测试结果

3里氏替换原则子类可以替换父类的方法保证程序运行正常子类可以实现父类没有的方法完成新增功能但是子类不应该重写父类的方法

假设有一个父类

fly()表示鸟类能够飞行。

如果我们按照里氏替换原则Penguin

类企鹅继承自

方法好即不能飞要么导致错误或异常例如抛出不适当的异常则违反了里氏替换原则

fly()

类中移除因为企鹅并不符合“可以飞”的行为约定。

在这种情况下我们可能会创建一个

FlyingBird

4依赖反转原则抽象不要依赖细节细节应该依赖抽象这里抽象指的是接口和抽象类

5接口隔离原则尽可能将一个接口拆分成多个小接口客户端不应该依赖它不需要的接口

6合成复用原则尽量使用组合替换继承