Android 设计模式

1. MVC（Model-View-Controller）模式：MVC 模式将应用程序分为三个部分：Model、View 和 Controller。Model 负责数据的管理和处理，View 负责用户界面的展示，Controller 负责处理用户的输入和调用 Model 和 View 的方法。MVC 模式的优点是简单易懂，缺点是 Controller 可能会变得过于复杂。

   // Model
   public class User {
       private String name;
       private int age;
       // getters and setters
   }
   
   // View
   public class MainActivity extends AppCompatActivity {
       private TextView nameTextView;
       private TextView ageTextView;
   
       @Override
       protected void onCreate(Bundle savedInstanceState) {
           super.onCreate(savedInstanceState);
           setContentView(R.layout.activity_main);
           nameTextView = findViewById(R.id.nameTextView);
           ageTextView = findViewById(R.id.ageTextView);
       }
   
       public void displayUser(User user) {
           nameTextView.setText(user.getName());
           ageTextView.setText(String.valueOf(user.getAge()));
       }
   }
   
   // Controller
   public class UserController {
       private User user;
       private MainActivity view;
   
       public UserController(User user, MainActivity view) {
           this.user = user;
           this.view = view;
       }
   
       public void updateUser(String name, int age) {
           user.setName(name);
           user.setAge(age);
           view.displayUser(user);
       }
   }
   

2. MVP（Model-View-Presenter）模式：MVP 模式将应用程序分为三个部分：Model、View 和 Presenter。Model 和 View 的交互通过 Presenter 进行，Presenter 负责处理用户的输入和调用 Model 和 View 的方法。MVP 模式的优点是解耦合度高，缺点是 Presenter 可能会变得过于复杂。

   // Model
   public class User {
       private String name;
       private int age;
       // getters and setters
   }
   
   // View
   public interface UserView {
       void displayUser(User user);
   }
   
   public class MainActivity extends AppCompatActivity implements UserView {
       private TextView nameTextView;
       private TextView ageTextView;
       private UserPresenter presenter;
   
       @Override
       protected void onCreate(Bundle savedInstanceState) {
           super.onCreate(savedInstanceState);
           setContentView(R.layout.activity_main);
           nameTextView = findViewById(R.id.nameTextView);
           ageTextView = findViewById(R.id.ageTextView);
           presenter = new UserPresenter(this);
       }
   
       public void updateUser(View view) {
           String name = nameEditText.getText().toString();
           int age = Integer.parseInt(ageEditText.getText().toString());
           presenter.updateUser(name, age);
       }
   
       @Override
       public void displayUser(User user) {
           nameTextView.setText(user.getName());
           ageTextView.setText(String.valueOf(user.getAge()));
       }
   }
   
   // Presenter
   public class UserPresenter {
       private User user;
       private UserView view;
   
       public UserPresenter(UserView view) {
           this.view = view;
           user = new User();
       }
   
       public void updateUser(String name, int age) {
           user.setName(name);
           user.setAge(age);
           view.displayUser(user);
       }
   }
   

3. MVVM（Model-View-ViewModel）模式：MVVM 模式将应用程序分为三个部分：Model、View 和 ViewModel。ViewModel 负责将 Model 中的数据转化为 View 可以使用的格式，并将用户的输入转化为 Model 可以使用的格式。View 和 ViewModel 通过数据绑定进行交互。MVVM 模式的优点是解耦合度高，缺点是需要使用数据绑定库。

   // Model
   public class User {
       private String name;
       private int age;
       // getters and setters
   }
   
   // View
   public class MainActivity extends AppCompatActivity {
       private TextView nameTextView;
       private TextView ageTextView;
       private UserViewModel viewModel;
   
       @Override
       protected void onCreate(Bundle savedInstanceState) {
           super.onCreate(savedInstanceState);
           setContentView(R.layout.activity_main);
           nameTextView = findViewById(R.id.nameTextView);
           ageTextView = findViewById(R.id.ageTextView);
           viewModel = new ViewModelProvider(this).get(UserViewModel.class);
           viewModel.getUser().observe(this, new Observer<User>() {
               @Override
               public void onChanged(User user) {
                   nameTextView.setText(user.getName());
                   ageTextView.setText(String.valueOf(user.getAge()));
               }
           });
       }
   
       public void updateUser(View view) {
           String name = nameEditText.getText().toString();
           int age = Integer.parseInt(ageEditText.getText().toString());
           viewModel.updateUser(name, age);
       }
   }
   
   // ViewModel
   public class UserViewModel extends ViewModel {
       private MutableLiveData<User> user;
   
       public UserViewModel() {
           user = new MutableLiveData<>();
           user.setValue(new User());
       }
   
       public LiveData<User> getUser() {
           return user;
       }
   
       public void updateUser(String name, int age) {
           User newUser = new User();
           newUser.setName(name);
           newUser.setAge(age);
           user.setValue(newUser);
       }
   }
   

4. 工厂模式（Factory Pattern）：定义一个用于创建对象的接口，让子类决定实例化哪个类。工厂方法使一个类的实例化延迟到其子类。

5. 单例模式（Singleton Pattern）：确保一个类只有一个实例，并提供全局访问点。

6. 适配器模式（Adapter Pattern）：将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

7. 观察者模式（Observer Pattern）：定义了一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并自动更新。

8. 策略模式（Strategy Pattern）：定义一系列算法，将每个算法封装起来并使它们可以相互替换。策略模式使得算法可以独立于使用它的客户端而变化。

9. 建造者模式（Builder Pattern）：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

10. 装饰器模式（Decorator Pattern）：动态地给一个对象添加一些额外的职责。就扩展功能而言，装饰器模式比生成子类方式更为灵活。

11. 外观模式（Facade Pattern）：为子系统中的一组接口提供一个一致的界面，此模式定义了一个高层接口，使得这一子系统更加容易使用。

12. 迭代器模式（Iterator Pattern）：提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露该对象的内部表示。

13. 组合模式（Composite Pattern）：将对象组合成树形结构以表示“部分-整体”的层次结构，使得用户对单个对象和组合对象的使用具有一致性