Receiver.java
package org.commandpackage;

public abstract class Receiver {
	//抽象接收者，定义每个接收者必须完成的业务
	public abstract void doSomething();
}


ConcreteReceiver1.java
package org.commandpackage;

public class ConcreteReceiver1 extends Receiver {
//	具体接收者必须实现的业务逻辑
	@Override
	public void doSomething() {
		// TODO Auto-generated method stub
		System.out.println("业务逻辑1");
	}

}


ConcreteReceiver2.java
package org.commandpackage;

public class ConcreteReceiver2 extends Receiver {
//	具体接收者必须实现的业务逻辑
	@Override
	public void doSomething() {
		// TODO Auto-generated method stub
		System.out.println("业务逻辑2");
	}

}


Command.java
package org.commandpackage;

public abstract class Command {
//	封装执行者，创建一个全局的封装者
	protected final Receiver receiver;
	
	public Command(Receiver receiver) {
		this.receiver = receiver;
	}

	//	每个命令必须有一个执行的方法
	public abstract void execute();
}


ConcreteCommand1.java
package org.commandpackage;

public class ConcreteCommand1 extends Command {
//	创建默认接收者
	public ConcreteCommand1() {
		// TODO Auto-generated constructor stub
		super(new ConcreteReceiver1());
	}

//	设置新的接收者
	public ConcreteCommand1(Receiver receiver) {
		// TODO Auto-generated constructor stub
		super(receiver);
	}
	
	@Override
	public void execute() {
		// TODO Auto-generated method stub
		super.receiver.doSomething();
	}

}

ConcreteCommand2.java
package org.commandpackage;

public class ConcreteCommand2 extends Command {
//	创建默认接收者
	public ConcreteCommand2() {
		// TODO Auto-generated constructor stub
		super(new ConcreteReceiver2());
	}

//	设置新的接收者
	public ConcreteCommand2(Receiver receiver) {
		// TODO Auto-generated constructor stub
		super(receiver);
	}
	
	@Override
	public void execute() {
		// TODO Auto-generated method stub
		super.receiver.doSomething();
	}

}


Invoker.java
package org.commandpackage;

public class Invoker {

	private Command command;
//	接受一个命令
	public void setCommand(Command command) {
		this.command = command;
	}
//	执行命令
	public void action(){
		this.command.execute();
	}
}

Client.java
package org.commandpackage;

import org.commandpackage.Command;
import org.commandpackage.ConcreteCommand1;
import org.commandpackage.Invoker;

public class Client {

