设计模式

[RWebRTC]

创建型模式

简单工厂模式

客户端不关心对象创建，传入有限参数就可以创建某些对象，在不更新客户端代码情况下调整对象的创建策略。但是如果工厂出错，所有客户端都受影响。

public abstract class Child {

    abstract void say();

}

public class Child1 extends Child {

    private final String name;

    Child1(String name) {
        this.name = name;
    }

    @Override
    void say() {
        System.out.println("Child1: name is " + name);
    }
}

public class Child2 extends Child {

    private final int age;

    Child2(int age) {
        this.age = age;
    }

    @Override
    void say() {
        System.out.println("Child2: age is " + age);
    }
}

public class Factory {

    public static Child getChild(@NotNull String type) {
        switch (type) {
            case "child1": {
                return new Child1("child1");
            }
            case "child2": {
                return new Child2(18);
            }
        }
        return null;
    }

}

public class ClassMain {

    public static void main(String[] args) {
        Child child1 = Factory.getChild("child1");
        Child child2 = Factory.getChild("child2");

        child1.say();
        child2.say();
    }

}

单例模式

单例模式提供唯一对象访问，但是没有抽象层，职责过重，单一对象被销毁后，状态丢失。

public class SingleClass {

    private static SingleClass single;

    private SingleClass() {
    }

    public static SingleClass getInstance() {
        if (single == null) {
            synchronized (SingleClass.class) {
                if (single == null) {
                    single = new SingleClass();
                }
                return single;
            }
        }
        return single;
    }

}

行为型模式

策略模式

管理算法族，替换继承，但是客户端需要清楚的了解其内部实现原理。

public abstract class BaseClass {
    abstract void sayILoveYou();
}

public class ChildClassA extends BaseClass {
    @Override
    void sayILoveYou() {
        System.out.println("I love you, Java!");
    }
}

public class ChildClassB extends BaseClass {
    @Override
    void sayILoveYou() {
        System.out.println("I love you, YY!");
    }
}

public class ClassMain {

    private BaseClass baseClass;

    private void setBaseClass(BaseClass baseClass) {
        this.baseClass = baseClass;
    }

    public static void main(String[] args) {
        ClassMain classMain = new ClassMain();

        classMain.setBaseClass(new ChildClassA());
        classMain.baseClass.sayILoveYou();

        classMain.setBaseClass(new ChildClassB());
        classMain.baseClass.sayILoveYou();
    }

}

观察者模式

表示层和数据层之间进行了分离，可以使用广播进行通信，在对象和观察者之间建立一定抽象耦合关系。但是许多观察者观察一个对象，对象变化时，通知所有观察者需要一定时间，观察者也只是知道对象变化了，不一定知道对象如何变化，如果对象和观察者之间循环引用，会引起 Crash。

public abstract class Subject {

    protected String state;

    public String getState(){
        return state;
    }

    private ArrayList<Observer> observers = new ArrayList<>();

    public void attach(Observer observer) {
        observers.add(observer);
    }

    public void detach(Observer observer) {
        if (observers.contains(observer)) {
            observers.remove(observer);
        }
    }

    public void notifyObserver() {
        for (Observer o : observers) {
            o.update(this);
        }
    }

}

public abstract class Observer {

    public abstract void update(Subject subject);

}

public class ConcreteSubject extends Subject {

    public void change(String state){
        this.state = state;
        notifyObserver();
    }

}

public class ConcreteObserver extends Observer {

    private final String myName;

    ConcreteObserver(String myName) {
        this.myName = myName;
    }

    @Override
    public void update(Subject subject) {
        System.out.println(myName + ": " + subject.getState());
    }
}

public class Main {
    public static void main(String[] args) {
        ConcreteSubject subject = new ConcreteSubject();
        ConcreteObserver observer1 = new ConcreteObserver("observer1");
        ConcreteObserver observer2 = new ConcreteObserver("observer2");
        subject.attach(observer1);
        subject.attach(observer2);
        subject.change("change in main");
    }
}