设计模式

qq_41622788

于 2018-02-25 12:24:55 发布

阅读量282

点赞数

本文链接：https://blog.csdn.net/qq_41622788/article/details/79368059

版权

设计模式分类：

创建模式（单例、工厂、原型）

结构模式（装饰、适配器）

行为模式（命令模式）

一．单例模式

单例模式，是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中一个类只有一个实例。即一个类只有一个对象实例

懒汉模式

饿汉模式

二．工厂模式

1、简介

工厂模式主要是为创建对象提供了接口。工厂模式按照《Java与模式》中的提法分为三类：
1. 简单工厂模式(Simple Factory)
2. 工厂方法模式(Factory Method)
3. 抽象工厂模式(Abstract Factory)
这三种模式从上到下逐步抽象，在什么样的情况下我们应该记得使用工厂模式呢？

大体有两点：
1.在编码时不能预见需要创建哪种类的实例。
2.系统不应依赖于产品类实例如何被创建、组合和表达的细节

2、简单工厂模式

这个模式本身很简单而且使用在业务较简单的情况下。一般用于小项目或者具体产品很少扩展的情况（这样工厂类才不用经常更改）。
它由三种角色组成：
    ①工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑，根据逻辑不同，产生具体的工厂产品。
    ②抽象产品角色：它一般是具体产品继承的父类或者实现的接口。由接口或者抽象类来实现。如例中的Car接口。
    ③具体产品角色：工厂类所创建的对象就是此角色的实例。

下面来看简单工厂模式的例子：

