android中常见设计模式

最新推荐文章于 2024-07-09 17:45:32 发布

独家记忆sky

最新推荐文章于 2024-07-09 17:45:32 发布

阅读量1.1k

点赞数

本文链接：https://blog.csdn.net/qq_33806473/article/details/72526647

版权

单例模式

确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。

public class Singleton {
    private static volatile Singleton instance = null;

    private Singleton(){
    }

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

Build模式

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示
如果一个类的构造需要很多参数，而且这些参数并不都是必须的，那么这种情况下就比较适合Builder。
假设有一个Person类，我们通过该Person类来构建一大批人，这个Person类里有很多属性，最常见的比如name，age，weight，height等等，并且我们允许这些值不被设置，那么我们将需要重载很多构造方法。

Person增加一个静态内部类Builder类，并修改Person类的构造函数，代码如下。

public class Person {
    private String name;
    private int age;
    private double height;
    private double weight;

    privatePerson(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 Person build(){
            return new Person(this);
        }
    }
}

创建person对象时

Person.Builder builder=new Person.Builder();
Person person=builder
        .name("张三")
        .age(18)
        .height(178.5)
        .weight(67.4)
        .build();

常见的AlertDialog，OkHttp等就使用了build模式

观察者模式

定义对象间的一种一对多的依赖关系，当一个对象的状态发送改变时，所有依赖于它的对象都能得到通知并被自动更新

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 interface Observer<T> {
    void onUpdate(Observable<T> observable,T data);
}

用法

public class Main {
    public static void main(String [] args){
        Observable<String> observable=new Observable<String>();
        Observer<String> observer1=new Observer<String>() {
            @Override
            public void onUpdate(Observable<String> observable, String data) {
                System.out.println("观察者1："+data);
            }
        };
        Observer<String> observer2=new Observer<String>() {
            @Override
            public void onUpdate(Observable<String> observable, String data) {
                System.out.println("观察者2："+data);
            }
        };

        observable.register(observer1);
        observable.register(observer2);



        observable.notifyObservers("发布消息1");
        observable.notifyObservers("发布消息2");

        observable.unregister(observer1);

        observable.notifyObservers("发布消息3");

    }
}

EventBus

EventBus.getDefault().register(Object subscriber);
EventBus.getDefault().unregister(Object subscriber);

EventBus.getDefault().post(Object event);

RxJava

Observable<String> myObservable = Observable.create(  
    new Observable.OnSubscribe<String>() {  
        @Override  
        public void call(Subscriber<? super String> sub) {  
            sub.onNext("Hello, world!");  
            sub.onCompleted();  
        }  
    }  
);

Subscriber<String> mySubscriber = new Subscriber<String>() {  
    @Override  
    public void onNext(String s) { System.out.println(s); }  

    @Override  
    public void onCompleted() { }  

    @Override  
    public void onError(Throwable e) { }  
};

myObservable.subscribe(mySubscriber);

原型模式

用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。更快的获取到一个相同属性的对象，内容与原型一样，内存地址i不一样。
首先我们定义一个Person类 实现Cloneable接口重写clone方法

public class Person implements Cloneable {

    private String name;
    private String age;
    private String gender;


    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 String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    @Override
    protected Object clone() {
        Person person=null;
        try {
            person=(Person)super.clone();
            person.name=this.name;
            person.age=this.age;
            person.gender=this.gender;
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return person;
    }
}

        Person person = new Person();
        person.setAge("20");
        person.setGender("男");
        person.setName("赞张");
        Person person1 = (Person) person.clone();

此时person和person1相同的内容但是内存指向不一样

代理模式

提供了一个新的对象,实现了对真实对象的操作,或成为真实对象的替身.

A找中介租房为Demo来构建代理模式，先定义一个抽象主题,IHouse

public interface IHouse {  
    void getHouseInfo();  
    void signContract();  
    void payFees();  
}

定义真实主题

public class House implements IHouse{  
    private final String TAG = House.class.getSimpleName();  
    private String name;  
    private double price;  

    public House(String name, double price){  
        this.name = name;  
        this.price = price;  
    }  

    @Override  
    public void getHouseInfo() {  
        Log.i(TAG, "House Info- name:" + name + "  ￥:" + price);  
    }  

    @Override  
    public void signContract() {  
        Log.i(TAG, "Contract:" + name + "  signed at" +  
               new SimpleDateFormat("HH:mm:ss").format(SystemClock.uptimeMillis()));  
    }  

    @Override  
    public void payFees() {  
        Log.i(TAG, "Bill: name-" + name + "  $-" + price);  
    }  
}

定义房屋代理,同样需要实现IHouse接口

public class ProxyHouse implements IHouse{  
    private final String TAG = ProxyHouse.class.getSimpleName();  
    private IHouse house;  
    public ProxyHouse(IHouse house){  
        this.house = house;  
    }  
    @Override  
    public void getHouseInfo() {  
        Log.i(TAG, "searching");  
        house.getHouseInfo();  
        Log.i(TAG, "search finished");  
    }  

    @Override  
    public void signContract() {  
        Log.i(TAG, "prepare contract");  
        house.signContract();  
    }  

    @Override  
    public void payFees() {  
        house.payFees();  
    }  
}

对于客户来说,完全不用跟House进行直接交互,而是跟代理交互

IHouse house = new House("Downton Abbey", 5000);  
IHouse proxyHouse = new ProxyHouse(house);  
Log.i(TAG, "looking for a perfect house");  
proxyHouse.getHouseInfo();  
Log.i(TAG, "thinking");  
proxyHouse.signContract();  
proxyHouse.payFees();  
Log.i(TAG, "so easy");

工厂模式

1.工厂方法模式 (Factory Method)
2.抽象工厂模式 (Abstract Factory)

工厂生产不同操作系统的手机为例

public interface Phone {  
    public void getOS();  
}

再根据Phone接口实现Android,IOS，二种手机.

public class AndroidPhone implements Phone {  
    private final String TAG = AndroidPhone.class.getSimpleName();  
    @Override  
    public void getOS() {  
        Log.i(TAG, "im Android");  
    }  
}  
public class IosPhone implements Phone {  
    private final String TAG = IosPhone.class.getSimpleName();  
    @Override  
    public void getOS() {  
        Log.i(TAG, "im IOS");  
    }  
}

标准的工厂方法模式都需要有抽象的工厂接口或者基类.

public abstract class IGenerator {  
    public abstract IPhone generatePhone() throws Exception;  
}

public class AndroidGenerator extends IGenerator {  
    @Override  
    public Phone generatePhone() {  
        return new AndroidPhone();  
    }  
}  
public class IOSGenerator extends IGenerator {  
    @Override  
    public Phone generatePhone() {  
        return new IosPhone();  
    }

生产

AndroidGenerator androidGenerator = new AndroidGenerator();  
IOSGenerator iosGenerator = new IOSGenerator();  

AndroidPhone android = androidGenerator.generatePhone();  
IosPhone ios = iosGenerator.generatePhone();