23种设计模式之五（代理模式）

代理模式：（为一个对象提供一个替身，以控制对这个对象的访问）

 被代理的对象可以是远程对象、创建开销大的对象或需要安全控制的对象；代理模式有很多变体，都是为了控制与管理对象访问。

代理模式包含如下角色：

ISubject：抽象主题角色，是一个接口。该接口是对象和它的代理共用的接口。

RealSubject：真实主题角色，是实现抽象主题接口的类。

Proxy：代理角色，内部含有对真实对象RealSubject的引用，从而可以操作真实对象。代理对象提供与真实对象相同的接口，以便在任何时刻都能代替真实对象。同时，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装。

实现动态代理的关键技术是反射。

例子：（通过这个例子，从不使用代理模式，到使用代理模式）

监控糖果机：地点、糖果库存和当前状态

ISubject：

package com.java.mmzs.agentmode.candymachine;

import java.io.Serializable;

public interface State extends Serializable{
    public void insertCoin();
    public void returnCoin();
    public void turnCrank();
    public void dispense();
    public void printstate();
    public String getstatename();
}

package com.java.mmzs.agentmode.candymachinermi;

import java.rmi.Remote;
import java.rmi.RemoteException;

import com.java.mmzs.agentmode.candymachine.State;

public interface CandyMachineRemote extends Remote{
    public String  getLocation() throws RemoteException;
    public int getCount() throws RemoteException;
    public State getstate() throws RemoteException;
}

RealSubject：

package com.java.mmzs.agentmode.candymachine;

public class OnReadyState implements State {
    private transient CandyMachine mCandyMachine;
    public OnReadyState(CandyMachine mCandyMachine)
    {
        this.mCandyMachine=mCandyMachine;
    }

    @Override
    public void insertCoin() {
        // TODO Auto-generated method stub
        System.out
        .println("you have inserted a coin,next,please turn crank!");
        mCandyMachine.setState(mCandyMachine.mHasCoin);
    }

    @Override
    public void returnCoin() {
        // TODO Auto-generated method stub
        System.out.println("you haven't inserted a coin yet!");
        
    }

    @Override
    public void turnCrank() {
        // TODO Auto-generated method stub
        System.out.println("you turned,but you haven't inserted a coin!");
        
    }

    @Override
    public void dispense() {
        // TODO Auto-generated method stub

    }

    @Override
    public void printstate() {
        // TODO Auto-generated method stub
        System.out.println("***OnReadyState***");
        
    }
    @Override
    public String getstatename() {
        // TODO Auto-generated method stub
        return "OnReadyState";
    }
}

package com.java.mmzs.agentmode.candymachine;

import java.util.Random;

public class HasCoin implements State {
    private transient CandyMachine mCandyMachine;

    public HasCoin(CandyMachine mCandyMachine) {
        this.mCandyMachine = mCandyMachine;
    }

    @Override
    public void insertCoin() {
        // TODO Auto-generated method stub
        System.out.println("you can't insert another coin!");

    }

    @Override
    public void returnCoin() {
        // TODO Auto-generated method stub
        System.out.println("coin return!");
        mCandyMachine.setState(mCandyMachine.mOnReadyState);
    }

    @Override
    public void turnCrank() {
        // TODO Auto-generated method stub
        System.out.println("crank turn...!");
        Random ranwinner=new Random();
        int winner=ranwinner.nextInt(10);
        if(winner==0)
        {
            mCandyMachine.setState(mCandyMachine.mWinnerState);

        }else
        {
            mCandyMachine.setState(mCandyMachine.mSoldState);

        }
        
    }

    @Override
    public void dispense() {
    }

    @Override
    public void printstate() {
        // TODO Auto-generated method stub
        System.out.println("***HasCoin***");

    }

    @Override
    public String getstatename() {
        // TODO Auto-generated method stub
        return "HasCoin State";
    }

}

package com.java.mmzs.agentmode.candymachine;

public class SoldState implements State {
    private transient CandyMachine mCandyMachine;
    public SoldState(CandyMachine mCandyMachine)
    {
        this.mCandyMachine=mCandyMachine;
    }