//抽象产品
abstract class Car{
private String name;
public Car(String name) {
this.name=name
}
public abstract void drive();
}
//具体产品
class Benz extends Car{
public Benz(String name){
super(name);
}
public void drive(){
System.out.println(this.getName()+"----go-----------------------");
}
}
class Bmw extends Car{
public Bmw(String name){
super(name);
}
public void drive(){
System.out.println(this.getName()+"----go-----------------------");
}
}
//简单工厂
class CarFactory {
public static Car createCar(String car){
Car c = null;
if("Benz".equalsIgnoreCase(car))
c = new Benz();
else if("Bmw".equalsIgnoreCase(car))
c = new Bmw();
return c;
}
}
//测试
public class SimplyFactoryTest {
public static void main(String[] args) throws IOException {
//客户要奔驰车
Car car = CarFactory.createCar("Benz");
car.setName("benz");
//开着奔驰出发
car.drive();
}

这便是简单工厂模式了。那么它带了了什么好处呢？
首先，符合现实中的情况；而且客户端免除了直接创建产品对象的责任，而仅仅负责“消费”产品。
下面我们从开闭原则上来分析下简单工厂模式。当新增加了一辆车的时候，只要符合抽象产品制定的合同，那么只要通知工厂类知道就可以被客户使用了。（即创建一个新的车类，继承抽象产品Car）那么对于产品部分来说，它是符合开闭原则的——对扩展开放、对修改关闭；但是工厂类不太理想，因为每增加一辆车，都要在工厂类中增加相应的商业逻辑和判断逻辑，这显自然是违背开闭原则的。

而在实际应用中，很可能产品是一个多层次的树状结构。由于简单工厂模式中只有一个工厂类来对应这些产品，对于复杂的业务环境可能不太适应了。这就应该由工厂方法模式来出场了！！

3、工厂方法模式
①抽象工厂角色：这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须
实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。
②具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具
体产品的对象。在java中它由具体的类来实现。
③抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类
或者接口来实现。
④具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类
来实现。
工厂方法模式代码如下：

Java代码

//抽象产品
abstract class Car{
private String name;
public abstract void drive();
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
//具体产品
class Benz extends Car{
public void drive(){
System.out.println(this.getName()+"----go-----------------------");
}
}
class Bmw extends Car{
public void drive(){
System.out.println(this.getName()+"----go-----------------------");
}
}
//抽象工厂
abstract class CarFactory {
public abstract Car createCar(String car) throws Exception;
}
//具体工厂（每个具体工厂负责一个具体产品）
class BenzCarFactory extends CarFactory{
public Car createCar(String car) throws Exception {
return new Benz();
}
}
class Bmw CarFactory extends CarFactory{
public Car createCar(String car) throws Exception {
return new Bmw();
}
}
//测试类
public class Test {
public static void main(String[] args) throws Exception {
CarFactory d = new BenzCarFactory();
Car c = d.createCar("benz");
c.setName("benz");
c.drive();
}
}

使用开闭原则来分析下工厂方法模式。当有新的产品产生时，只要按照抽象产品角色、抽象工厂角色提供的合同来生成，那么就可以被客户使用，而不必去修改任何已有的代码。（即当有新产品时，只要创建并基础抽象产品；新建具体工厂继承抽象工厂；而不用修改任何一个类）工厂方法模式是完全符合开闭原则的！

如果不使用工厂模式来实现我们的例子，也许代码会减少很多——只需要实现已有的车，不使用多态。但是在可维护性上，可扩展性上是非常差的（你可以想象一下添加一辆车后要牵动的类）。因此为了提高扩展性和维护性，多写些代码是值得的。

5、抽象工厂模式
产品族：位于不同产品等级结构中，功能相关联的产品组成的家族。
BmwCar和BenzCar就是两个产品树（产品层次结构）；BenzSportsCar和BmwSportsCar就是一个产品族。他们都可以放到跑车家族中，因此功能有所关联。同理BmwBussinessCar和BenzBusinessCar也是一个产品族。
可以这么说，抽象工厂模式和工厂方法模式的区别就在于需要创建对象的复杂程度上。而且抽象工厂模式是三个里面最为抽象、最具一般性的。抽象工厂模式的用意为：给客户端提供一个接口，可以创建多个产品族中的产品对象。
而且使用抽象工厂模式还要满足一下条件：
1.系统中有多个产品族，而系统一次只可能消费其中一族产品
2.同属于同一个产品族的产品以其使用。
抽象工厂模式的各个角色（和工厂方法的如出一辙）：
①抽象工厂角色：这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须
实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。
②具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具
体产品的对象。在java中它由具体的类来实现。
③抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象
类或者接口来实现。
④具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的
类来实现。
Java代码

//抽象产品（Bmw和Audi同理）
abstract class BenzCar{
private String name;
public abstract void drive();
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
//具体产品（Bmw和Audi同理）
class BenzSportCar extends BenzCar{
public void drive(){
System.out.println(this.getName()+"----BenzSportCar-----------------------");
}
}
class BenzBusinessCar extends BenzCar{
public void drive(){
System.out.println(this.getName()+"----BenzBusinessCar-----------------------");
}
}
abstract class BmwCar{
private String name;
public abstract void drive();
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
class BmwSportCar extends BmwCar{
public void drive(){
System.out.println(this.getName()+"----BmwSportCar-----------------------");
}
}
class BmwBusinessCar extends BmwCar{
public void drive(){
System.out.println(this.getName()+"----BmwBusinessCar-----------------------");
}
}
abstract class AudiCar{
private String name;
public abstract void drive();
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
class AudiSportCar extends AudiCar{
public void drive(){
System.out.println(this.getName()+"----AudiSportCar-----------------------");
}
}
class AudiBusinessCar extends AudiCar{
public void drive(){
System.out.println(this.getName()+"----AudiBusinessCar-----------------------");
}
}
//抽象工厂
abstract class CarFactory {
public abstract BenzCar createBenzCar(String car) throws Exception;
public abstract BmwCar createBmwCar(String car) throws Exception;
public abstract AudiCar createAudiCar(String car) throws Exception;
}
//具体工厂
class SportCarFactory extends CarFactory{
public BenzCar createBenzCar(String car) throws Exception {
return new BenzSportCar();
}
public BmwCar createBmwCar(String car) throws Exception {
return new BmwSportCar();
}
public AudiCar createAudiCar(String car) throws Exception {
return new AudiSportCar();
}
}
class BusinessCarFactory extends CarFactory{
public BenzCar createBenzCar(String car) throws Exception {
return new BenzBusinessCar();
}
public BmwCar createBmwCar(String car) throws Exception {
return new BmwBusinessCar();
}
public AudiCar createAudiCar(String car) throws Exception {
return new AudiBusinessCar();
}
}
// 测试类
public class BossAbstractFactory {
public static void main(String[] args) throws Exception {
CarFactory d = new BusinessCarFactory();
AudiCar car = d.createAudiCar("");
car.drive();
}
}

其中：BenzSportCar和BenzBusinessCar属于产品树；同理BmwSportCar和BmwBusinessCar也属于产品树。而BenzSportCar和BmwSportCar和AudiSportCar属于产品族。
所以抽象工厂模式一般用于具有产品树和产品族的场景下。
抽象工厂模式的缺点：如果需要增加新的产品树，那么就要新增三个产品类，比如VolvoCar，VolvoSportCar,VolvoSportCar，并且要修改三个工厂类。

无论是简单工厂模式，工厂模式，还是抽象工厂模式，他们都属于工厂模式，在形式和特点上也是极为相似的，他们的最终目的都是为了解耦。在使用时，我们不必去在意这个模式到底工厂方法模式还是抽象工厂模式，因为他们之间的演变常常是令人琢磨不透的。经常你会发现，明明使用的工厂方法模式，当新需求来临，稍加修改，加入了一个新方法后，由于类中的产品构成了不同等级结构中的产品族，它就变成抽象工厂模式了；而对于抽象工厂模式，当减少一个方法使的提供的产品不再构成产品族之后，它就演变成了工厂方法模式。所以，在使用工厂模式时，只需要关心降低耦合度的目的是否达到了。

三．代理模式

1. 什么是代理

我们大家都知道微商代理，简单地说就是代替厂家卖商品，厂家“委托”代理为其销售商品。关于微商代理，首先我们从他们那里买东西时通常不知道背后的厂家究竟是谁，也就是说，“委托者”对我们来说是不可见的；其次，微商代理主要以朋友圈的人为目标客户，这就相当于为厂家做了一次对客户群体的“过滤”。我们把微商代理和厂家进一步抽象，前者可抽象为代理类，后者可抽象为委托类（被代理类）。通过使用代理，通常有两个优点，并且能够分别与我们提到的微商代理的两个特点对应起来：

优点一：可以隐藏委托类的实现；

优点二：可以实现客户与委托类间的解耦，在不修改委托类代码的情况下能够做一些额外的处理。

2. 静态代理

若代理类在程序运行前就已经存在，那么这种代理方式被成为静态代理，这种情况下的代理类通常都是我们在Java代码中定义的。通常情况下，静态代理中的代理类和委托类会实现同一接口或是派生自相同的父类。下面我们用Vendor类代表生产厂家，BusinessAgent类代表微商代理，来介绍下静态代理的简单实现，委托类和代理类都实现了Sell接口，Sell接口的定义如下：

public interface Sell {

void sell();

void ad();

}

Vendor类的定义如下：

public class Vendor implements Sell {

public void sell() {

System.out.println("In sell method");

}

public void ad() {

System,out.println("ad method")

}

代理类BusinessAgent的定义如下：

public class BusinessAgent implements Sell {

private Vendor mVendor;

public BusinessAgent(Vendor vendor) {

mVendor = vendor;

}

public void sell() { mVendor.sell(); }

public void ad() { mVendor.ad(); }

}

从BusinessAgent类的定义我们可以了解到，静态代理可以通过聚合来实现，让代理类持有一个委托类的引用即可。

下面我们考虑一下这个需求：给Vendor类增加一个过滤功能，只卖货给大学生。通过静态代理，我们无需修改Vendor类的代码就可以实现，只需在BusinessAgent类中的sell方法中添加一个判断即可如下所示：

public class BusinessAgent implements Sell {

...

public void sell() {

if (isCollegeStudent()) {

vendor.sell();

}

...

}

这对应着我们上面提到的使用代理的第二个优点：可以实现客户与委托类间的解耦，在不修改委托类代码的情况下能够做一些额外的处理。静态代理的局限在于运行前必须编写好代理类，下面我们重点来介绍下运行时生成代理类的动态代理方式。

3.动态代理

代理类在程序运行时创建的代理方式被称为动态代理。也就是说，这种情况下，代理类并不是在Java代码中定义的，而是在运行时根据我们在Java代码中的“指示”动态生成的。相比于静态代理，动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类的函数。这么说比较抽象，下面我们结合一个实例来介绍一下动态代理的这个优势是怎么体现的。

现在，假设我们要实现这样一个需求：在执行委托类中的方法之前输出“before”，在执行完毕后输出“after”。我们还是以上面例子中的Vendor类作为委托类，BusinessAgent类作为代理类来进行介绍。首先我们来使用静态代理来实现这一需求，相关代码如下：

public class BusinessAgent implements Sell {

private Vendor mVendor;

public BusinessAgent(Vendor vendor) {

this.mVendor = vendor;

}

public void sell() {

System.out.println("before");

mVendor.sell();

System.out.println("after");

}

public void ad() {

System.out.println("before");

mVendor.ad();

System.out.println("after");

}

从以上代码中我们可以了解到，通过静态代理实现我们的需求需要我们在每个方法中都添加相应的逻辑，这里只存在两个方法所以工作量还不算大，假如Sell接口中包含上百个方法呢？这时候使用静态代理就会编写许多冗余代码。通过使用动态代理，我们可以做一个“统一指示”，从而对所有代理类的方法进行统一处理，而不用逐一修改每个方法。下面我们来具体介绍下如何使用动态代理方式实现我们的需求。

4. 使用动态代理

（1）InvocationHandler接口

在使用动态代理时，我们需要定义一个位于代理类与委托类之间的中介类，这个中介类被要求实现InvocationHandler接口，这个接口的定义如下：

public interface InvocationHandler {

Object invoke(Object proxy, Method method, Object[] args);

}

从InvocationHandler这个名称我们就可以知道，实现了这个接口的中介类用做“调用处理器”。当我们调用代理类对象的方法时，这个“调用”会转送到invoke方法中，代理类对象作为proxy参数传入，参数method标识了我们具体调用的是代理类的哪个方法，args为这个方法的参数。这样一来，我们对代理类中的所有方法的调用都会变为对invoke的调用，这样我们可以在invoke方法中添加统一的处理逻辑（也可以根据method参数对不同的代理类方法做不同的处理）。因此我们只需在中介类的invoke方法实现中输出“before”，然后调用委托类的invoke方法，再输出“after”。下面我们来一步一步具体实现它。

（2）委托类的定义

动态代理方式下，要求委托类必须实现某个接口，这里我们实现的是Sell接口。委托类Vendor类的定义如下：

public class Vendor implements Sell {

public void sell() {

System.out.println("In sell method");

}

public void ad() {

System,out.println("ad method")

}

（3）中介类

上面我们提到过，中介类必须实现InvocationHandler接口，作为调用处理器”拦截“对代理类方法的调用。中介类的定义如下：

public class DynamicProxy implements InvocationHandler {

private Object obj; //obj为委托类对象；

public DynamicProxy(Object obj) {

this.obj = obj;

}

@Override

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

System.out.println("before");

Object result = method.invoke(obj, args);

System.out.println("after");

return result;

}

从以上代码中我们可以看到，中介类持有一个委托类对象引用，在invoke方法中调用了委托类对象的相应方法（第11行），看到这里是不是觉得似曾相识？通过聚合方式持有委托类对象引用，把外部对invoke的调用最终都转为对委托类对象的调用。这不就是我们上面介绍的静态代理的一种实现方式吗？实际上，中介类与委托类构成了静态代理关系，在这个关系中，中介类是代理类，委托类就是委托类；

代理类与中介类也构成一个静态代理关系，在这个关系中，中介类是委托类，代理类是代理类。也就是说，动态代理关系由两组静态代理关系组成，这就是动态代理的原理。下面我们来介绍一下如何”指示“以动态生成代理类。

（4）动态生成代理类

动态生成代理类的相关代码如下：

public class Main {

public static void main(String[] args) {

//创建中介类实例

DynamicProxy inter = new DynamicProxy(new Vendor());

//获取代理类实例sell

Sell sell = (Sell)(Proxy.newProxyInstance(Sell.class.getClassLoader(),

new Class[] {Sell.class}, inter));

//通过代理类对象调用代理类方法，实际上会转到invoke方法调用

sell.sell();

sell.ad();

}

在以上代码中，我们调用Proxy类的newProxyInstance方法来获取一个代理类实例。这个代理类实现了我们指定的接口并且会把方法调用分发到指定的调用处理器。这个方法的声明如下：

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException

方法的三个参数含义分别如下：

loader：定义了代理类的ClassLoder；
interfaces：代理类实现的接口列表
h：调用处理器，也就是我们上面定义的实现了InvocationHandler接口的类实例

四原型模式

定义：用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。

类图：

原型模式主要用于对象的复制，它的核心是就是类图中的原型类Prototype。Prototype类需要具备以下两个条件：

实现Cloneable接口。在java语言有一个Cloneable接口，它的作用只有一个，就是在运行时通知虚拟机可以安全地在实现了此接口的类上使用clone方法。在java虚拟机中，只有实现了这个接口的类才可以被拷贝，否则在运行时会抛出CloneNotSupportedException异常。
重写Object类中的clone方法。Java中，所有类的父类都是Object类，Object类中有一个clone方法，作用是返回对象的一个拷贝，但是其作用域protected类型的，一般的类无法调用，因此，Prototype类需要将clone方法的作用域修改为public类型。
原型模式是一种比较简单的模式，也非常容易理解，实现一个接口，重写一个方法即完成了原型模式。在实际应用中，原型模式很少单独出现。经常与其他模式混用，他的原型类Prototype也常用抽象类来替代。
实现代码：
[java] view plain copy

class Prototype implements Cloneable {
public Prototype clone(){
Prototype prototype = null;
try{
prototype = (Prototype)super.clone();
}catch(CloneNotSupportedException e){
e.printStackTrace();
}
return prototype;
}
}
class ConcretePrototype extends Prototype{
public void show(){
System.out.println("原型模式实现类");
}
}
public class Client {
public static void main(String[] args){
ConcretePrototype cp = new ConcretePrototype();
for(int i=0; i< 10; i++){
ConcretePrototype clonecp = (ConcretePrototype)cp.clone();
clonecp.show();
}
}
}
原型模式的优点及适用场景
       使用原型模式创建对象比直接new一个对象在性能上要好的多，因为Object类的clone方法是一个本地方法，它直接操作内存中的二进制流，特别是复制大对象时，性能的差别明显。
       使用原型模式的另一个好处是简化对象的创建，使得创建对象就像我们在编辑文档时的复制粘贴一样简单。
       因为以上优点，所以在需要重复地创建相似对象时可以考虑使用原型模式。比如需要在一个循环体内创建对象，假如对象创建过程比较复杂或者循环次数很多的话，使用原型模式不但可以简化创建过程，而且可以使系统的整体性能提高很多。
原型模式的注意事项

使用原型模式复制对象不会调用类的构造方法。因为对象的复制是通过调用Object类的clone方法来完成的，它直接在内存中复制数据，因此不会调用到类的构造方法。不但构造方法中的代码不会执行，甚至连访问权限都对原型模式无效。还记得单例模式吗？单例模式中，只要将构造方法的访问权限设置为private型，就可以实现单例。但是clone方法直接无视构造方法的权限，所以，单例模式与原型模式是冲突的，在使用时要特别注意。
深拷贝与浅拷贝。Object类的clone方法只会拷贝对象中的基本的数据类型，对于数组、容器对象、引用对象等都不会拷贝，这就是浅拷贝。如果要实现深拷贝，必须将原型模式中的数组、容器对象、引用对象等另行拷贝。例如：
[java] view plain copy

public class Prototype implements Cloneable {
private ArrayList list = new ArrayList();
public Prototype clone(){
Prototype prototype = null;
try{
prototype = (Prototype)super.clone();
prototype.list = (ArrayList) this.list.clone();
}catch(CloneNotSupportedException e){
e.printStackTrace();
}
return prototype;
}
}
由于ArrayList不是基本类型，所以成员变量list，不会被拷贝，需要我们自己实现深拷贝，幸运的是Java提供的大部分的容器类都实现了Cloneable接口。所以实现深拷贝并不是特别困难。

五．装饰模式

装饰模式又名包装(Wrapper)模式。装饰模式指的是在不必改变原类文件和使用继承的情况下，动态地扩展一个对象的功能。它是通过创建一个包装对象，也就是装饰来包裹真实的对象，是继承关系的一个替代方案。
但是纯粹的装饰模式很难找到，大多数的装饰模式的实现都是“半透明”的，而不是完全透明的。换言之，允许装饰模式改变接口，增加新的方法。半透明的装饰模式是介于装饰模式和适配器模式之间的。适配器模式的用意是改变所考虑的类的接口，也可以通过改写一个或几个方法，或增加新的方法来增强或改变所考虑的类的功能。
大多数的装饰模式实际上是半透明的装饰模式，这样的装饰模式也称做半装饰、半适配器模式。
咖啡是一种饮料，咖啡的本质是咖啡豆+水磨出来的。咖啡店现在要卖各种口味的咖啡，如果不使用装饰模式，那么在销售系统中，各种不一样的咖啡都要产生一个类，如果有4中咖啡豆，5种口味，那么将要产生至少20个类（不包括混合口味），非常麻烦。使用了装饰模式，只需要11个类即可生产任意口味咖啡（包括混合口味）。

/**
* 饮料接口
* @author Administrator
*
*/
public interface Beverage {
//返回商品描述
public String getDescription();
//返回价格
public double getPrice();
}

CoffeeBean1——具体被装饰的对象类1
[java] view plain copy
print ?

public class CoffeeBean1 implements Beverage {
private String description = "选了第一种咖啡豆";
@Override
public String getDescription() {
return description;
}
@Override
public double getPrice() {
return 50;
}
}

CoffeeBean2——具体被装饰的对象类2
[java] view plain copy
print ?

public class CoffeeBean2 implements Beverage {
private String description = "第二种咖啡豆！";
@Override
public String getDescription() {
return description;
}
@Override
public double getPrice() {
return 100;
}
}

Decorator——装饰类
[java] view plain copy
print ?

public class Decorator implements Beverage {
private String description = "我只是装饰器，不知道具体的描述";
@Override
public String getDescription() {
return description;
}
@Override
public double getPrice() {
return 0; //价格由子类来决定
}
}

Milk——具体装饰类，给咖啡加入牛奶
[java] view plain copy
print ?

public class Milk extends Decorator{
private String description = "加了牛奶！";
private Beverage beverage = null;
public Milk(Beverage beverage){
this.beverage = beverage;
}
public String getDescription(){
return beverage.getDescription()+"\n"+description;
}
public double getPrice(){
return beverage.getPrice()+20; //20表示牛奶的价格
}
}

Mocha——给咖啡加入摩卡
[java] view plain copy
print ?

public class Mocha extends Decorator {
private String description = "加了摩卡！";
private Beverage beverage = null;
public Mocha(Beverage beverage){
this.beverage = beverage;
}
public String getDescription(){
return beverage.getDescription()+"\n"+description;
}
public double getPrice(){
return beverage.getPrice()+49; //30表示摩卡的价格
}
}

Soy——给咖啡加入豆浆
[java] view plain copy
print ?

public class Soy extends Decorator {
private String description = "加了豆浆！";
private Beverage beverage = null;
public Soy(Beverage beverage){
this.beverage = beverage;
}
public String getDescription(){
return beverage.getDescription()+"\n"+description;
}
public double getPrice(){
return beverage.getPrice()+30; //30表示豆浆的价格
}
}

测试类：
[java] view plain copy
print ?

public class Test {
public static void main(String[] args) {
Beverage beverage = new CoffeeBean1(); //选择了第一种咖啡豆磨制的咖啡
beverage = new Mocha(beverage); //为咖啡加了摩卡
beverage = new Milk(beverage);
System.out.println(beverage.getDescription()+"\n加了摩卡和牛奶的咖啡价格："+beverage.getPrice());
}
}
装饰模式的缺点：
1，装饰模式虽然扩展性较高，但是没有设计二简洁，类的数量略多（但肯定比设计一少很多），如何取舍可扩展性和简洁性是个问题，有所选择就要有所牺牲
2，很难搞清楚一个类究竟被装饰了多少层，可能是1层，也可能是100层

六．适配器模式

在计算机编程中，适配器模式（有时候也称包装样式或者包装）将一个类的接口适配成用户所期待的。一个适配允许通常因为接口不兼容而不能在一起工作的类工作在一起，做法是将类自己的接口包裹在一个已存在的类中。

七命令模式

1.概念

　　将来自客户端的请求传入一个对象，从而使你可用不同的请求对客户进行参数化。用于“行为请求者”与“行为实现者”解耦，可实现二者之间的松耦合，以便适应变化。分离变化与不变的因素。

　　在面向对象的程序设计中，一个对象调用另一个对象，一般情况下的调用过程是：创建目标对象实例；设置调用参数；调用目标对象的方法。

但在有些情况下有必要使用一个专门的类对这种调用过程加以封装，我们把这种专门的类称作command类。

Command模式可应用于
a）整个调用过程比较繁杂，或者存在多处这种调用。这时，使用Command类对该调用加以封装，便于功能的再利用。
b）调用前后需要对调用参数进行某些处理。
c）调用前后需要进行某些额外处理，比如日志，缓存，记录历史操作等。

Command模式有如下效果：
a）将调用操作的对象和知道如何实现该操作的对象解耦。
b）Command是头等对象。他们可以像其他对象一样被操作和扩展。
c）你可将多个命令装配成一个符合命令。
d）增加新的Command很容易，因为这无需改变现有的类。

2.UML

3.代码

public interface Command {
    public void execute();
}

public class ConcreteCommand implements Command {

