看完《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");
    }
}

结果：

转载于:https://www.cnblogs.com/Alruddy/p/8194728.html