    @Override
    public void insertCoin() {
        // TODO Auto-generated method stub
        System.out.println("please wait!we are giving you a candy!");

    }

    @Override
    public void returnCoin() {
        // TODO Auto-generated method stub
        System.out.println("you haven't inserted a coin yet!");
        
    }

    @Override
    public void turnCrank() {
        // TODO Auto-generated method stub
        System.out
        .println("we are giving you a candy,turning another get nothing,!");

    }

    @Override
    public void dispense() {
        // TODO Auto-generated method stub
        
        mCandyMachine.releaseCandy();
        if (mCandyMachine.getCount() > 0) {
            mCandyMachine.setState(mCandyMachine.mOnReadyState);
        } else {
            System.out.println("Oo,out of candies");
            mCandyMachine.setState(mCandyMachine.mSoldOutState);
        }

    
    
    }

    @Override
    public void printstate() {
        // TODO Auto-generated method stub
        System.out.println("***SoldState***");
        
    }
    @Override
    public String getstatename() {
        // TODO Auto-generated method stub
        return "SoldState";
    }
}

package com.java.mmzs.agentmode.candymachine;

public class SoldOutState implements State {

    private  transient CandyMachine mCandyMachine;
    public SoldOutState(CandyMachine mCandyMachine)
    {
        this.mCandyMachine=mCandyMachine;
    }

    @Override
    public void insertCoin() {
        // TODO Auto-generated method stub
        System.out.println("you can't insert coin,the machine sold out!");
        
    }

    @Override
    public void returnCoin() {
        // TODO Auto-generated method stub
        System.out
        .println("you can't return,you haven't inserted a coin yet!");

    }

    @Override
    public void turnCrank() {
        // TODO Auto-generated method stub
        System.out.println("you turned,but there are no candies!");
        
    }

    @Override
    public void dispense() {
        // TODO Auto-generated method stub

    }

    @Override
    public void printstate() {
        // TODO Auto-generated method stub
        System.out.println("***SoldOutState***");
    
    }
    @Override
    public String getstatename() {
        // TODO Auto-generated method stub
        return "SoldOutState";
    }
}

package com.java.mmzs.agentmode.candymachine;

public class WinnerState implements State {

    private transient CandyMachine mCandyMachine;

    public WinnerState(CandyMachine mCandyMachine) {
        this.mCandyMachine = mCandyMachine;
    }

    @Override
    public void insertCoin() {
        // TODO Auto-generated method stub
        System.out.println("please wait!we are giving you a candy!");

    }

    @Override
    public void returnCoin() {
        // TODO Auto-generated method stub
        System.out.println("you haven't inserted a coin yet!");

    }

    @Override
    public void turnCrank() {
        // TODO Auto-generated method stub
        System.out
                .println("we are giving you a candy,turning another get nothing,!");

    }

    @Override
    public void dispense() {
        // TODO Auto-generated method stub

        
        mCandyMachine.releaseCandy();
        if (mCandyMachine.getCount() == 0) {
            mCandyMachine.setState(mCandyMachine.mSoldOutState);
        } else {
            System.out.println("you are a winner!you get another candy!");
            mCandyMachine.releaseCandy();
            if (mCandyMachine.getCount() > 0) {
                mCandyMachine.setState(mCandyMachine.mOnReadyState);
            } else {
                System.out.println("Oo,out of candies");
                mCandyMachine.setState(mCandyMachine.mSoldOutState);
            }
        }

    }

    @Override
    public void printstate() {
        // TODO Auto-generated method stub
        System.out.println("***WinnerState***");

    }
    @Override
    public String getstatename() {
        // TODO Auto-generated method stub
        return "WinnerState";
    }
}

package com.java.mmzs.agentmode.candymachine;

import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;

import com.java.mmzs.agentmode.candymachinermi.CandyMachineRemote;

public class CandyMachine extends UnicastRemoteObject implements CandyMachineRemote{

    State mSoldOutState;
    State mOnReadyState;
    State mHasCoin;
    State mSoldState;
    State mWinnerState;
    private String location="";
    private State state;
    private int count = 0;

