设计模式-java实现 简单易理解Demo[待续]

观察者模式

---

类图：

• Subject被观察的目标

• Observer 观察者

  当Subject(Subject的子类)对象的发生改变的时候，通知所有的观察者，观察者做出响应。

代码（此处使用JAVA提供的Observable类/Observer接口）：

被观察者

public class Account extends Observable {

    private float mMoney = 0.0f;

    public void add(float money ){
        mMoney += money;
        this.setChanged();
        this.notifyObservers(mMoney);
    }
}

观察者

public class User implements Observer {

    @Override
    public void update(Observable o, Object arg) {
        System.out.println("存款变了，通知User,存款为"+arg);
    }
}

Main

public class Main {
    public static void main(String[] args) {
        Observer user = new User();
        Observer user2 = new User2();
        Account account = new Account();

        account.addObserver(user);
        account.addObserver(user2);

        account.add(99.f);
    }
}

在此处贴上Observable的setChanged()和notifyObservers()方法

    protected synchronized void setChanged() {
        changed = true;
    }

    public void notifyObservers(Object arg) {

        Object[] arrLocal;

        synchronized (this) {

            if (!changed)
                return;
            arrLocal = obs.toArray();
            clearChanged();
        }

        for (int i = arrLocal.length-1; i>=0; i--)
            ((Observer)arrLocal[i]).update(this, arg);
    }

代码很清晰了，在notifyObservers()方法中，对所有注册的观察者进行通知更新。

代理模式

---

类图：

• Subject 共用接口，其中为被代理的方法。
• RealSubject 被代理对象

• Proxy代理对象

  代理即通过另一个类完成一个类改完成的方法，并在其基础上可以对其作出改变。在上图中，是通过聚合的方式。通过聚合或继承的方法实现代理，有兴趣可以看看java的代理实现，主要有两个类，Proxy、InvocationHandler。

代码(此处采用的实现方式是JDK代理)

接口

public interface Movable {
    void move();
}

被代理类

public class Car implements Movable {

    @Override
    public void move() {
        System.out.println("汽车运行中");
    }
}

代理类

public class TimeProxy implements InvocationHandler {

    private Movable movable;

    public TimeProxy(Movable mov){
        movable = mov;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("汽车开始运行");
        long start = System.currentTimeMillis();
        Object obj = method.invoke(movable, args);
        long end = System.currentTimeMillis();
        System.out.println("骑车结束运行，运行时间为："+(end-start)+"毫秒");
        return obj;
    }
}

Main

public class Main {
    public static void main(String[] args) {
        Car car = new Car();
        TimeProxy timeProxy = new TimeProxy(car);

        Movable movable = (Movable) Proxy.newProxyInstance(Car.class.getClassLoader(), Car.class.getInterfaces(), timeProxy);
        movable.move();
    }
}

单例模式

---

单例模式，即在程序运行期间，单例类最多只可以有一个实例存在。单例模式的实现方法很多，各有优缺点，在此采用枚举实现单例（Effective Java Edition 2 第二章/第三条）。

单例类

public enum  BoyFriend  {
    INSTANCE;

    public void whatsName() {
        System.out.println("code:" + this.hashCode());
    }

}

Main

public class Main {
    public static void main(String[] args) {
        BoyFriend boyFriend = BoyFriend.INSTANCE;
        boyFriend.whatsName();
        boyFriend.whatsName();
    }
}

实现非常简单，但是优点众多：线程安全、无法反射攻击、自动提供序列化支持等。。

责任链模式

---

• Handler接口，规定传递请求的方法。
• ConcreteHandleA 实现类，请求的具体执行者。

• Client客户端，发出请求

  责任链模式，即通过一个链式的结构去处理请求，在每个节点，可以选择是通过还不是通过，通过即前往下一个节点，不通过，即退出责任链。

  下面模拟一个场景，女孩发出约会，看男孩有没有钱、房、车，有的话，继续看，没有就byebye，看代码。

Boy

public class Boy {
    private boolean hasMoney;
    private boolean hasCar;
    private boolean hasHouse;

    private Boy(){}

