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

一、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和从网上查找到的学习资料，装载请注明出处。