    public CandyMachine(String location,int count) throws RemoteException{
        this.location=location;
        this.count = count;
        mSoldOutState = new SoldOutState(this);
        mOnReadyState = new OnReadyState(this);
        mHasCoin = new HasCoin(this);
        mSoldState = new SoldState(this);
        mWinnerState = new WinnerState(this);
        if (count > 0) {
            state = mOnReadyState;
        } else {
            state = mSoldOutState;
        }
    }
    public String getLocation()
    {
        return location;
    }
    public void setState(State state) {
        this.state = state;
    }

    public void insertCoin() {
        state.insertCoin();
    }

    public void returnCoin() {
        state.returnCoin();
    }

    public void turnCrank() {
        state.turnCrank();
        state.dispense();
    }

    void releaseCandy() {

        // TODO Auto-generated method stub
        if (count > 0) {
            count = count - 1;
            System.out.println("a candy rolling out!");
        }

    }

    public int getCount() {
        return count;
    }

    public void printstate() {
        state.printstate();
    }
    public State getstate() {
        return state;
    }
}

不使用代理：

package com.java.mmzs.agentmode;

import java.util.ArrayList;

import com.java.mmzs.agentmode.candymachine.CandyMachine;

public class Monitor {
    private ArrayList<CandyMachine> candyMachinelst;

    public Monitor() {
        candyMachinelst = new ArrayList<CandyMachine>();
    }

    public void addMachine(CandyMachine mCandyMachine) {
        candyMachinelst.add(mCandyMachine);
    }

    public void report() {
        CandyMachine mCandyMachine;
        for (int i = 0, len = candyMachinelst.size(); i < len; i++) {
            mCandyMachine = candyMachinelst.get(i);
            System.out.println("Machine Loc:" + mCandyMachine.getLocation());
            System.out.println("Machine Candy count:"
                    + mCandyMachine.getCount());
            System.out.println("Machine State:"
                    + mCandyMachine.getstate().getstatename());

        }

    }

}

package com.java.mmzs.agentmode;

import java.rmi.RemoteException;

import com.java.mmzs.agentmode.candymachine.CandyMachine;

public class MainTest {
    public static void main(String[] args) throws RemoteException {
        Monitor mMonitor=new Monitor();
        CandyMachine mCandyMachine = new CandyMachine("NY",6);
        mMonitor.addMachine(mCandyMachine);
        
        mCandyMachine = new CandyMachine("TK",4);
        mCandyMachine.insertCoin();
        mMonitor.addMachine(mCandyMachine);
        
        mCandyMachine = new CandyMachine("Bj",14);
        mCandyMachine.insertCoin();    
        mCandyMachine.turnCrank();
        mMonitor.addMachine(mCandyMachine);

        mMonitor.report();
    }
}

下面介绍一种代理RMI：

　　RMI远程方法调用是计算机之间通过网络实现对象调用的一种通讯机制。 使用这种机制，一台计算机上的对象可以调用另外 一台计算机上的对象来获取远程数据。 在过去，TCP/IP通讯是远程通讯的主要手段，面向过程的开发。 而RPC使程序员更容易地调用远程程序，但在面对复杂的信息传讯时，RPC依然未能很好的支持。

　　RMI被设计成一种面向对象开发方式，允许程序员使用远程对象来实现通信，

使用流程：

　　制作远程接口：接口文件

　　远程接口的实现：Service文件

　　RMI服务端注册，开启服务

　　RMI代理端通过RMI查询到服务端，建立联系，通过接口调用远程方法

package com.java.mmzs.agentmode.rmi;

import java.rmi.Remote;
import java.rmi.RemoteException;

public interface MyRemote extends Remote{

    public String sayHello() throws RemoteException;
    
}

package com.java.mmzs.agentmode.rmi;

import java.net.MalformedURLException;
import java.rmi.Naming;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.server.UnicastRemoteObject;

@SuppressWarnings("serial")
public class MyRemoteImpl extends UnicastRemoteObject implements MyRemote{

    protected MyRemoteImpl() throws RemoteException {
        super();
        // TODO Auto-generated constructor stub
    }