    public Boy(boolean hasMoney, boolean hasCar, boolean hasHouse) {
        this.hasMoney = hasMoney;
        this.hasCar = hasCar;
        this.hasHouse = hasHouse;
    }

    public boolean isHasMoney() {
        return hasMoney;
    }

    public void setHasMoney(boolean hasMoney) {
        this.hasMoney = hasMoney;
    }

    public boolean isHasCar() {
        return hasCar;
    }

    public void setHasCar(boolean hasCar) {
        this.hasCar = hasCar;
    }

    public boolean isHasHouse() {
        return hasHouse;
    }

    public void setHasHouse(boolean hasHouse) {
        this.hasHouse = hasHouse;
    }
}

接口

public interface Response {
    void deliverResponse(Boy boy);
}

实现类-得有车

public class CarResponse implements Response{

    private Response next;

    public CarResponse(Response res){
        next = res;
    }

    @Override
    public void deliverResponse(Boy boy) {
        if(boy.isHasCar()){
            System.out.println("有车呀，么么哒");
            if(next != null){
                next.deliverResponse(boy);
            }
        }else{
            System.out.println("没车你说个jb");
        }
    }
}

实现类-得有房

public class HouseResponse implements Response{

    private Response next;

    public HouseResponse(Response res){
        next = res;
    }

    @Override
    public void deliverResponse(Boy boy) {
        if(boy`这里写代码片`.isHasHouse()){
            System.out.println("有房呀，么么哒");
            if(next != null){
                next.deliverResponse(boy);
            }
        }else{
            System.out.println("没房你说个jb.");
        }
    }
}

实现类-得有钱

public class MoneyResponse implements Response{

    private Response next;

    public MoneyResponse(Response res){
        next = res;
    }

    @Override
    public void deliverResponse(Boy boy) {
        if(boy.isHasMoney()){
            System.out.println("有钱呀，么么哒");
            if(next != null){
                next.deliverResponse(boy);
            }
        }else{
            System.out.println("没钱你说个jb");
        }
    }
}

请求发出者 - Girl

public class Gril {

    public void date(Boy boy){
        Response r = new CarResponse(new HouseResponse(new MoneyResponse(null)));
        r.deliverResponse(boy);
    }
}

Main

public class Main {
    public static void main(String[] args) {
        Gril gril = new Gril();
        Boy boy = new Boy(false,true,false);
        gril.date(boy);
    }
}

很清晰了，date()方法相当于发出一个请求，在各个Response中进行传递。

享元模式（附带工厂模式、单例模式）

---

享元模式，即通过建立一个缓存机制，将对象进行重用，而不需要每次调用进行重新创建，在本例中，使用HashTable实现对象缓存。

本例中，创建了两个实现Util接口的实现类，通过单例的UtilBox工厂获取Util的实现类，并在其中实现享元。

Util接口

public interface Util {
    void use();

    void putoff();
}

实现类-钳子

public class Forceps implements Util {

    public Forceps(){
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void use() {
        System.out.println("用了个钳子");
    }

    @Override
    public void putoff() {
        System.out.println("放下了钳子");
    }
}

实现类 - 扳手

public class Wrench implements Util {

    public Wrench(){
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    @Override
    public void use() {
        System.out.println("用了个扳手");
    }

    @Override
    public void putoff() {
        System.out.println("放下了扳手");
    }
}

工厂类

public enum UtilBox {

    INSTANCE;

    UtilBox() {
        utilBoxTable =  new Hashtable<>();
    }
    private Hashtable utilBoxTable;

    public Util getUtil(String utilName){
        Util util = utilBoxTable.get(utilName);
        if(util != null){
            return util;
        }
        if("wrench".equals(utilName)){
            util = new Wrench();
            utilBoxTable.put("wrench",util);
        }else if("forceps".equals(utilName)){
            util = new Forceps();
            utilBoxTable.put("forceps",util);
        }else{
            throw new IllegalArgumentException("utilName is not exists");
        }
        return util;
    }
}

Main

public class Main {
    public static void main(String[] args) {
        //通过观察，发现加载时间明显改变了
        UtilBox.INSTANCE.getUtil("wrench").use();
        UtilBox.INSTANCE.getUtil("wrench").use();

        UtilBox.INSTANCE.getUtil("forceps").use();
        UtilBox.INSTANCE.getUtil("forceps").use();

    }
}

代码没有什么难度，明白其中的意思即可。

备忘录模式

---

• Originator 需要保存状态的类
• Memento 状态记录类

• Caretaker 记录状态的容器

