回顾：面向对象设计模式01.单例模式&工厂模式

目录

抽象工厂模式

责任链模式

观察者模式

---

抽象工厂模式

用于生成指定产品族，一个产品族中包括多种产品。例如：
我们都比较熟悉的电脑制造相关行业，有HP，罗技，联想，戴尔，近几年华为，小米也进来了，每个生产商生产的电脑又包括鼠标，键盘，屏幕等等配件。此时我们需要使用工厂模式来进行管理不同的产品族，这时使用简单工厂（也有叫作工厂方法的）已经无法满足要求，此时可以使用抽象工厂。

抽象类 PcFactory 

public abstract class PcFactory {
 
    //制作方法
    public abstract Mouse makeMouse();
    public abstract Keyboard makeKeyboard();
 
    //为得到具体的工厂的方法服务
    private static HpFactory hpFactory = new HpFactory();
    private static LogicFactory logicFactory = new LogicFactory();
    //为得到具体的工厂的方法服务
    public final static int PC_TYPE_HP = 1;
    public final static int PC_TYPE_LG = 2;
 
    /**
     * 得到具体的工厂的方法
     * @param pcType传入表示电脑类型的常数
     * @return 返回PcFactory抽象类：面向抽象编程代替面向具体编程
     */
    public static PcFactory getPcFactory(int pcType) {
        switch (pcType){
            case 1:
                return hpFactory;
            case 2 :
                return logicFactory;
            default:
                return null;
        }
    }
}

惠普工厂 HpFactory

public class HpFactory extends PcFactory {
 
    //返回抽象类：面向抽象编程代替面向具体编程
 
    @Override
    public Mouse makeMouse() {
        return new HpMouse();
    }
 
    @Override
    public Keyboard makeKeyboard() {
        return new HpKeyboard();
    }
 
}

罗技工厂 LogicFactory

public class LogicFactory extends PcFactory {
 
    @Override
    public Mouse makeMouse() {
        return new LogicMouse();
    }
 
    @Override
    public Keyboard makeKeyboard() {
        return new LogicKeyboard();
    }
}

键盘抽象类 Keyboard

public abstract class Keyboard {
    abstract String getInfo();
}

惠普键盘类 HpKeyboard

public class HpKeyboard extends Keyboard {
    @Override
    String getInfo() {
        return "HP keyboard";
    }
}

罗技键盘类 LogicKeyboard 

public class LogicKeyboard extends Keyboard {
    @Override
    String getInfo() {
        return "logic keyboard";
    }
}

鼠标抽象类 Mouse

public abstract class Mouse {
    abstract String getInfo();
}

惠普鼠标类 HpMouse 

public class HpMouse extends Mouse {
    @Override
    String getInfo() {
        return "HP mouse";
    }
}

罗技鼠标类 LogicMouse

public class LogicMouse extends Mouse {
    @Override
    String getInfo() {
        return "logic mouse";
    }
}

测试类

public class Main {
 
    public static void main(String[] args) {
        //通过抽象PcFactory父类得到HP电脑制作工厂
        PcFactory HpFactory = PcFactory.getPcFactory(PcFactory.PC_TYPE_HP);
        //得到HP制作键盘的方法
        Keyboard keyboard = HpFactory.makeKeyboard();
        //得到HP制作鼠标的方法
        Mouse mouse = HpFactory.makeMouse();
        System.out.println(keyboard.getInfo());
        System.out.println(mouse.getInfo());
    }
 
}

 

责任链模式

责任链模式是一个对象的行为模式，很多对象之间形成一条链条，处理请求在这个链条上进行传递，直到责任链的上的某个对象决定处理请求（也可扩展为几个对象处理），这个过程对于用户来说是透明的，也就是说用户并不需要知道是责任链上的哪个对象处理的请求，对请求是否处理由链条上的对象自己决定。

可以想象一下击鼓传花的游戏。

