java设计模式（一）——适配器、桥接、建造者、职责链、命令

本文链接：https://blog.csdn.net/huangzebiao007/article/details/12876693

一、Adapter适配器设计模式

当我们要组合两个不相干的类时，第一种解决方案是修改各自类的接口。但是如果没有源码，或者不愿意为了一个应用而修改各自的接口，则需要使用Adapter适配器，在两种接口之间创建一个混合接口。
适配器设计模式中有3个重要角色：被适配者Adaptee，适配器Adapter和目标对象Target。
其中两个现存的想要组合到一起的类分别是被适配者Adaptee和目标对象Target角色，我们需要创建一个适配器Adapter将其组合在一起。
常用有两种方法：组合适配器模式，继承适配器模式
1、组合适配器模式：假设要画图形，有圆形和方形两个类，现在需要一个既可以画圆形又可以画方形的类。

//适配器
class Adapter extends Circle{
    private Square square;  
    public Adapter(Square square){  
    	this.square = square;  
    }  
    public void drawSquare(){  
    	square.drawSquare();  
    }  
}

// 圆形，目标对象
class Circle {
	public void drawCircle() {
		System.out.println("Draw circle");
	}
}

// 方形，被适配对象
class Square {
	public void drawSquare() {
		System.out.println("Draw square");
	}
}

//既可以画圆形，又可以画方形，适配器  
public class AdapterCombination{
    public static void main(String[] args) {
        Adapter adapter = new Adapter(new Square());
        adapter.drawCircle();
        adapter.drawSquare();
    }
}

输出结果：

Draw circle
Draw square

2、继承适配器模式

class Adapter2 implements ICircle, ISquare {
	private ISquare square;
	private ICircle circle;

	public Adapter2(Square2 square) {
		this.square = square;
	}

	public Adapter2(Circle2 circle) {
		this.circle = circle;
	}
	
	public Adapter2(Square2 square,Circle2 circle){
		this.square = square;
		this.circle = circle;
	}

	public void drawSquare() {
		square.drawSquare();
	}

	public void drawCircle() {
		circle.drawCircle();
	}
}

interface ICircle {
	public void drawCircle();
}

interface ISquare {
	public void drawSquare();
}

// 圆形
class Circle2 implements ICircle {
	public void drawCircle() {
		System.out.println("Draw circle");
	}
}

// 方形
class Square2 implements ISquare {
	public void drawSquare() {
		System.out.println("Draw square");
	}
}

public class AdapterExtend {
    public static void main(String[] args) {
        Adapter2 adapter2 = new Adapter2(new Square2(),new Circle2());
        adapter2.drawCircle();
        adapter2.drawSquare();
    }
}

输出结果：

Draw circle
Draw square

二、Bridge桥接设计模式

桥接设计模式是将一组功能(实现)与另一组使用该功能的其他对象(行为)分离开来,以便达到单一因素变化，然后使用对象调用的方式将这两组关联系起来，将问题的行为和实现分离开来实现，通过用聚合代替继承来解决子类爆炸性增长的问题。假设我们现在有两个图形，有两种画法，实现如下：

public class BridgePattern {
    public static void main(String[] args) {
        //画一个实线的圆
        Drawing draw1 = new SolidDrawing();
        Shape shape1 = new Circle(draw1);
        shape1.doDraw();
        //画一个虚线的圆
        Drawing draw2 = new DashDrawing();
        Shape shape2 = new Circle(draw2);
        shape2.doDraw();
        //画一个实线的矩形
        Drawing draw3 = new SolidDrawing();
        Shape shape3 = new Rectangle(draw3);
        shape3.doDraw();
        //画一个虚线的矩形
        Drawing draw4 = new DashDrawing();
        Shape shape4 = new Rectangle(draw4);
        shape4.doDraw();    
    }
}

// 行为，使用功能的类
interface Shape {
    public void doDraw();
}

class Circle implements Shape {
    private Drawing draw;

    public Circle(Drawing draw) {
        this.draw = draw;
    }

    public void doDraw() {
        System.out.println("I am Circle.");
        draw.draw();
    }
}

class Rectangle implements Shape {
    private Drawing draw;

    public Rectangle(Drawing draw) {
        this.draw = draw;
    }

    public void doDraw() {
        System.out.println("I am Rectangle.");
        draw.draw();
    }
}

// 实现，提供功能的类
interface Drawing {
    public void draw();
}

class SolidDrawing implements Drawing {
    public void draw() {
        System.out.println("Drawing solide line…");
    }
}