    @Override
    public String sayHello() throws RemoteException {
        // TODO Auto-generated method stub
        return "Hello World!";
    }
    public static void main(String[] args) {
        
        try {
            MyRemote service=new MyRemoteImpl();
            // LocateRegistry.createRegistry(6600);  
            Naming.rebind("rmi://127.0.0.1:6600/RemoteHello", service);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            System.out.println( e.toString());
        } 
        
        
    }
}

package com.java.mmzs.agentmode.rmi;

import java.rmi.Naming;

public class MyRemoteClient {
    public static void main(String[] args) {
        
        new MyRemoteClient().go();
    }
    
    public void go()
    {
        try {
            MyRemote service=(MyRemote)Naming.lookup("rmi://127.0.0.1:6600/RemoteHello");
            String s=service.sayHello();
            System.out.println(s);

        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } 
    }
}

接下来使用RMI改造糖果机的例子：

　　

package com.java.mmzs.agentmode.candymachinermi;

import java.rmi.Remote;
import java.rmi.RemoteException;

import com.java.mmzs.agentmode.candymachine.State;

public interface CandyMachineRemote extends Remote{
    public String  getLocation() throws RemoteException;
    public int getCount() throws RemoteException;
    public State getstate() throws RemoteException;
}

package com.java.mmzs.agentmode.candymachinermi;

import java.rmi.RemoteException;
import java.util.ArrayList;

import com.java.mmzs.agentmode.candymachine.CandyMachine;

public class Monitor {

    private ArrayList<CandyMachineRemote> candyMachinelst;

    public Monitor() {
        candyMachinelst = new ArrayList<CandyMachineRemote>();
    }

    public void addMachine(CandyMachineRemote mCandyMachine) {
        candyMachinelst.add(mCandyMachine);
    }

