设计模式分类

    设计模式可分为三大类，共23种经典模式：

1. 创建型模式

1.1 单例模式（Singleton）

核心思想

    确保一个类仅有一个实例，并提供全局访问点。

实现方式

    双重检查锁定（DCL）：

public class Singleton {
    private static volatile Singleton instance;
    private Singleton() {}
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

    静态内部类（推荐，线程安全且延迟加载）：

public class Singleton {
    private Singleton() {}
    private static class Holder {
        static final Singleton INSTANCE = new Singleton();
    }
    public static Singleton getInstance() {
        return Holder.INSTANCE;
    }
}

Android应用

    LayoutInflater：通过Context.getSystemService()获取单例。

    注意事项：避免内存泄漏（如单例持有Activity引用）。

1.2 工厂模式（Factory）

核心思想

    将对象创建逻辑封装到工厂类中，客户端无需关心具体实现。

实现方式

    简单工厂：

public class BitmapFactory {
    public static Bitmap createBitmap(String type) {
        if ("file".equals(type)) {
            return new FileBitmap();
        } else if ("network".equals(type)) {
            return new NetworkBitmap();
        }
        return null;
    }
}

    抽象工厂（定义产品族）：

public interface ThemeFactory {
    Button createButton();
    TextView createTextView();
}
public class MaterialThemeFactory implements ThemeFactory {
    @Override public Button createButton() { return new MaterialButton(); }
    @Override public TextView createTextView() { return new MaterialTextView(); }
}

Android应用

    BitmapFactory.decodeResource()：根据资源类型创建Bitmap。

    NotificationCompat.Builder：构建不同样式的通知。

1.3 建造者模式（Builder）

核心思想

    分离复杂对象的构建与表示，支持逐步构建和配置。

实现方式

public class AlertDialogBuilder {
    private String title;
    private String message;
    public AlertDialogBuilder setTitle(String title) {
        this.title = title;
        return this;
    }
    public AlertDialogBuilder setMessage(String message) {
        this.message = message;
        return this;
    }
    public AlertDialog build() {
        return new AlertDialog(title, message);
    }
}
// 使用
AlertDialog dialog = new AlertDialogBuilder()
    .setTitle("提示")
    .setMessage("确认删除？")
    .build();

Android应用

    AlertDialog.Builder、Retrofit.Builder：通过链式调用配置参数。

    Glide.with(context).load(url).into(imageView)：Glide的API设计也隐含建造者模式思想。

2. 结构型模式

2.1 适配器模式（Adapter）

核心思想

    将不兼容的接口转换为客户端期望的接口。

实现方式

    类适配器（继承方式）：

public class LegacyAdapter extends LegacyLibrary implements NewInterface {
    @Override public void newMethod() {
        oldMethod(); // 调用父类方法
    }
}

对象适配器（组合方式，更灵活）：

public class Adapter implements Target {
    private Adaptee adaptee;
    public Adapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }
    @Override public void request() {
        adaptee.specificRequest();
    }
}

Android应用

    RecyclerView.Adapter：将数据集适配为View展示。

    ArrayAdapter：将数组或List数据适配到ListView。

2.2 代理模式（Proxy）

核心思想

    为其他对象提供一种代理以控制对这个对象的访问。

实现方式

    静态代理：

public interface ImageLoader {
    void loadImage(String url);
}
public class RealImageLoader implements ImageLoader {
    @Override public void loadImage(String url) { /* 实际加载逻辑 */ }
}
public class ProxyImageLoader implements ImageLoader {
    private RealImageLoader realLoader;
    @Override public void loadImage(String url) {
        if (realLoader == null) realLoader = new RealImageLoader();
        realLoader.loadImage(url); // 代理实际对象
    }
}

    动态代理（基于接口，运行时生成代理类）：

public static Object createProxy(Object target) {
    return Proxy.newProxyInstance(
        target.getClass().getClassLoader(),
        target.getClass().getInterfaces(),
        (proxy, method, args) -> {
            // 前置逻辑（如权限校验）
            Object result = method.invoke(target, args);
            // 后置逻辑（如缓存结果）
            return result;
        });
}

Android应用

    Binder机制：客户端通过Proxy对象跨进程调用服务端方法。

    Glide的RequestManagerRetriever：代理管理图片请求生命周期。

3. 行为型模式

3.1 观察者模式（Observer）

核心思想

    定义对象间的一对多依赖关系，当一个对象状态改变时，自动通知依赖它的对象。

实现方式

public interface Observer {
    void update(String message);
}
public class ConcreteObserver implements Observer {
    @Override public void update(String message) {
        System.out.println("收到消息：" + message);
    }
}
public class Subject {
    private List<Observer> observers = new ArrayList<>();
    public void addObserver(Observer observer) {
        observers.add(observer);
    }
    public void notifyObservers(String message) {
        for (Observer observer : observers) {
            observer.update(message);
        }
    }
}

Android应用

    LiveData：数据变化时通知UI组件更新。

    RxJava的Observable：通过订阅机制实现观察者模式。

    BroadcastReceiver：监听系统广播事件。

3.2 策略模式（Strategy）

核心思想

    定义一系列算法，将每个算法封装起来，并使它们可以互相替换。

实现方式

public interface SortingStrategy {
    void sort(int[] data);
}
public class QuickSort implements SortingStrategy {
    @Override public void sort(int[] data) { /* 快速排序实现 */ }
}
public class MergeSort implements SortingStrategy {
    @Override public void sort(int[] data) { /* 归并排序实现 */ }
}
public class Sorter {
    private SortingStrategy strategy;
    public void setStrategy(SortingStrategy strategy) {
        this.strategy = strategy;
    }
    public void executeSort(int[] data) {
        strategy.sort(data);
    }
}

Android应用

    动画插值器（Interpolator）：如LinearInterpolator、AccelerateDecelerateInterpolator。

    图片加载策略：Glide根据网络状态选择加载原图或缩略图。

4. Android源码中的设计模式

4.1 责任链模式（View事件分发）

实现逻辑：

public boolean dispatchTouchEvent(MotionEvent ev) {
    if (onInterceptTouchEvent(ev)) { // ViewGroup决定是否拦截
        return onTouchEvent(ev);      // 自身处理
    } else {
        return child.dispatchTouchEvent(ev); // 传递给子View
    }
}

应用场景：

    事件从Activity → ViewGroup → View逐层传递。

4.2 装饰者模式（ContextWrapper）

类结构：

    ContextWrapper（装饰者）包装ContextImpl（被装饰者），通过attachBaseContext()注入具体实现。

应用场景：

    Activity和Service通过继承ContextThemeWrapper扩展功能。

4.3 模板方法模式（AsyncTask）

核心方法：

protected abstract Result doInBackground(Params... params); // 子类实现
protected void onPreExecute() {}    // 模板方法
protected void onPostExecute(Result result) {} // 模板方法

流程固定：

    onPreExecute() → doInBackground() → onPostExecute()。

5. 设计模式实践建议

    避免过度设计：优先用简单代码解决问题，模式引入需评估必要性。

    结合语言特性：Kotlin的object关键字可简化单例实现。

    模式混合使用：如RecyclerView = 适配器 + 观察者 + 组合模式。

    关注Android Jetpack：如ViewModel（状态管理）、WorkManager（任务调度）隐含模式思想。