class DashDrawing implements Drawing {
    public void draw() {
        System.out.println("Drawing dash line…");
    }
}

输出结果：

I am Circle.
Drawing solide line…
I am Circle.
Drawing dash line…
I am Rectangle.
Drawing solide line…
I am Rectangle.
Drawing dash line…

假设我们需要增加一个三角形，则我们主要多增加一个实现了Shape的接口就好了，如下

class Triangle implements Shape{
	private Drawing draw;
	
	public Triangle(Drawing draw){
		this.draw = draw;
	}
	public void doDraw() {
		System.out.println("I am Triangle.");
		draw.draw();
	}
}

然后我们要画一个是虚线的三角形，则这样调用

        Drawing draw5 = new DashDrawing();
        Shape shape5 = new Triangle(draw5);
        shape5.doDraw();

输出结果：

I am Triangle.
Drawing dash line…

三、Builder建造者模式

Builder建造者模式将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。Builder模式是一步一步创建一个复杂的对象，它允许用户可以只通过指定复杂对象的类型和内容就可以构建它们，用户不需要了解所构建对象的内部具体构建细节，Builder建造设计模式的目的是为了将构造复杂对象的过程和它的部件解耦。

Builder建造者设计模式中有两个重要角色：Director指导者和Builder建造者。Director指导者相当于设计师或架构师，拥有整个产品各个部件之间关系的构建蓝图。Builder建造者是部件的具体创建者，Builder建造者根据Director指导者的指示创建产品的各个部件，最终由Director构建出完整产品。要向builder要Product而不是向知道建造过程的Director要。

举例说明，就好象我要一座房子住，可是我不知道怎么盖（简单的砌墙，层次较低），也不知道怎么样设计（建几个房间，几个门好看，层次较高），于是我需要找一帮民工，他们会砌墙，还得找个设计师，他知道怎么设计，我还要确保民工听设计师的领导，而设计师本身也不干活，光是下命令，这里砌一堵墙，这里砌一扇门，这样民工开始建设，最后，我可以向民工要房子了。在这个过程中，设计师是什么也没有，除了他在脑子里的设计和命令，所以要房子也是跟民工要！

//建造者：
interface Builder {  
	  public void makeWindow();  
	  
	  public void makeFloor();  
	  
	  public String submitRoom();  
}  
class Mingong implements Builder {  
	  private String window="";  
	  private String floor="";  
	    
	  public void makeWindow() {  
		  window=new String("window");  
	  }  
	  public void makeFloor(){  
		  floor=new String("floor");  
	  }  
	  // 交房子给房主  
	  public String submitRoom() {  
		    if((!window.equals(""))&&(!floor.equals(""))) {  
		    	return "房子已经建好了";  
		    } else{
		    	return null;  
		    }
	  }  
} 
//指挥者：
class Designer{  
	  // 指挥民工进行工作  
	  public void order(Builder builder) {  
		    builder.makeWindow();  
		    builder.makeFloor();  
	  }  
}

public class BuilderPattern {
    public static void main(String[] args) {
        Builder mingong = new Mingong();    
        Designer designer = new Designer();
        designer.order(mingong);
        System.out.println(mingong.submitRoom());
    }
}

输出结果：

房子已经建好了

四、ChainOfResponsibility责任链设计模式

责任链设计模式是用一系列请求处理器试图处理一个请求，这些请求处理器之间是一个松散耦合，唯一的共同点是在他们之间传递请求。例如客户端发送一个请求，请求处理器A先处理，如果A没有处理或者无法处理，就将请求传递给请求处理器B，如果B没有处理或者无法处理，就将请求传递到请求处理器C去处理，所有这些请求处理器构成一条请求处理责任链。一个处理数字，字母和特殊符号的例子：

// 抽象请求处理器
abstract class Handler {
	private Handler successor;

	public Handler() {
	}

	public Handler(Handler successor) {
		this.successor = successor;
	}

	public Handler getSuccessor() {
		return successor;
	}

	public void setSuccessor(Handler successor) {
		this.successor = successor;
	}

	public abstract void handRequest(Request request);
}

// Request请求类
class Request {
	private String type;

	public Request(String type) {
		this.type = type;
	}

	public String getType() {
		return type;
	}
}

// 数字请求处理器
class NumberHandler extends Handler {
	public NumberHandler() {
	}

	public NumberHandler(Handler successor) {
		super(successor);
	}

	public void handRequest(Request request) {
		if (request.getType().equals("Number")) {
			System.out.println("Number has been handled");
		}
		// 传递到下一个请求处理器处理
		else {
			getSuccessor().handRequest(request);
		}
	}
}

