一、创建型模式

1.1 单例模式

单例模式就是用于在全局维护仅有该类的一个对象的实例。

1.1.1 饿汉式单例模式

/**
 * 饿汉式的单例模式：因为怕自己挨饿，所以要提前准备好；
 * 是线程安全的，不是 Lazy Loading 的
*/
class HungryModeSingleInstance {
    static HungryModeSingleInstance mInstance = new HungryModeSingleInstance();
    
    private HungryModeSingleInstance() {}
    
    public static getInstance() {
        return mInstance;
    }
}

1.1.2 懒汉式单例模式

/**
 * 懒汉式的单例模式：Lazy Loading, 需要的时候才去加载
 * 不是线程安全的
*/
class LazyModeSingleInstance {
    private static LazyModeSingleInstance mInstance;
    
    private LazyModeSingleInstance() { }
    
    public static LazyModeSingleInstance getInstance() {
        if (mInstance == null) {
            mInstance = new LazyModeSingleInstance();
        }
        return mInstance;
    }
}

1.1.3 线程安全的懒汉式单例模式

/**
 * 线程安全的懒汉式单例模式：Lazy Loading，而且线程安全
*/
class SingleInstance {
    private static volatile SingleInstance mInstance;
    
    private SingleInstance() { }
    
    public static SingleInstance getInstance() {
        if (mInstance == null) {
            synchronized(this) {
                if (mInstance == null) {
                    mInstance = new SingleInstance();
                }
            }
        }
        return mInstance;
    }
}

1.2 工厂模式

interface ICar {
    void run();
}

class Benz implements ICar {
    @Override
    public void run() {
        System.out.println("Benz is running!");
    }
}

class Audi implements ICar {
    @Override
    public void run() {
        System.out.println("Audi is running!");
    }
}

建造者模式

原型模式

二、结构型模式

三、行为型模式

3.1 策略模式

策略模式的应用场景，就是针对不同的业务逻辑，使用不同的策略，比如 Java 线程池 ThreadPoolExecutor 中对于来不及处理命令的 DiscardPolicy，就是典型的策略模式。

优点：符合开闭原则（对扩展开放，对修改封闭），代码可读性强

缺点：复杂业务场景可能导致策略类太多

// 策略接口
Interface RejectExcutionHandler {
    public void rejectExecution(Runnable var1, ThreadPoolExecutor var2);
}

// 具体的策略类实现
static class DiscardPolicy implements RejectExcutionHandler {
    public DiscardPolicy() { }
    
    @Override
    public void rejectExecution(Runnable r, ThreadPoolExecutor e) {
        // do nothing
    }
}


static class AbortPolicy implements RejectExcutionHandler {
    public AbortPolicy() { }

    @Override
    public void rejectExecution(Runnable r, ThreadPoolExecutor e) {
        throw new RejectedExecutionException("Task " + r.toString() + 
            " rejected from " + e.toString());
    }
}

public static class DiscardOldestPolicy implements RejectedExecutionHandler {
    public DiscardOldestPolicy() {
    }

    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        if (!e.isShutdown()) {
            e.getQueue().poll();
            e.execute(r);
        }

    }
}

public static class CallerRunsPolicy implements RejectedExecutionHandler {
    public CallerRunsPolicy() {
    }

    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        if (!e.isShutdown()) {
            r.run();
        }

    }
}

3.2 观察者模式

观察者模式，用于在被观察对象变化时候，通知观察的对象，Android Jetpack 中的 Lifecycle 就使用了观察者模式。

Jetpack 的 Lifecycle 中，Activity 是 LifecycleOwner, ReportFragment 是被观察者。在 ReportFragment 生命周期变化时，会通过 diapatchEvent 发送对应的 Event，这个 Event 最终会被 Actiivty 的 mLifecycleRegistry 处理，并回调到我们调用的 getLifecycle.addOberver 中具体添加的 Observer 的处理逻辑中去。

interface Observer {
    void update();
}

// 被观察者
public class Subject {
    List<Observer> observers = new ArrayList<>();
    
    pulbic void addObserver(Observer observer) {
        observers.add(observer);
    }
    
    // 通知观察者
    private void notifyAll() {
        for (Observer observer : observers) {
            observer.update();
        }
    }
}

// 观察者
public class MyObserver implements Observer {
    private Subject subject;
    public MyObserver(Subject subject) {
        this.subject = subject;
        subject.addObserver(this);
    }
    
    @Override
    public void update() {
        System.out.println("observed state changed!");
    }
}

Java 设计模式