状态模式

Ericson原创

2015/11/08 设计模式 java 设计模式

状态模式，当一个对象的内在状态改变时允许改变其行为，这个对象看起来像是改变了其类。状态模式主要解决的是当控制一个对象状态转换的条件表达式过于复杂时的情况。把状态的判断逻辑转移到表示不同状态的一系列类当中，可以把复杂的判断逻辑简化。状态模式结构图如下： state 状态模式的好处是将与特定状态相关的行为局部化，并且将不同状态的行为分割开来。状态模式通过把各种状态转移逻辑分布到State的子类之间，来减少相互间的依赖。当一个对象的行为取决于它的状态，并且它必须在运行时刻根据状态改变它的行为时，就可以考虑使用状态模式。

状态模式优点：

状态模式将与特定状态相关的行为局部化，并且将不同状态的行为分割开来
所有状态相关的代码都存在于某个ConcreteState中，所以通过定义新的子类很容易地增加新的状态和转换
状态模式通过把各种状态转移逻辑分不到State的子类之间，来减少相互间的依赖

缺点：

导致较多的ConcreteState子类

适用场景：

当一个对象的行为取决于它的状态，并且它必须在运行时刻根据状态改变它的行为时，就可以考虑使用状态模式
一个操作中含有庞大的分支结构，并且这些分支决定于对象的状态

应用举例：电灯有两个状态，开（亮）与关（不亮），下面用状态模式实现对电灯的控制。 statesample

阅读全文

抽象工厂模式

Ericson原创

2015/11/08 设计模式 java 设计模式

工厂方法模式是定义一个用于创建对象的接口，让子类决定实例化哪一个类。抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。 AbstractFactory IFactory是一个抽象工厂接口，它里面应该包含所有的产品创建的抽象方法。抽象工厂模式的优点：易于交换产品系列，由于具体工厂类，在一个应用中只需要在初始化的时候出现一次，这就使得改变一个应用的具体工厂变得非常容易，它只需要改变具体工厂即可使用不同的产品配置；它让具体的创建实例过程与客户端分离，客户端是通过它们的抽象接口操纵实例，产品的具体类名也被具体工厂的实现分离，不会出现在客户代码中。

阅读全文

观察者模式

Ericson原创

2015/11/08 设计模式 java 设计模式

观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。观察者模式结构图如下所示： observer 主要代码如下所示：

public abstract class Observer {
    public abstract void Update();
}
abstract class Subject {
    private List<Observer> observers = new ArrayList<Observer>();
    public void Attach(Observer observer) {
        observers.add(observer);
    }
    public void Detach(Observer observer) {
        observers.remove(observer);
    }
    public void Notify() {
        for (Observer o : observers) {
            o.Update();
        }
    }
}
class ConcreteSubject extends Subject {
    private String subjectState;
    public String getSubjectState() {
        return subjectState;
    }
    public void setSubjectState(String subjectState) {
        this.subjectState = subjectState;
    }
}
class ConcreteObserver extends Observer {
    private String name;
    private String observerState;
    private ConcreteSubject subject;
    public ConcreteObserver(ConcreteSubject subject, String name) {
        this.subject = subject;
        this.name = name;
    }
    public void Update() {
        observerState = subject.getSubjectState();
    }
    public ConcreteSubject getSubject() {
        return subject;
    }
    public void setSubject(ConcreteSubject subject1) {
        this.subject = subject1;
    }
}

观察者模式将一个系统分割成一系列相互协作类有一个很不好的副作用，那就是需要维护相关对象间的一致性。我们不希望为了维持一致性而使各类紧密耦合，这样会给维护、扩展和重用都带来不便。观察者模式所做的工作其实就是在解除耦合，让耦合的双方都依赖于抽象，而不是依赖于具体，从而使得各自的变化都不会影响另一边的变化。

代理模式优点：

代理模式能够协调调用者和被调用者，在一定程序上降低了系统的耦合度
代理对象可以在客户端和目标对象之间起到中介的作用，这样起到了保护目标对象的作用

缺点是：

由于在客户端和真实主题之间增加了代理对象，因此有些类型的代理模式可能会造成请求的处理速度变慢
实现代理模式需要额外的工作，有些代理模式的实现非常复杂

阅读全文

建造者模式

Ericson原创

2015/11/06 设计模式 java 设计模式

建造者模式，将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。建造者模式结构图如下所示： builder 建造者模式基本代码：

public class Product {
    List<String> parts = new ArrayList<String>();
    public void Add(String part) {
        parts.add(part);
    }
    public void Show() {
        System.out.println("\n产品");
        for (String part : parts) {
            System.out.println(part);
        }
    }
}
abstract class Builder {
    public abstract void buildPartA();
    public abstract void buildPartB();
    public abstract Product getResult();
}
class ConcreteBuilder extends Builder {
    private Product product = new Product();
    public void buildPartA() {
        product.Add("部件A");
    }
    public void buildPartB() {
        product.Add("部件B");
    }
    public Product getResult() {
        return product;
    }
}
class ConcreteBuilder2 extends Builder {
    private Product product = new Product();
    public void buildPartA() {
        product.Add("部件X");
    }
    public void buildPartB() {
        product.Add("部件Y");
    }
    public Product getResult() {
        return product;
    }
}
class Director{
    public void Construct(Builder builder){
        builder.buildPartA();
        builder.buildPartB();
    }
}

建造者就是封装了建造的过程，保证建造的完整性，把建造过程和表示分离开。建造者模式是在当创建算法对象的算法应该独立于该对象的组成部分以及它们的装配方式时适用的模式。
案例是：比如游戏中建造人，人的建造不能缺胳膊少腿，建造出来可能分为胖子和瘦子。

阅读全文

外观模式

Ericson原创

2015/11/05 设计模式 java 设计模式

外观模式，为子系统中的一组接口提供一个一致的界面，此模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。外观模式的结构图如下所示： Facade 外观模式的代码如下所示：

class SubSystemOne {
    public void methodOne() {
        System.out.println("method one");
    }
}
class SubSystemTwo {
    public void methodTwo() {
        System.out.println("method two");
    }
}
class SubSystemThree {
    public void methodThree() {
        System.out.println("method three");
    }
}
class SubSystemFour {
    public void methodFor() {
        System.out.println("method four");
    }
}
public class Facade {
    SubSystemOne one;
    SubSystemTwo two;
    SubSystemThree three;
    SubSystemFour four;
    public Facade() {
        one = new SubSystemOne();
        two = new SubSystemTwo();
        three = new SubSystemThree();
        four = new SubSystemFour();
    }
    public void MethodA() {
        System.out.println("method a");
        one.methodOne();
        two.methodTwo();
        four.methodFor();
    }
    public void MethodB() {
        two.methodTwo();
        three.methodThree();
    }
}

外观模式定义了一个高层接口，在高层接口中封装底层接口的内容，客户端可以直接调用高层接口来使用底层接口。

阅读全文