// 字母请求处理器
class CharacterHandler extends Handler {
	public CharacterHandler() {
	}

	public CharacterHandler(Handler successor) {
		super(successor);
	}

	public void handRequest(Request request) {
		if (request.getType().equals("Character")) {
			System.out.println("Character has been handled");
		}
		// 传递到下一个请求处理器处理
		else {
			getSuccessor().handRequest(request);
		}
	}
}

// 特殊符号请求处理器
class SymbolHandler extends Handler {
	public SymbolHandler() {
	}

	public SymbolHandler(Handler successor) {
		super(successor);
	}

	public void handRequest(Request request) {
		if (request.getType().equals("Symbol")) {
			System.out.println("Symbol has been handled");
		}
		// 传递到下一个请求处理器处理
		else {
			getSuccessor().handRequest(request);
		}
	}
}

public class ChainOfResponsibilityPattern {
    public static void main(String[] args) {
        Handler numberHandler = new NumberHandler();
        Handler characterHandler = new CharacterHandler();
        Handler symbolHandler = new SymbolHandler();

        numberHandler.setSuccessor(characterHandler);
        characterHandler.setSuccessor(symbolHandler);
        Request request1 = new Request("Number");
        Request request2 = new Request("Character");
        Request request3 = new Request("Symbol");

        numberHandler.handRequest(request1);
        numberHandler.handRequest(request2);
        numberHandler.handRequest(request3);
    }
}

输出结果：

Number has been handled
Character has been handled
Symbol has been handled

五、Command命令设计模式

Command命令设计模式将一个请求封装成一个对象，从而使你可用不同的请求对客户进行操作。Command命令设计模式是对命令的封装。命令模式把发出命令的责任和执行命令的责任分割开，委派给不同的对象。每一个命令都是一个操作，命令请求发出请求要求执行一个操作；命令接受方收到请求，并执行操作。命令模式允许命令请求方和命令接收方独立开来，使得命令请求方不必知道命令接收方的接口，更不必知道请求是怎么被接收，以及操作是否被执行，何时被执行，以及是怎么被执行的。

Command命令设计模式中5个角色：

(1).抽象命令角色：声明了一个给所有具体命令类的抽象接口。这是一个抽象角色，通常由一个java接口或java抽象类实现。

(2).请求者（Invoke）角色：负责调用命令对象执行请求，相关的方法叫做行动方法。

(3).接收者（Receiver）角色：负责具体实施和执行一个请求。任何一个类都可以成为接收者，实施和执行请求的方法叫做行动方法。

(4).具体命令角色：定义一个接受者和行为之间的弱耦合；实现execute方法，负责调用接收者的相应操作。execute方法通常叫做执行方法。

(5).客户角色：创建了一个具体命令对象并确定其接收者。

模拟对电视机的操作开机、关机命令

//抽象命令角色
interface Command {
	public void execute();
}

//请求者角色，遥控器
class InvokerControl {
	private Command command;
	public InvokerControl(Command command) {
		this.command = command;
	}
	public void action() {
		command.execute();
	}
}

//接收者角色，TV
class ReceiverTv{
	public void turnOn() {
		System.out.println("The televisino is on.");
	}
	public void turnOff() {
		System.out.println("The television is off.");
	}
}

//具体命令类，开电视
class TurnOnCommand implements Command {
	private ReceiverTv receiver;
	public TurnOnCommand(ReceiverTv receiver) {
		this.receiver = receiver;
	}
	public void execute() {
		receiver.turnOn();
	}
}

//具体命令类，关电视
class TurnOffCommand implements Command {
	private ReceiverTv receiver;
	public TurnOffCommand(ReceiverTv receiver) {
		this.receiver = receiver;
	}
	public void execute() {
		receiver.turnOff();
	}
}

public class CommandPattern {
    public static void main(String[] args) {
        // 客户端创建命令接受者
        ReceiverTv tv = new ReceiverTv();
        // 客户端创建具体命令，并指定命令接受者
        Command command = new TurnOnCommand(tv);
        // 客户端创建请求者，并给请求者指定具体命令
        InvokerControl invoker = new InvokerControl(command);
        // 命令请求者发出命令请求
        invoker.action();
        
        Command command2 = new TurnOffCommand(tv);
        InvokerControl invoker2 = new InvokerControl(command2);
        invoker2.action();
        
    }
}

输出结果：

The televisino is on.
The television is off.

备注：java设计模式的学习主要是参考一位牛人http://blog.csdn.net/chjttony和从网上查找到的学习资料，装载请注明出处。