目录
在Android中常用的设计模式有：单例模式，工厂模式，观察者模式等，下面根据具体案例深刻了解模式具体的表现：
1.单例模式：
单例模式存在的意义主要就是保证有且仅有一个对象，只创建一个，所有想要拿到该单例的都是同一个对象。
优点：
1).由于单例模式在内存中只有一个实例，减少了内存开销。对于那些耗内存的类，只实例化一次，大大提高性能，尤其是移动开发中。
2).单例模式可以避免对资源的多重占用，例如一个写文件时，由于只有一个实例存在内存中，避免对同一个资源文件的同时写操作。
3).单例模式可以在系统设置全局的访问点，优化和共享资源访问。
饿汉式：
public class EHanSingleton {
//在类初始化时，已经自行实例化,所以是线程安全的。
private static final EHanSingleton single =new EHanSingleton();
public static EHanSingleton getInstance(){
return single;
}
}-
优点：写法简单，线程安全。 - 缺点：没有懒加载的效果，如果没有使用过的话会造成内存浪费。
懒汉式：
public class LanHanSingleton {
private static LanHanSingleton singleton;
public static synchronized LanHanSingleton getSingleton(){
if (singleton == null){
singleton =new LanHanSingleton();
}
return singleton;
}
}- 优点：实现了懒加载的效果，线程安全。
- 缺点：使用synchronized会造成不必要的同步开销，而且大部分时候我们是用不到同步的。
双重校验锁（DCL）：
public class DoubleCheckSingleton {
private volatile static DoubleCheckSingleton singleton;
public static DoubleCheckSingleton getInstance(){
if (singleton == null){
synchronized (DoubleCheckSingleton.class){
if (singleton == null){
singleton =new DoubleCheckSingleton();
}
}
}
return singleton;
}
}- 优点：懒加载，线程安全，效率较高
- 缺点：volatile影响一点性能，高并发下有一定的缺陷，某些情况下DCL会失效，虽然概率较小
静态内部类：
public class StaticInnerSigleton {
public static StaticInnerSigleton getInstance(){
return StaticInner.single;
}
//静态内部类
private static class StaticInner{
private static final StaticInnerSigleton single =new StaticInnerSigleton();
}
}- 优点：懒加载，线程安全，推荐使用
2.工厂设计模式：
工厂模式分为工厂方法模式和抽象工厂模式。
工厂方法模式分为三种：普通工厂模式，就是建立一个工厂类，对实现了同一接
口的一些类进行实例的创建。
多个工厂方法模式，是对普通工厂方法模式的改进，在普通工厂方法模式中，如
果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工
厂方法，分别创建对象。
静态工厂方法模式，将上面的多个工厂方法模式里的方法置为静态的，不需要创
建实例，直接调用即可。
-
普通工厂模式
-
多个工厂方法模式该模式是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象。
不需要创建实例，直接调用即可。 -
静态工厂方法模式，将上面的多个工厂方法模式里的方法置为静态的，
-
抽象工厂模式 工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则，所以，从设计角度考虑，有一定的问题，如何解决？就用到抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。
3. 建造者模式(Builder模式)：
定义：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
public class UserInfo {
private String name;
private int age;
private double height;
private double weight;
private UserInfo(Builder builder) {
this.name = builder.name;
this.age = builder.age;
this.height = builder.height;
this.weight = builder.weight;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public double getHeight() {
return height;
}
public void setHeight(double height) {
this.height = height;
}
public double getWeight() {
return weight;
}
public void setWeight(double weight) {
this.weight = weight;
}
static class Builder {
private String name;
private int age;
private double height;
private double weight;
public Builder name(String name) {
this.name = name;
return this;
}
public Builder age(int age) {
this.age = age;
return this;
}
public Builder height(double height) {
this.height = height;
return this;
}
public Builder weight(double weight) {
this.weight = weight;
return this;
}
public UserInfo build() {
return new UserInfo(this);
}
}
}//创建
UserInfo.Builder builder=new UserInfo.Builder();
UserInfo person=builder
.name("张三")
.age(18)
.height(178.5)
.weight(67.4)
.build();
//获取UserInfo的属性
Log.e("userinfo","name = "+person.getName());Android中很多地方运用了Builder模式，比如常见的对话框创建/Okhttp等
AlertDialog.Builder builder=new AlertDialog.Builder(this);
AlertDialog dialog=builder.setTitle("对话框")
.setIcon(android.R.drawable.ic_dialog)
.setView(R.layout.custom_view)
.setPositiveButton(R.string.positive, new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
}
})
.setNegativeButton(R.string.negative, new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
}
})
.create();
dialog.show();
Request.Builder builder=new Request.Builder();
Request request=builder.addHeader("","")
.url("")
.post(body)
4.观察者模式：
定义：对象间一种一对多的依赖关系，使得当一个对象改变状态，则所有依赖于它的对象都会得到通知并被自动更新。
运用的场景：广播，EventBus等都是观察者模式
主要包括四个部分：
1. Subject被观察者。是一个接口或者是抽象类，定义被观察者必须实现的职责，它必须能偶动态地增加、取消观察者，管理观察者并通知观察者。
2. Observer观察者。观察者接收到消息后，即进行update更新操作，对接收到的信息进行处理。
3. ConcreteSubject具体的被观察者。定义被观察者自己的业务逻辑，同时定义对哪些事件进行通知。
4. ConcreteObserver具体观察者。每个观察者在接收到信息后处理的方式不同，各个观察者有自己的处理逻辑。
模拟场景：天气预报，每次天气更新都会向你及时发送消息，观察者们就要更新界面。写法如下：
public class Weather {
private String description;
public Weather(String description) {
this.description = description;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
@Override
public String toString() {
return "Weather{" +
"description='" + description + '\'' +
'}';
}
}
然后定义我们的被观察着，我们希望它能够通用，所以定义成泛型，内部应该暴露出register和unRegister供观察者订阅和取消订阅，至于观察者的保存，我们用ArrayList即可，另外，当主题发生变化的时候，需要通知观察者来做出响应，还需要一个notifyObservers方法，具体实现如下：
public class Observable<T> {
List<Observer<T>> mObservers = new ArrayList<Observer<T>>();
public void register(Observer<T> observer) {
if (observer == null) {
throw new NullPointerException("observer == null");
}
synchronized (this) {
if (!mObservers.contains(observer))
mObservers.add(observer);
}
}
public synchronized void unregister(Observer<T> observer) {
mObservers.remove(observer);
}
public void notifyObservers(T data) {
for (Observer<T> observer : mObservers) {
observer.onUpdate(this, data);
}
}
}
而我们的观察者只需要实现一个观察者的接口Observer,该接口也是泛型的
public interface Observer<T> {
void onUpdate(Observable<T> observable,T data);
}
调用：
public class Main {
public static void main(String [] args){
Observable<Weather> observable=new Observable<Weather>();
Observer<Weather> observer1=new Observer<Weather>() {
@Override
public void onUpdate(Observable<Weather> observable, Weather data) {
System.out.println("观察者1："+data.toString());
}
};
Observer<Weather> observer2=new Observer<Weather>() {
@Override
public void onUpdate(Observable<Weather> observable, Weather data) {
System.out.println("观察者2："+data.toString());
}
};
observable.register(observer1);
observable.register(observer2);
Weather weather=new Weather("晴转多云");
observable.notifyObservers(weather);
Weather weather1=new Weather("多云转阴");
observable.notifyObservers(weather1);
observable.unregister(observer1);
Weather weather2=new Weather("台风");
observable.notifyObservers(weather2);
}
}
5.适配器设计模式
适配器模式将某个类的接口转换成客户端期望的另一个接口表示，目的是
消除由于接口不匹配所造成的类的兼容性问题。主要分为三类：类的适配器模式、
对象的适配器模式、接口的适配器模式。
-
类的适配器模式
-
对象的适配器模式基本思路和类的适配器模式相同，只是将 Adapter 类作修改，这次不继承Source 类，而是持有 Source 类的实例，以达到解决兼容性的问题。
-
接口的适配器模式接口的适配器是这样的：有时我们写的一个接口中有多个抽象方法，当我们写该接口的实现类时，必须实现该接口的所有方法，这明显有时比较浪费，因为并不是所有的方法都是我们需要的，有时只需要某一些，此处为了解决这个问题，我们引入了接口的适配器模式，借助于一个抽象类，该抽象类实现了该接口，实现了所有的方法，而我们不和原始的接口打交道，只和该抽象类取得联系，所以我们写一个类，继承该抽象类，重写我们需要的方法就行。
6.装饰模式（Decorator）
顾名思义，装饰模式就是给一个对象增加一些新的功能，而且是动态的，要
求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例。
7.策略模式（strategy）
策略模式定义了一系列算法，并将每个算法封装起来，使他们可以相互替换，且算法的变化不会影响到使用算法的客户。需要设计一个接口，为一系列实现类 提供统一的方法，多个实现类实现该接口，设计一个抽象类（可有可无，属于辅 助类），提供辅助函数。策略模式的决定权在用户，系统本身提供不同算法的实 现，新增或者删除算法，对各种算法做封装。因此，策略模式多用在算法决策系 统中，外部用户只需要决定用哪个算法即可。
1233
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
