常用的设计模式：单例模式，工厂模式，观察者模式，代理模式,其他的我使用不多。
单例模式最常见也最简单
分为几种实现：
懒汉式：

public class Single {
    private static Single single;

    public synchronized static Single getInstance() {
        if (single == null) {
            single = new Single();
            return single;
        } else {
            return single;
        }
    }
}

双重锁 double check

public class Single {
    // 防止指令重排序 一般创建对象
   // 1.给 instance 分配内存
    // 2.调用 Singleton 的构造函数来初始化成员变量
     // 3.将instance对象指向分配的内存空间（执行完这步 instance 就为非 null 了）
   // 虚拟机会优化 有时候执行顺序 会是 132
    private volatile static Single single;

    public  static Single getInstance() {
        if (single == null) {
            synchronized (Single.class) {
                if (single == null) {
                    // 保证不会多次生成对象
                    single = new Single();
                    return single;
                }
            }
        }
        return single;
    }
}

饿汉式

public class Single{
    // 类加载时就初始化 不会有线程安全问题
    private static final Single instance = new Single();

    public static Single getInstance(){
        return instance;
    }
}

工厂模式 在Android中很多地方用到
举个简单的工厂模式例子，其他的说法都是基础的变种：

public class MobileFactory {

    public static Moblie createMobile(String type) {
        if (type.equals("xiaomi")) {
            return new XiaomiMoblie();
        } else {
            return new OtherMoblie();
        }
    }
}

interface Moblie {

}

class XiaomiMoblie implements Moblie {

}

class OtherMoblie implements Moblie {

}

MobileFactory.createMobile("xiaomi");

观察者模式
角色 ：观察者 被观察者
简单实现一下观察者模式,核心：被观察者发生变化，通知观察者

/**
 * 观察者
 */
class Obsever {
    
    public Obsever(Observale o){
        o.addObsever(this);
    }
    
    public void update() {
        System.out.println("被通知更新");
    }
}

/**
 * 被观察者
 */
class Observale {
    // 实现一对多 一个被观察者对应多个观察者
    private List<Obsever> list = new ArrayList<>();

    public void addObsever(Obsever obsever) {
        list.add(obsever);
    }
    
    // Observale 变化可以通过这个通知观察者
    public void notifyObsevers() {
        for (int i = 0; i < list.size(); i++) {
            list.get(i).update();
        }
    }
}

Java 已经提供了快速创建观察者的方法
提供了一个Observable类以及一个Observer接口

setChanged();
notifyObservers();
通知观察者更新

代理模式

interfece Print{
public void print();
}
// 真实类
class RealObject implements Print{
public void print() {
System.out.print("realObject");
   }
}
// 代理类
class Proxy  implements Print{
      private Print print;
      public Proxy(Print print){
        this.print = print;
     }
      public void print() {
        print.print();
       }
}