简单工厂模式.docx

简单工厂模式.docx

《简单工厂模式.docx》由会员分享，可在线阅读，更多相关《简单工厂模式.docx（22页珍藏版）》请在冰豆网上搜索。

简单工厂模式

简单工厂模式

简单工厂模式包含如下角色：

Factory：

工厂角色

Product：

抽象产品角色

ConcreteProduct：

具体产品角色

publicvoidpay（Stringtype）

{

if（type.equalsIgnoreCase（"cash"））

{

//现金支付处理代码

}

elseif（type.equalsIgnoreCase（"creditcard"））

{

//信用卡支付处理代码

}

elseif（type.equalsIgnoreCase（"voucher"））

{

//代金券支付处理代码

}

else

{

……

}

}

代码复杂，难以维护

重构后的代码：

publicabstractclassAbstractPay

{

publicabstractvoidpay（）;

}

publicclassCashPayextendsAbstractPay

{

publicvoidpay（）

{

//现金支付处理代码

}

}

publicclassPayMethodFactory

{

publicstaticAbstractPaygetPayMethod（Stringtype）

{

if（type.equalsIgnoreCase（"cash"））

{

returnnewCashPay（）;//根据参数创建具体产品

}

elseif（type.equalsIgnoreCase（"creditcard"））

{

returnnewCreditcardPay（）;//根据参数创建具体产品

}

……

}

}

工厂方法模式

工厂方法模式包含如下角色：

Product：

抽象产品

ConcreteProduct：

具体产品

Factory：

抽象工厂

ConcreteFactory：

具体工厂

抽象工厂类代码：

publicabstractclassPayMethodFactory

{

publicabstractAbstractPaygetPayMethod（）;

}

具体工厂类代码：

publicclassCashPayFactoryextendsPayMethodFactory

{

publicAbstractPaygetPayMethod（）

{

returnnewCashPay（）;

}

}

客户类代码片段：

PayMethodFactoryfactory;

AbstractPaypayMethod;

factory=newCashPayFactory（）;

payMethod=factory.getPayMethod（）;

payMethod.pay（）;

抽象工厂模式

抽象工厂模式包含如下角色：

AbstractFactory：

抽象工厂

ConcreteFactory：

具体工厂

AbstractProduct：

抽象产品

Product：

具体产品

抽象工厂类的典型代码如下：

publicabstractclassAbstractFactory

{

publicabstractAbstractProductAcreateProductA（）;

publicabstractAbstractProductBcreateProductB（）;

}

具体工厂类的典型代码如下：

publicclassConcreteFactory1extendsAbstractFactory

{

publicAbstractProductAcreateProductA（）

{

returnnewConcreteProductA1（）;

}

publicAbstractProductBcreateProductB（）

{

returnnewConcreteProductB1（）;

}

}

抽象产品类：

PublicabstractclassAbsractProductA（）{

//每个产品共有的方法

PublicvoidshareMethod（）{

}

//每个产品相同方法，不同实现

PublicabstractvoiddoSomething（）;

}

具体产品A1:

PublicclassProductA1extendsAbstractProductA{

PublicvoiddoSomething（）{

System.out.println（“产品A1的实现方法”）

}

}

具体产品A2：

PublicclassProductA2extendsAbstractProductA{

PublicvoiddoSomething（）{

System.out.println（“产品A2的实现方法”）

}

}

产品等级1：

PublicclassCreator1extendsAbsractCreator{

//只生产产品等级为1的A产品

PublicAbstractPorductAcreatProductA（）{

ReturnnewProductA（）;

}

//只生产产品等级为1的B产品

PublicAbstractProductBcreatProductB（）{

ReturnnewProductB（）;

}

}

原型模式

原型模式包含如下角色：

Prototype：

抽象原型类

ConcretePrototype：

具体原型类

Client：

客户类

PublicPrototypeClassclone（）{

@override

PublicPrototypeClassprototypeClass=null;

Try{

prototypeClass=（prototypeClass）super.clone（）;

}catch（CloneNotSupportedExceptione）{

}

ReturnprototypeClass;

}

}

单例模式

单例模式的实现代码如下所示：

publicclassSingleton

{

privatestaticSingletoninstance=null;//静态私有成员变量

//私有构造函数

privateSingleton（）

{

}

//静态公有工厂方法，返回唯一实例

publicstaticSingletongetInstance（）

{

if（instance==null）

instance=newSingleton（）;

returninstance;

}

}

适配器模式

类适配器

对象适配器

适配器模式包含如下角色：

Target：

目标抽象类

Adapter：

适配器类

Adaptee：

适配者类

Client：

客户类

典型的类适配器代码：

publicclassAdapterextendsAdapteeimplementsTarget

{

publicvoidrequest（）

{

specificRequest（）;

}

}

典型的对象适配器代码：

publicclassAdapterextendsTarget

{

privateAdapteeadaptee;

publicAdapter（Adapteeadaptee）

{

this.adaptee=adaptee;

}

publicvoidrequest（）

{

adaptee.specificRequest（）;

}

}

桥接模式

桥接模式包含如下角色：

Abstraction：

抽象类

RefinedAbstraction：

扩充抽象类

Implementor：

实现类接口

ConcreteImplementor：

具体实现类

典型的实现类接口代码：

publicinterfaceImplementor

