看完《HeadFirst设计模式》的一点想法(一)

两个星期刷完这本设计模式的入门书,感触良多,不得不感叹模式的力量以及先人的智慧,本学期选修的Android课程中许多不明白的东西就渐渐地明白了。
做点笔记,也算对于自己所学东西地一点总结。

策咯模式

特点:

  • 定义算法族,并进行封装,使其可以互相替换
  • 多用组合,少用继承
  • 针对接口编程,不针对实现编程

参照书上的例子:


// 封装行为的接口
public interface FlyBehavior{
    void fly();
}

class FlyWithWings implements FlyBehavior{
    @Override
    public void fly() {
        System.out.println("I'm flying with wings.");
    }
}

class FlyNoWay implements FlyBehavior{
    @Override
    public void fly() {
        System.out.println("I can't fly.");
    }
}
// 在具体类中使用组合来实现
public abstract class Duck {
    protected FlyBehavior flyBehavior;

    public Duck(){
    }

    public void setFlyBehavior(FlyBehavior flyBehavior){
        this.flyBehavior = flyBehavior;
    }

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

class NormalDuck extends Duck{
    public NormalDuck(FlyBehavior flyBehavior){
        this.flyBehavior = flyBehavior;
    }
}
// 测试
public class Main {

    public static void main(String[] args) {
        Duck normalDuck = new NormalDuck(new FlyWithWings());
        normalDuck.performFly();
        normalDuck.setFlyBehavior(new FlyNoWay());
        normalDuck.performFly();
    }
}

结果:

类图

类似地,还可以动态添加很多行为。

观察者模式

这可以说是我见到地第一个设计模式了,让我明白了Java事件监听器(*Listener)的实现方式。

特点:

  • 定义了对象之间的一对多依赖(主题对观察者的一对多)
  • 主题内容一旦发生改变,立马通知观察者

类图:

参照书上的例子:

// 观察者
public interface Observer {
    void update(String message);
}

class ConcreteObserver implements Observer{
    Subject subject;
    String message;
    public ConcreteObserver(Subject subject){
        this.subject = subject;
        subject.registerObserver(this);
    }
    public void cancelSub(){
        subject.removeObserver(this);
    }

    @Override
    public void update(String message) {
        this.message = message;
        display();
    }

    public void display(){
        System.out.println(toString() + " update message : " + message);
    }
}

// 主题
public interface Subject {
    void registerObserver(Observer ob);
    void removeObserver(Observer ob);
    void notifyObservers();
}

class ConcreteSubject implements Subject{
    List<Observer> observers = new ArrayList<>();
    String message;

    public void setMessage(String msg){
        message = msg;
        notifyObservers();
    }

    public String getMessage(){
        return message;
    }

    @Override
    public void registerObserver(Observer ob) {
        observers.add(ob);
    }

    @Override
    public void removeObserver(Observer ob) {
        observers.remove(ob);
    }

    @Override
    public void notifyObservers() {
        for (Observer ob : observers){
            ob.update(message);
        }
    }
}
// 测试
import java.util.ArrayList;

public class Main {

    public static void main(String[] args) {
        ArrayList<Observer> concreteObservers = new ArrayList<>();
        ConcreteSubject subject = new ConcreteSubject();
        for (int i = 0; i < 5; i++){
            ConcreteObserver observer = new ConcreteObserver(subject);
            concreteObservers.add(observer);
        }
        subject.setMessage("123");
        System.out.println("------------");
        ConcreteObserver observer1 = (ConcreteObserver) concreteObservers.get(1);
        observer1.cancelSub();
        subject.setMessage("456");
    }
}

结果:

posted @ 2018-01-04 18:03  可达龙  阅读(373)  评论(0编辑  收藏