Android开发中经典设计模式

在 Android 开发中，设计模式是帮助开发人员解决常见问题、提高代码可维护性、可扩展性和可重用性的重要工具。以下是一些在 Android 开发中常用的经典设计模式：

1. 单例模式（Singleton Pattern）

单例模式确保一个类只有一个实例，并提供一个全局的访问点。在 Android 开发中，单例模式常常用于管理共享资源，如数据库连接、网络请求等。

使用场景：

共享资源管理，例如网络请求、数据库操作。
在应用生命周期内只需要一个实例的对象，如应用级别的配置管理。

示例：

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

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

2. 观察者模式（Observer Pattern）

观察者模式定义了一种一对多的依赖关系，当一个对象的状态发生改变时，它的所有依赖者都会收到通知并自动更新。Android 中的 LiveData、BroadcastReceiver 和 EventBus 等都实现了观察者模式。

使用场景：

在多个组件之间传递事件或状态更新。
动态通知UI更新，比如数据变化时更新UI。

示例：

public class MyObserver implements Observer {
    @Override
    public void update(Observable o, Object arg) {
        // 处理通知
    }
}

Observable observable = new Observable();
MyObserver observer = new MyObserver();
observable.addObserver(observer);
observable.notifyObservers();

3. 工厂模式（Factory Pattern）

工厂模式通过定义一个创建对象的接口，让子类决定实例化哪一个类。它将对象的创建和使用分离，提高了系统的灵活性和扩展性。

使用场景：

创建不同类型的对象时。
需要根据参数决定实例化不同类的场景。

示例：

public interface Button {
    void render();
}

public class WindowsButton implements Button {
    @Override
    public void render() {
        System.out.println("Rendering Windows button");
    }
}

public class MacButton implements Button {
    @Override
    public void render() {
        System.out.println("Rendering Mac button");
    }
}

public abstract class Dialog {
    public abstract Button createButton();
}

public class WindowsDialog extends Dialog {
    @Override
    public Button createButton() {
        return new WindowsButton();
    }
}

public class MacDialog extends Dialog {
    @Override
    public Button createButton() {
        return new MacButton();
    }
}

4. 适配器模式（Adapter Pattern）

适配器模式通过一个适配器类将不兼容的接口转换成可兼容的接口，使得原本不兼容的类可以一起工作。在 Android 开发中，Adapter 是一个非常常见的模式，尤其是在 ListView 或 RecyclerView 中。

使用场景：

需要将不兼容的接口或类适配成符合要求的接口时。
连接旧代码与新代码，或是处理不同类型的数据格式时。

示例：

public class MediaAdapter implements MediaPlayer {
    private AdvancedMediaPlayer advancedMusicPlayer;

    public MediaAdapter(AdvancedMediaPlayer advancedMusicPlayer) {
        this.advancedMusicPlayer = advancedMusicPlayer;
    }

    @Override
    public void play(String audioType, String fileName) {
        if (audioType.equalsIgnoreCase("mp4")) {
            advancedMusicPlayer.playMP4(fileName);
        } else if (audioType.equalsIgnoreCase("vlc")) {
            advancedMusicPlayer.playVLC(fileName);
        }
    }
}

5. 代理模式（Proxy Pattern）

代理模式为其他对象提供一种代理以控制对这个对象的访问。在 Android 中，代理模式常常用于实现权限控制、延迟加载等功能。

使用场景：

控制对某个对象的访问。
延迟加载，或在不直接访问目标对象时进行控制。

示例：

public interface Image {
    void display();
}

public class RealImage implements Image {
    private String fileName;

    public RealImage(String fileName) {
        this.fileName = fileName;
    }

    @Override
    public void display() {
        System.out.println("Displaying image: " + fileName);
    }
}

public class ProxyImage implements Image {
    private RealImage realImage;
    private String fileName;

    public ProxyImage(String fileName) {
        this.fileName = fileName;
    }

    @Override
    public void display() {
        if (realImage == null) {
            realImage = new RealImage(fileName);
        }
        realImage.display();
    }
}

6. 命令模式（Command Pattern）

命令模式将请求封装成对象，从而让用户通过不同的请求将调用者和执行者解耦。在 Android 中，命令模式常见于按钮点击事件、菜单选择等。

使用场景：

需要将请求调用者与执行者解耦时。
动作或请求的组合执行，例如多个操作的撤销和重做。

示例：

public interface Command {
    void execute();
}

public class LightOnCommand implements Command {
    private Light light;

    public LightOnCommand(Light light) {
        this.light = light;
    }

    @Override
    public void execute() {
        light.turnOn();
    }
}

public class Light {
    public void turnOn() {
        System.out.println("Light is ON");
    }

    public void turnOff() {
        System.out.println("Light is OFF");
    }
}

7. 建造者模式（Builder Pattern）

建造者模式通过提供一个分步构建的接口，构建复杂的对象。Android 中的 AlertDialog 和 Notification 等对象常用建造者模式来进行构建。

使用场景：

对象的创建过程非常复杂或具有多种配置选项时。
需要在不同环境中以不同方式创建对象时。

示例：

public class User {
    private String name;
    private String address;
    private int age;

    private User(UserBuilder builder) {
        this.name = builder.name;
        this.address = builder.address;
        this.age = builder.age;
    }

    public static class UserBuilder {
        private String name;
        private String address;
        private int age;

        public UserBuilder setName(String name) {
            this.name = name;
            return this;
        }

        public UserBuilder setAddress(String address) {
            this.address = address;
            return this;
        }

        public UserBuilder setAge(int age) {
            this.age = age;
            return this;
        }

        public User build() {
            return new User(this);
        }
    }
}

8. 状态模式（State Pattern）

状态模式允许一个对象在其内部状态改变时改变其行为。它让对象在状态发生变化时，能够表现出不同的行为。在 Android 开发中，状态模式常用于处理 UI 组件的不同状态。

使用场景：

对象的行为随着其状态的变化而变化时。
在多个状态之间转换，并在每个状态下做不同的处理时。

示例：

public interface State {
    void doAction(Context context);
}

public class StartState implements State {
    @Override
    public void doAction(Context context) {
        System.out.println("Player is in start state");
        context.setState(this);
    }
}

public class StopState implements State {
    @Override
    public void doAction(Context context) {
        System.out.println("Player is in stop state");
        context.setState(this);
    }
}

public class Context {
    private State state;

    public void setState(State state) {
        this.state = state;
    }

    public State getState() {
        return state;
    }
}

这些设计模式在 Android 开发中起到了非常重要的作用，帮助开发人员提高了代码的可维护性、可扩展性和可重用性。理解并合理运用这些设计模式能使代码结构更加清晰，并提升开发效率。

去1:1私密咨询