Android常用设计模式

记一下Android常用的设计模式：

1.单例模式：

/*
* 单例模式
* */
public class Singleton {
    private static volatile Singleton singleton = null;

    private Singleton() {
    }

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

    }
}

2.建造者模式：

/**
 * 建造者模式
 */
public class Person {
    private String name;
    private String age;
    private double height;
    private double weight;

    public Person(Builder builder) {
        this.name = name;
        this.age = age;
        this.height = height;
        this.weight = weight;
    }

    public String getName() {
        return name;
    }

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

    public String getAge() {
        return age;
    }

    public void setAge(String 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 Person build() {
            return new Person(this);
        }
    }
}

使用：

Person.Builder builder=new Person.Builder();
builder.age(12).name("测试").height(12).weight(12).build();

3.观察者模式：

先定义一个接口：

public interface Observer<T> {
    void onUpdate(Observable<T> observable,T data);
}

//观察者
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);
        }
    }
}

//实体类
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 + '\'' +
                '}';
    }
}

使用:

Observable<Weather>observable=new Observable<>();
Observer<Weather>observer=new Observer<Weather>() {
    @Override
    public void onUpdate(Observable<Weather> observable, Weather data) {

    }
};

Observer<Weather>observer2=new Observer<Weather>() {
    @Override
    public void onUpdate(Observable<Weather> observable, Weather data) {

    }
};
observable.register(observer);
observable.register(observer2);
Weather weather=new Weather("好天气");
observable.notifyObservers(weather);