{

publicvoidoperationImpl（）;

}

典型的抽象类代码：

publicabstractclassAbstraction

{

protectedImplementorimpl;

publicvoidsetImpl（Implementorimpl）

{

this.impl=impl;

}

publicabstractvoidoperation（）;

}

典型的扩充抽象类代码：

publicclassRefinedAbstractionextendsAbstraction

{

publicvoidoperation（）

{

//代码

impl.operationImpl（）;

//代码

}

}

外观模式

观模式包含如下角色：

Facade:

外观角色

SubSystem:

子系统角色

典型的外观角色代码：

publicclassFacade

{

privateSubSystemAobj1=newSubSystemA（）;

privateSubSystemBobj2=newSubSystemB（）;

privateSubSystemCobj3=newSubSystemC（）;

publicvoidmethod（）

{

obj1.method（）;

obj2.method（）;

obj3.method（）;

}

}

代理模式

代理模式包含如下角色：

Subject:

抽象主题角色

Proxy:

代理主题角色

RealSubject:

真实主题角色

抽象主踢类：

PublicinterfaceSubject{

//定义一个方法

Publicvoidrequest（）;

}

PublicclassRealSubjectimplementsSubject{

Publicvoidrequest（）{

}

}

典型的代理类实现代码：

publicclassProxyimplementsSubject

{

privateRealSubjectrealSubject=newRealSubject（）;

publicvoidpreRequest（）

{…...}

publicvoidrequest（）

{

preRequest（）;

realSubject.request（）;

postRequest（）;

}

publicvoidpostRequest（）

{……}

}

命令模式

命令模式包含如下角色：

Command:

抽象命令类

ConcreteCommand:

具体命令类

Invoker:

调用者

Receiver:

接收者

Client:

客户类

典型的抽象命令类代码：

publicabstractclassCommand

{

publicabstractvoidexecute（）;

}

典型的调用者代码：

publicclassInvoker

{

privateCommandcommand;

publicInvoker（Commandcommand）

{

mand=command;

}

publicvoidsetCommand（Commandcommand）

{

mand=command;

}

//业务方法，用于调用命令类的方法

publicvoidcall（）

{

command.execute（）;

}

}

典型的具体命令类代码：

publicclassConcreteCommandextendsCommand

{

privateReceiverreceiver;

publicvoidexecute（）

{

receiver.action（）;

}

}

典型的请求接收者代码：

publicclassReceiver

{

publicvoidaction（）

{

//具体操作

}

}

迭代器模式

迭代器模式包含如下角色：

Iterator:

抽象迭代器

ConcreteIterator:

具体迭代器

Aggregate:

抽象聚合类

ConcreteAggregate:

具体聚合类

实例：

电视机遥控器

电视机遥控器就是一个迭代器的实例，通过它可以实现对电视机频道集合的遍历操作，本实例我们将模拟电视机遥控器的实现。

观察者模式

观察者模式包含如下角色：

Subject:

目标

ConcreteSubject:

具体目标

Observer:

观察者

ConcreteObserver:

具体观察者

典型的抽象目标类代码如下所示：

publicabstractclassSubject

{

protectedArrayListobservers=newArrayList（）;

publicabstractvoidattach（Observerobserver）;

publicabstractvoiddetach（Observerobserver）;

publicabstractvoidnotify（）;

}

publicclassConcreteSubjectextendsSubject

{

publicvoidattach（Observerobserver）

{

observers.add（observer）;

}

典型的具体目标类代码如下所示：

publicvoiddetach（Observerobserver）

{

observers.remove（observer）;

}

publicvoidnotify（）

{

for（Objectobs:

observers）

{

（（Observer）obs）.update（）;

}

}

}

典型的抽象观察者代码如下所示：

publicinterfaceObserver

{

publicvoidupdate（）;

}

典型的具体观察者代码如下所示：

publicclassConcreteObserverimplementsObserver

{

publicvoidupdate（）

{

//具体更新代码

}

}

客户端代码片段如下所示：

Subjectsubject=newConcreteSubject（）;

Observerobserver=newConcreteObserver（）;

subject.attach（observer）;

subject.notify（）;

策略模式

策略模式包含如下角色：

Context:

环境类

Strategy:

抽象策略类

ConcreteStrategy:

具体策略类

不使用策略模式的代码：

publicclassContext

{

……

publicvoidalgorithm（Stringtype）

{

......

if（type=="strategyA"）

{

//算法A

}

elseif（type=="strategyB"）

{

//算法B

}

elseif（type=="strategyC"）

{

//算法C

}

......

}

……

}

重构之后的抽象策略类：

publicabstractclassAbstractStrategy

{

publicabstractvoidalgorithm（）;

}

重构之后的具体策略类：

publicclassConcreteStrategyAextendsAbstractStrategy

{

publicvoidalgorithm（）

{

//算法A

}

}

重构之后的环境类：

publicclassContext

{

privateAbstractStrategystrategy;

publicvoidsetStrategy（AbstractStrategystrategy）

{

this.strategy=strategy;

}

publicvoidalgorithm（）

{

strategy.algorithm（）;

}

}

客户端代码片段：

……

Contextcontext=newContext（）;

AbstractStrategystrategy;

strategy=newConcreteStrategyA（）;

person.setStrategy（strategy）;

person.algorithm（）;

……