    public void report() {
        CandyMachineRemote mCandyMachine;
        for (int i = 0, len = candyMachinelst.size(); i < len; i++) {
            mCandyMachine = candyMachinelst.get(i);
            try {
                System.out
                        .println("Machine Loc:" + mCandyMachine.getLocation());

                System.out.println("Machine Candy count:"
                        + mCandyMachine.getCount());
                System.out.println("Machine State:"
                        + mCandyMachine.getstate().getstatename());
            } catch (RemoteException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

    }

}

package com.java.mmzs.agentmode.candymachinermi;

import java.rmi.Naming;
import java.rmi.registry.LocateRegistry;

import com.java.mmzs.agentmode.candymachine.CandyMachine;
import com.java.mmzs.agentmode.rmi.MyRemote;
import com.java.mmzs.agentmode.rmi.MyRemoteImpl;

public class RemoteMainTest {
    public static void main(String[] args) {

        try {
            CandyMachine service = new CandyMachine("test1", 7);
            // LocateRegistry.createRegistry(6602);
            Naming.rebind("rmi://127.0.0.1:6602/test1", service);
            service.insertCoin();
            service = new CandyMachine("test2", 5);
            Naming.rebind("rmi://127.0.0.1:6602/test2", service);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            System.out.println(e.toString());
        }

    }
}

package com.java.mmzs.agentmode.candymachinermi;

import java.rmi.Naming;

import com.java.mmzs.agentmode.candymachine.CandyMachine;
import com.java.mmzs.agentmode.rmi.MyRemote;

public class MainTest {

    public static void main(String[] args) {
        Monitor mMonitor = new Monitor();

        try {
            CandyMachineRemote mCandyMachine = (CandyMachineRemote) Naming
                    .lookup("rmi://127.0.0.1:6602/test1");
            mMonitor.addMachine(mCandyMachine);
            mCandyMachine = (CandyMachineRemote) Naming
                    .lookup("rmi://127.0.0.1:6602/test2");
            mMonitor.addMachine(mCandyMachine);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        mMonitor.report();
    }

}

  

几种常见的代理模式介绍：

虚拟代理：

　　虚拟代理为创建开销大的对象提供代理服务。 真正的对象在创建前和创建中时，由虚拟代理来扮演替身。

　　似乎很神秘，其实很简单 如：Android的在线图片加载类；

动态代理：可参照这篇文章

　　运行时动态的创建代理类，并将方法调用转发到指定类；

　　有n各主题类，但是代理类中的“前处理、后处理”都是一样的，仅调用主题不同。也就是说，多个主题类对应一个代理类，共享“前处理，后处理”功能，动态调用所需主题，大大减小了程序规模，这就是动态代理模式的特点。

看一个找对象项目： 约会服务系统代码讲解

package com.java.mmzs.agentmode.dyn;

public interface PersonBean {
    String getName();
    String getGender();
    String getInterests();
    int getHotOrNotRating();
    
    void setName(String name);
    void setGender(String gender);
    void setInterests(String interests);
    void setHotOrNotRating(int rating);
}

package com.java.mmzs.agentmode.dyn;

public class PersonBeanImpl implements PersonBean{
    String name;
    String gender;
    String interests;
    int rating;
    int ratingcount=0;
    @Override
    public String getName() {
        // TODO Auto-generated method stub
        return name;
    }

    @Override
    public String getGender() {
        // TODO Auto-generated method stub
        return gender;
    }

    @Override
    public String getInterests() {
        // TODO Auto-generated method stub
        return interests;
    }

    @Override
    public int getHotOrNotRating() {
        // TODO Auto-generated method stub
        if(ratingcount==0)         return 0;
        return (rating/ratingcount);
    }

    @Override
    public void setName(String name) {
        // TODO Auto-generated method stub
        this.name=name;
    }

    @Override
    public void setGender(String gender) {
        // TODO Auto-generated method stub
        this.gender=gender;
    }

    @Override
    public void setInterests(String interests) {
        // TODO Auto-generated method stub
        this.interests=interests;
    }

    @Override
    public void setHotOrNotRating(int rating) {
        // TODO Auto-generated method stub
        this.rating=rating;
        ratingcount++;
    }

}

package com.java.mmzs.agentmode.dyn;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class NonOwnerInvocationHandler implements InvocationHandler{
    PersonBean person;
    public NonOwnerInvocationHandler(PersonBean person)
    {
        this.person=person;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        // TODO Auto-generated method stub

        if(method.getName().startsWith("get"))
        {
            return method.invoke(person,args);
        }else if(method.getName().equals("setHotOrNotRating"))
        {
            return method.invoke(person,args);
            
        }else if(method.getName().startsWith("set"))
        {
            return new IllegalAccessException();
        }
        
        return null;
    }

}

package com.java.mmzs.agentmode.dyn;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class OwnerInvocationHandler implements InvocationHandler{
    PersonBean person;
    public OwnerInvocationHandler(PersonBean person)
    {
        this.person=person;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        // TODO Auto-generated method stub

        if(method.getName().startsWith("get"))
        {
            return method.invoke(person,args);
        }else if(method.getName().equals("setHotOrNotRating"))
        {
            return new IllegalAccessException();
        }else if(method.getName().startsWith("set"))
        {
            return method.invoke(person,args);
        }
        
        return null;
    }

}

package com.java.mmzs.agentmode.dyn;

import java.lang.reflect.Proxy;

public class MatchService {
    public MatchService() {

        PersonBean joe = getPersonInfo("joe", "male", "running");

        PersonBean OwnerProxy = getOwnerProxy(joe);

        System.out.println("Name is " + OwnerProxy.getName());
        System.out.println("Interests is " + OwnerProxy.getInterests());

        OwnerProxy.setInterests("Bowling");
        System.out.println("Interests are " + OwnerProxy.getInterests());
        OwnerProxy.setHotOrNotRating(50);
        System.out.println("Rating is " + OwnerProxy.getHotOrNotRating());
        OwnerProxy.setHotOrNotRating(40);
        System.out.println("Rating is " + OwnerProxy.getHotOrNotRating());

        System.out.println("**************");

        PersonBean nonOwnerProxy = getNonOwnerProxy(joe);
        System.out.println("Name is " + nonOwnerProxy.getName());
        System.out.println("Interests are " + nonOwnerProxy.getInterests());
        nonOwnerProxy.setInterests("haha");
        System.out.println("Interests are " + nonOwnerProxy.getInterests());
        nonOwnerProxy.setHotOrNotRating(60);
        System.out.println("Rating is " + nonOwnerProxy.getHotOrNotRating());

    }

    PersonBean getPersonInfo(String name, String gender, String interests) {
        PersonBean person = new PersonBeanImpl();
        person.setName(name);
        person.setGender(gender);
        person.setInterests(interests);
        return person;
    }

    PersonBean getOwnerProxy(PersonBean person) {
        return (PersonBean) Proxy.newProxyInstance(person.getClass()
                .getClassLoader(), person.getClass().getInterfaces(),
                new OwnerInvocationHandler(person));
    }

    PersonBean getNonOwnerProxy(PersonBean person) {
        return (PersonBean) Proxy.newProxyInstance(person.getClass()
                .getClassLoader(), person.getClass().getInterfaces(),
                new NonOwnerInvocationHandler(person));
    }
}

package com.java.mmzs.agentmode.dyn;


public class MainTest {


    public static void main(String[] args) {
        
        MatchService mMatchService=new MatchService();
    }


}

 保护代理：

　　当我们想要隐藏某个类时，可以为其提供代理类；

　　类似房屋中介，相亲平台，代理律师；

 public interface ZiRanRen {
     void Quanli();
 }

 public class Consigner implements ZiRanRen {
     public void eat() {
         System.out.println("吃饭");
     }
     public void drink() {
         System.out.println("喝水");
     }
     @Override
     public void Quanli() {
         System.out.println("我赋予我的代理律师来行使这些权利,此时代理律师全权代理我处理某些事务");
     }
 }

 public class Lawyer implements ZiRanRen {
     @Override
     public void Quanli() {
         new Consigner().Quanli();
     }
 }

 public class Clienter {
     public static void main(String[] args) {
         ZiRanRen lawyer = new Lawyer();
         lawyer.Quanli();
     }
 }

　　可以看出，我们想对外开放某些功能，就可以将这些功能在代理类中被引用；如此一来，屏蔽了我们不想外露的功能，只将我们想开放的功能开放出来。亦即委托类中其实是可以有很多方法的，很多功能的，我们可以酌情对外开放，代理类犹如一道大门，将委托类与外部调用者隔绝开来，只将部分功能赋予这个大门，来代替委托类行使这个功能，哪怕最终还是要牵扯到自身（因为最终还是要调用委托类的对应方法实现）。

几种变体：

　　防火墙代理

　　缓存代理

　　智能引用代理

　　同步代理

　　写入时复制代理

优点：

（1）代理类与委托类(被代理类)都实现了同一个接口，可实现灵活多变；继承式的实现方式则不够灵活；

（2）在委托类中实现功能，在代理类的方法中中引用委托类的同名方法；

（3）外部类调用委托类某个方法时，直接以接口指向代理类的实例，这正是代理的意义所在：屏蔽。

缺点：

 代理模式虽然实现了调用者与委托类之间的强耦合，但是却增加了代理类与委托类之间的强耦合（在代理类中显式调用委托类的方法），而且增加代理类之后明显会增加处理时间，拖慢处理时间。

欢迎加群一起交流：603654340

应用场景：

（1）当我们想要隐藏某个类时，可以为其提供代理类；

（2）当一个类需要对不同的调用者提供不同的调用权限时，可以使用代理类来实现（代理类不一定只有一个，我们可以建立多个代理类来实现，也可以在一个代理类中金进行权限判断来进行不同权限的功能调用）；

（3）当我们要扩展某个类的某个功能时，可以使用代理模式，在代理类中进行简单扩展（只针对简单扩展，可在引用委托类的语句之前与之后进行）；

代理模式关键点------代理模式和装饰者模式差异：（体现在方法的实现中）

装饰者模式，装饰以后会添加新功能；

代理模式目的是对目标对象访问的控制和管理；

什么情况下用代理模式什么情况下用装饰模式呢?

那就得看情况了，如果是为了给对象增加功能，那就用装饰模式。比如一个Car类它的speed()方法中行驶速度是300m/s，那能不能实现500m/s的汽车对象呢？有装饰模式就可以实现。700m/s的呢？装饰两次就行了。不是定义两个装饰器类，而是定义一个装饰器能够增速200m/s，然后装饰两次。