    private Receiver receiver = null;
    private String state;

    public ConcreteCommand(Receiver receiver){
       this.receiver = receiver;
    }
    public void execute() {
       receiver.action();
    }
}

public class Receiver {
    public void action(){
       //真正执行命令操作的功能代码
    }
}

public class Invoker {
    private Command command = null;

    public void setCommand(Command command) {
       this.command = command;
    }

    public void runCommand() {
       command.execute();
    }
}

public class Client {
    public void assemble(){
       //创建接收者
       Receiver receiver = new Receiver();
       //创建命令对象，设定它的接收者
       Command command = new ConcreteCommand(receiver);
       //创建Invoker，把命令对象设置进去
       Invoker invoker = new Invoker();
       invoker.setCommand(command);
    }
}

下面给个例子，是模拟对电视机的操作有开机、关机、换台命令。代码如下

//命令接收者
public class Tv {
　　public int currentChannel = 0;

　　public void turnOn() {
　　   System.out.println("The televisino is on.");
　　}

　　public void turnOff() {
　　   System.out.println("The television is off.");
　　}

　　public void changeChannel(int channel) {
　　   this.currentChannel = channel;
　　   System.out.println("Now TV channel is " + channel);
　　}
}

//执行命令的接口
public interface Command {
　　void execute();
}

//开机命令
public class CommandOn implements Command {
　　private Tv myTv;

　　public CommandOn(Tv tv) {
　　   myTv = tv;
　　}

　　public void execute() {
　　   myTv.turnOn();
　　}
}

//关机命令
public class CommandOff implements Command {
　　private Tv myTv;

　　public CommandOff(Tv tv) {
　　   myTv = tv;
　　}

　　public void execute() {
　　   myTv.turnOff();
　　}
}

//频道切换命令
public class CommandChange implements Command {
　　private Tv myTv;

　　private int channel;

　　public CommandChange(Tv tv, int channel) {
　　   myTv = tv;
　　 this.channel = channel;
　　}

　　public void execute() {
　　   myTv.changeChannel(channel);
　　}
}

//可以看作是遥控器吧
public class Control {
　　private Command onCommand, offCommand, changeChannel;

　　public Control(Command on, Command off, Command channel) {
　　 onCommand = on;
　　 offCommand = off;
　　   changeChannel = channel;
　　}

　　public void turnOn() {
　　   onCommand.execute();
　　}

　　public void turnOff() {
　　   offCommand.execute();
　　}

　　public void changeChannel() {
　　 changeChannel.execute();
　　}
}

//测试类
public class Client {
　　public static void main(String[] args) {
  　　 // 命令接收者
　　 Tv myTv = new Tv();
　　 // 开机命令
  　　 CommandOn on = new CommandOn(myTv);
  　　 // 关机命令
  　　 CommandOff off = new CommandOff(myTv);
  　　 // 频道切换命令
　　 CommandChange channel = new CommandChange(myTv, 2);
　　 // 命令控制对象
　　   Control control = new Control(on, off, channel);

  　　 // 开机
  　　 control.turnOn();
　　 // 切换频道
　　 control.changeChannel();
　　 // 关机
　　 control.turnOff();
　　}
}

执行结果为：
The televisino is on.
Now TV channel is 2
The television is off.