  备忘录模式，即在不破坏原类封装的条件下，加入存储类和操作类记录原有类的状态变化。

原有类

public class Account {
    private float money;

    public float getMoney() {
        return money;
    }

    public void setMoney(float money) {
        this.money = money;
    }

    public Record save(){
        return new Record(money);
    }

    public void restore(Record record){
        money = record.money;
    }

    @Override
    public String toString() {
        return "账户余额为:"+money;
    }
}

备忘类

public class Record  {
    float money;

    public Record(float money) {
        this.money = money;
    }
}

纪录类(本处采用Stack实现)

public class Memory {
    private Stack memo;

    public Memory(){
        memo = new Stack<>();
    }

    public Record get(){
        return memo.pop();
    }

    public void push(Record r){
        memo.push(r);
    }
}

Main

public class Main {
    public static void main(String[] args) {
        Memory memory = new Memory();
        Account a = new Account();

        a.setMoney(12.0f);
        memory.push(a.save());
        System.out.println(a.toString());

        a.setMoney(25.0f);
        memory.push(a.save());
        System.out.println(a.toString());

        memory.get();
        a.restore(memory.get());
        System.out.println(a.toString());
    }
}

代码依然没难度，看明白就好。

策略模式

图片有点看不清楚，意思就是，通过聚合的方式，向原有类中添加功能。

鸭子 - 抽象类

public abstract class Duck {

    public void swim(){
        System.out.println(this.getClass().getSimpleName()+"游啊游");
    }

    public abstract void display();
}

飞行的策略

public interface FlyStratagy {
    void fly();
}

飞行的策略实现

public interface FlyStratagy {
    void fly();
}

鸭子的实现 - 包含了飞行策略

public class WildDuck extends Duck {

    private FlyStratagy fly;

    public WildDuck(){
        fly = new FlyWithWin();
    }

    @Override
    public void display() {
        System.out.println("灰色的鸭子");
    }

    public void fly(){
        fly.fly();
    }
}

Main

public class Main  {
    public static void main(String[] args) {
        WildDuck duck = new WildDuck();
        duck.fly();
        duck.swim();
        duck.display();
    }
}

策略模式的好处就是，将功能的添加采用聚合的模式，那么不会像接口那样，需要强制性的实现，并且策略可复用，在其他需要这个策略的地方，直接引入即可。
策略模式的详细说明可以参考《Effective Java edition 2》第四章第十八条：接口优于抽象类。

状态模式

状态模式，即通过状态，决定当前的行为，在发生了一定行为之后，进入下一个状态。

主体 - 灯

public class Light {
    private LightState lightState;

    public Light(){
        lightState = new OffState();
    }
    public void setLightState(LightState ls){
        lightState = ls;
    }

    public void switcher(){
        lightState.handleState(this);
    }
}

状态接口

public interface LightState {
    void handleState(Light light);
}

状态实现 - 开灯状态

public class OnState implements LightState {
    @Override
    public void handleState(Light light) {
        System.out.println("灯开着了");
        light.setLightState(new OffState());
    }
}

状态实现 - 关灯状态

public class OffState implements LightState {
    @Override
    public void handleState(Light light) {
        System.out.println("灯关了");
        light.setLightState(new OnState());
    }
}

Main

public class Main {
    public static void main(String[] args) {
        Light light = new Light();
        light.switcher();
        light.switcher();
        light.switcher();
        light.switcher();
    }
}

通过light的switcher()方法，改变了状态，触发状态改变，改变了light的行为，一直循环。

2015年6月16日 更新至此.
ps:以上图片均来自百度，侵删。
ps2:水平有限，如有不足，请指出。
ps3:代码可以在：简单设计模式Java实现 - github找到