	/**
	 * @param args 整个流程，给具体的命令指定一个默认的执行者，将执行者进行封装，故接收者，只需要知道执行什么命令，而不需要知道执行者是谁
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
//		创建一个接收者,执行什么命令，执行
		Invoker invoker = new Invoker();
		Command command = new ConcreteCommand1();
		invoker.setCommand(command);
		invoker.action();
	}

}

Receiver.java 命令的执行者
package org.command;

public abstract class Receiver {
	//抽象接收者，定义每个接收者必须完成的业务
	public abstract void doSomething();
}


ConcreteReceiver1.java 命令执行者的具体业务逻辑1
package org.command;

public class extends Receiver {
//	具体接收者必须实现的业务逻辑
	@Override
	public void doSomething() {
		// TODO Auto-generated method stub
		System.out.println("业务逻辑1");
	}
}

ConcreteReceiver2.java 命令执行者的具体业务逻辑2
package org.command;

public class ConcreteReceiver2 extends Receiver {
//	具体接收者必须实现的业务逻辑
	@Override
	public void doSomething() {
		// TODO Auto-generated method stub
		System.out.println("业务逻辑2");
	}
}

Command.java 命令的接口
package org.command;

public abstract class Command {
//	每个命令必须有一个执行的方法
	public abstract void execute();
}


ConcreteCommand1.java 具体的命令1
package org.command;

public class ConcreteCommand1 extends Command {
//	定义一个接收者
	private Receiver receiver;
	
	public ConcreteCommand1(Receiver _receiver) {
		// TODO Auto-generated constructor stub
		this.receiver = _receiver;
	}

	@Override
	public void execute() {
		// TODO Auto-generated method stub
		this.receiver.doSomething();
	}

}


ConcreteCommand1.java 具体的命令2
package org.command;

public class ConcreteCommand2 extends Command {
	private Receiver receiver;
	
	public ConcreteCommand2(Receiver _receiver) {
		// TODO Auto-generated constructor stub
		this.receiver = _receiver;
	}

	@Override
	public void execute() {
		// TODO Auto-generated method stub
		this.receiver.doSomething();
	}

}


Invoker.java命令的接收者
package org.command;

public class Invoker {

	private Command command;
//	接受一个命令
	public void setCommand(Command command) {
		this.command = command;
	}
//	执行命令
	public void action(){
		this.command.execute();
	}
}

Client.java调试
package org.command;

public class Client {

	/**
	 * @param args 整个流程，1需要创建命令的接收者Invoker；2需要知道执行者是Receiver;3创建命令Command，同时指派执行者Receiver；4接收者Invoker发布命令，同时执行
	 * 执行的过程是透明的，但需要知道接收者,执行者，及命令
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
//		创建一个接收者
		Invoker invoker = new Invoker();
		Receiver receiver;
		Command command;
		
		System.out.println("------------执行命令1-----------------");
//		创建一个命令的执行者
		receiver = new ConcreteReceiver1();
//		给执行者指派一个命令
		command = new ConcreteCommand1(receiver);
//		接收者发布命令
		invoker.setCommand(command);
//		执行命令
		invoker.action();
		
		System.out.println("------------执行命令2-----------------");
//		创建一个命令的执行者
		receiver = new ConcreteReceiver2();
//		给执行者指派一个命令
		command = new ConcreteCommand1(receiver);
//		接收者发布命令
		invoker.setCommand(command);
//		执行命令
		invoker.action();
	}

}

被装饰者 Component.java
public abstract class Component {
//	创建被装饰类
//	抽象的方法
	public abstract void operate();
}

具体实现者(核心实现功能)ConcreteComponent.java
public class ConcreteComponent extends Component {
//	具体实现
	@Override
	public void operate() {
		System.out.println("do Something");
	}
}

装饰类Decorator.java
public class Decorator extends Component {
	private Component component = null;
//	通过构造参数传递被装饰者
	public Decorator(Component _component) {
		// TODO Auto-generated constructor stub
		this.component = _component;
	}
//	委托被装饰者执行行
	@Override
	public void operate() {
		// TODO Auto-generated method stub
		this.component.operate();
	}
}

功能扩展一:ConcreteDecorator1.java
public class ConcreteDecorator1 extends Decorator {
//	定义被装饰者
	public ConcreteDecorator1(Component _component) {
		super(_component);
	}
//	定义自己的修饰方法
	public void method1(){
		System.out.println("method1 修饰");
	}
//	重写父类的operate方法
	@Override
	public void operate() {
		// TODO Auto-generated method stub
		this.method1();
		super.operate();
	}
	
}

功能扩展二:ConcreteDecorator2.java
public class ConcreteDecorator2 extends Decorator{
//	定义被装饰者
	public ConcreteDecorator2(Component _component) {
		super(_component);
	}
//	定义自己的修饰方法
	public void method2() {
		System.out.println("method2 修饰");
	}
//	重写父类的operate方法
	@Override
	public void operate() {
		// TODO Auto-generated method stub
		this.method2();
		super.operate();
	}

}

main方法以:Client.java
public class Client {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Component component = new ConcreteComponent();
		
		component = new ConcreteDecorator1(component);
		
		component = new ConcreteDecorator2(component);
		
		component.operate();
	}

}

运行结果:
method2 修饰
method1 修饰
do Something


描述:继承是静态扩展,而装饰模式是动态扩展,降低父子类的耦合,便于功能扩展,便于维护.
注意:避免多层装饰.