Android常用设计模式

一、单例模式

1、饿汉式

public class EHanSingleton {
    //在类初始化时，已经自行实例化,所以是线程安全的。
    private static final EHanSingleton single =new EHanSingleton();
 
    public static EHanSingleton getInstance(){
        return single;
    }
}

• 优点：写法简单，线程安全
• 缺点：没有懒加载的效果，如果没有使用过的话会造成内存浪费

其中，getInstance()

getInstance的使用

getInstance这个方法在单例模式用的甚多，为了避免对内存造成浪费，直到需要实例化该类的时候才将其实例化，这个时候通过getInstance来获取该对象。

getInstance的特点

1.可以直接使用，调用多次返回同一个对象。

2.getInstance往往是static的。

3.对象使用之前通过getInstance得到而不需要自己定义，用完之后不需要delete。

4.对于抽象类，要想对其实例化，只能用getInstance方法，是不能new出来的
 

2、懒汉式

public class LanHanSingleton {
    private static LanHanSingleton singleton;
 
    public static synchronized LanHanSingleton getSingleton(){
        if (singleton == null){
            singleton =new LanHanSingleton();
        }
        return singleton;
    }
}

• 优点：实现了懒加载的效果，线程安全。
• 缺点：使用synchronized会造成不必要的同步开销，而且大部分时候我们是用不到同步的

3、双重校验锁（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会失效，虽然概率较小

4、静态内部类

public class StaticInnerSigleton {
 
    public static StaticInnerSigleton getInstance(){
        return StaticInner.single;
    }
 
    //静态内部类
    private static class StaticInner{
        private static final StaticInnerSigleton single =new StaticInnerSigleton();
    }
}

• 优点：懒加载，线程安全，推荐使用

二、工厂模式

        工厂模式分为工厂方法模式和抽象工厂模式。
        工厂方法模式分为三种：普通工厂模式，就是建立一个工厂类，对实现了同一接
口的一些类进行实例的创建。
        多个工厂方法模式，是对普通工厂方法模式的改进，在普通工厂方法模式中，如
果传递的字符串出错，则不能正确创建对象；而多个工厂方法模式是提供多个工
厂方法，分别创建对象。
        静态工厂方法模式，将上面的多个工厂方法模式里的方法置为静态的，不需要创
建实例，直接调用即可。

1、普通工厂模式

public interface Sender {
    public void send();
}


public class MailSender implements Sender {
    private static final String TAG = "MailSender";
    @Override
    public void send() {
        Log.i(TAG, "send: MailSender");
    }
}

public class SmsSender implements Sender {
    private static final String TAG = "SmsSender";
    @Override
    public void send() {
        Log.i(TAG, "send: SmsSender");
    }
}

public class SendFactory {
    private static final String TAG = "SendFactory";
    public Sender produce(String type) {
        Log.i(TAG, "produce: SendFactory");
        if ("mail".equals(type)) {
            return new MailSender();
        } else if ("sms".equals(type)) {
            return new SmsSender();
        } else {
            Log.i(TAG, "produce: type is error!");
            return null;
        }
    }
}

2、多个工厂方法模式

        该模式是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符

串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别

创建对象。

        不需要创建实例，直接调用即可。

public class SendFactory2 {
    public Sender produceMail() {
        return new MailSender();
    }

    public Sender produceSms() {
        return new SmsSender();
    }
}


public class FactoryTest {
    public static void main(String[] args) {
        SendFactory2 factory = new SendFactory2();
        Sender sender = factory.produceMail();
        sender.send();
    }
}

3、静态工厂方法模式

        将上面的多个工厂方法模式里的方法置为静态的。

public class SendFactory3 {
    public static Sender produceMail() {
        return new MailSender();
    }

    public static Sender produceSms() {
        return new SmsSender();
    }
}


public class FactoryTest {
    public static void main(String[] args) {
        Sender sender = SendFactory3.produceMail();
        sender.send();
    }
}

4、抽象工厂模式

        工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要
拓展程序，必须对工厂类进行修改，这违背了闭包原则，所以，从设计角度考虑，
有一定的问题，如何解决？就用到抽象工厂模式，创建多个工厂类，这样一旦需
要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。

public abstract class Provider {
    public abstract Sender produce();
}


public class SendMailFactory extends Provider {
    @Override
    public Sender produce() {
        return new MailSender();
    }
}


public class FactoryTest {
    public static void main(String[] args) {
        Provider provider = new SendMailFactory();
        Sender sender = provider.produce();
        sender.send();
    }
}

三、建造者模式(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());

四、观察者模式

定义：对象间一种一对多的依赖关系，使得当一个对象改变状态，则所有依赖于它的对象都会得到通知并被自动更新。

运用的场景：广播，EventBus等都是观察者模式。

模拟场景：天气预报，每次天气更新都会向你及时发送消息，观察者们就要更新界面。

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 + '\'' +  
                '}';  
    }  
}  

定义被观察者

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);  
  
    }  
}  

运行结果：

(38条消息) Android常用设计模式_android 设计模式_界斗士的博客-CSDN博客