责任链模式也可以说是行为模式(而抽象工厂叫做建造模式)：拥有相同行为的类共同实现一个接口

类图 

Filter 接口

/**
 * Filter接口，实际上是对变化的抽象
 * 这种方式会逐个的运行Filter，但不能
 * 指定是否需要继续执行后面的Filter。
 * 比如：当发现违法了特殊符号的Filter时
 * 其后的过滤链没有必要执行
 */
public interface Filter {
 
    void doFilter(Message message);
 
}

ChackSyntaxFilter类

public class ChackSyntaxFilter implements Filter {
 
    @Override
    public void doFilter(Message message) {
        String content = message.getContent();
        content = content.replace("<", "#");
        content = content.replace(">", "#");
        message.setContent(content);
    }
 
}

WordFilter类

public class WordFilter implements Filter {
 
    @Override
    public void doFilter(Message message) {
        String content = message.getContent();
        content = content.replace("牛", "***");
        content = content.replace("马", "*****");
        message.setContent(content);
    }
 
}

 FilterChain过滤器链

/**
 * 将Filter组织成一个链条
 */
public class FilterChain {
 
    private FilterChain(){}
    
    private static List<Filter> filters = new ArrayList<>();
 
    private static FilterChain instance = new FilterChain();
 
    public static FilterChain getInstance(){
        return instance;
    }
 
    public FilterChain add(Filter filter) {
        filters.add(filter);
        return this;
    }
 
    public Message dofilters(final Message message) {
        for (Filter f : filters) {
            f.doFilter(message);
        }
        return message;
    }
 
}

测试 

public class Main {
 
    public static void main(String[] args) {
        Message msg = new Message();
        msg.setContent("hello, <abc>, 牛xx马， 哈哈哈");
 
        FilterChain fc = FilterChain.getInstance();
        fc.add(new ChackSyntaxFilter())
                .add(new WordFilter())
                .dofilters(msg);
 
        System.out.println(msg.getContent());
    }
 
}

观察者模式

观察者模式是对象的行为模式，有时也称为“发布/订阅模式”或者“监听器模式”。

观察者模式定义了被观察者和观察者之间的一对多的关系，让多个观察者对象可以响应一个被观察者对象。

类图

 从上图可以看到：Nurse类、Wife类、Docter类都共同实现Observer接口，BellEvent按铃类继承Event事件抽象类，Patient是病人实体类

Observer接口

public interface Observer {
    void bell(BellEvent event);
}

Nurse类

public class Nurse implements Observer {
    @Override
    public void bell(BellEvent event) {
        System.out.println("I am nurse, Can I help you?");
    }
}

Wife类

public class Wife implements Observer {
    @Override
    public void bell(BellEvent event) {
        System.out.println("baby, I am here, Don't worry !");
    }
}

Doctor类

public class Docter implements Observer {
    @Override
    public void bell(BellEvent event) {
        System.out.println("I am docter, Can I help you?");
    }
}

Event抽象类 

public abstract class Event {
 
    protected Object source;
 
    public Object getSource() {
        return this.source;
    }
 
}

BellEvent类

public class BellEvent extends Event {
 
    long timestamp;
 
    public BellEvent(Object source) {
        this.timestamp = System.currentTimeMillis();
        this.source = source;
    }
 
}

病人实体类

public class Patient {
 
    private List<Observer> observers = new ArrayList<>();
 
    public void addObserver(Observer observer) {
        observers.add(observer);
    }
 
    public void ringBell() {
        BellEvent event = new BellEvent(this);
        for (Observer observer: observers) {
            observer.bell(event);
        }
    }
 
}

测试

public class Main {
 
    public static void main(String[] args) {
 
        Patient patient = new Patient();
 
        patient.addObserver(new Docter());
        patient.addObserver(new Nurse());
        patient.addObserver(new Wife());
 
        patient.ringBell();
 
    }
}