Android应用开发Android 常见的设计模式

Android应用开发Android 常见的设计模式_第1张图片白羽2019-03-04来源：网络阅读 227评论 0

摘要：本文将带你了解Android应用开发Android 常见的设计模式，希望本文对大家学Android有所帮助。

本文将带你了解Android应用开发Android 常见的设计模式，希望本文对大家学Android有所帮助。

Android应用开发Android 常见的设计模式_第2张图片

单例模式：分为懒汉式和饿汉式
EventBus就是使用的单例模式，双重锁+volatile。

工厂方法模式：
定义一个用于创建对象的接口，让子类决定实例化哪一个类，工厂方法使一个类的实例化延迟到其子类。
在工厂方法模式中，核心的工厂类不再负责所有的对象的创建，而是将具体创建的工作交给子类去做。这个核心类则摇身一变，成为了一个抽象工厂角色，仅负责给出具体工厂子类必须实现的接口，而不接触哪一个类应当被实例化这种细节。
首先：定义一个接口
public interface Strategy {
void travel();
}
然后，根据不同的出行方式来实现接口
public class WalkStrategy implements Strategy{

@Override
public void travel() {
System.out.println(walk);
}

}
public class PlaneStrategy implements Strategy{

@Override
public void travel() {
System.out.println(plane);
}

}
public class SubwayStrategy implements Strategy{

@Override
public void travel() {
System.out.println(subway);
}

}
还需要一个包装类，来调用接口
public class TravelContext {
Strategy strategy;

public Strategy getStrategy() {
return strategy;
}

public void setStrategy(Strategy strategy) {
this.strategy = strategy;
}

public void travel() {
if (strategy != null) {
strategy.travel();
}
}
}
测试：
public class Main {
public static void main(String[] args) {
TravelContext travelContext=new TravelContext();
travelContext.setStrategy(new PlaneStrategy());
travelContext.travel();
travelContext.setStrategy(new WalkStrategy());
travelContext.travel();
travelContext.setStrategy(new SubwayStrategy());
travelContext.travel();
}
}
如果以后要增加别的出行方式，只要继承接口即可，不需要修改现有的类
android中的使用：bitmapFactory

抽象工厂模式：
为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类。
在以下情况下，适用于工厂方法模式：
(1) 当一个类不知道它所必须创建的对象的类的时候。
(2) 当一个类希望由它的子类来指定它所创建的对象的时候。
(3) 当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候。

建造者模式：
将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
与抽象工厂的区别：在建造者模式里，有个指导者，由指导者来管理建造者，用户是与指导者联系的，指导者联系建造者最后得到产品。即建造模式可以强制实行一种分步骤进行的建造过程。
建造模式是将复杂的内部创建封装在内部，对于外部调用的人来说，只需要传入建造者和建造工具，对于内部是如何建造成成品的，调用者无需关心。
public class Person {
private String name;

private Person(Builder builder) {
this.name=builder.name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}

static class Builder{
private String name;

public Builder name(String name){
this.name=name;
return this;
}
public Person build(){
return new Person(this);
}
}
}
从上边代码我们可以看到我们在Builder类中定义了一份跟Person类一样的属性，通过一系列的成员函数进行赋值，但是返回的都是this,最后提供了一个build函数来创建person对象，对应的在Person的构造函数中，传入了Builder对象，然后依次对自己的成员变量进行赋值。此外，Builder的成员函数返回的都是this的另一个作用就是让他支持链式调用，使代码可读性大大增强
于是我们就可以这样创建Person对象
Person.Builder builder=new Person.Builder();
Person person=builder
.name(张三)
.age(18)
.height(178.5)
.weight(67.4)
.build();
Android中builder模式很多，例如：alertDialog的builder模式、gsonbuilder、okhttp的builder链式调用
总结如下：
1、定义一个静态内部类Builder，内部成员变量跟外部一样
2、Builder通过一系列方法给成员变量赋值，并返回当前对象（this）
3、Builder类内部提供一个build方法方法或者create方法用于创建对应的外部类，该方法内部调用了外部类的一个私有化构造方法，该构造方法的参数就是内部类Builder
4、外部类提供一个私有化的构造方法供内部类调用，在该构造函数中完成成员变量的赋值

代理模式：
为其他对象提供一种代理以控制对这个对象的访问
所谓代理，就是一个人或者机构代表另一个人或者机构采取行动。在一些情况下，一个客户不想或者不能够直接引用一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。

适配器模式：

观察者模式：
定义对象间一种一对多的依赖关系，使得当每一个对象改变状态，则所有依赖于它的对象都会得到通知并自动更新。
观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化时，会通知所有观察者对象，使它们能够自动更新自己。
主要包括四个部分：
　　1. Subject被观察者。是一个接口或者是抽象类，定义被观察者必须实现的职责，它必须能偶动态地增加、取消观察者，管理观察者并通知观察者。
　　2. Observer观察者。观察者接收到消息后，即进行update更新操作，对接收到的信息进行处理。
　　3. ConcreteSubject具体的被观察者。定义被观察者自己的业务逻辑，同时定义对哪些事件进行通知。
　　4. ConcreteObserver具体观察者。每个观察者在接收到信息后处理的方式不同，各个观察者有自己的处理逻辑。
其实就是我们无需每时每刻关注我们感兴趣的东西，我们只需要订阅它即可，一旦我们订阅的事务有变化了，被订阅的事务就会即时的通知我们
我们来看一下观察者模式的组成：
观察者，我们称它为Observer，有时候我们也称它为订阅者，即Subscriber
被观察者，我们称它为Observable，即可以被观察的东西，有时候还会称之为主题，即Subject
举例：

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 {
List> mObservers = new ArrayList>();

public void register(Observer observer) {
if (observer == null) {
throw new NullPointerException(observer == null);
}
synchronized (this) {
if (!mObservers.contains(observer))
mObservers.add(observer);
}
}

public synchronized void unregister(Observer observer) {
mObservers.remove(observer);
}

public void notifyObservers(T data) {
for (Observer observer : mObservers) {
observer.onUpdate(this, data);
}
}

}
而我们的观察者只需要实现一个观察者的接口Observer,该接口也是泛型的
public interface Observer {
void onUpdate(Observable observable,T data);
}
一旦订阅的主题发生了变化，就会调用该接口
用一下，我们定义一个天气变化的主题，也就是被观察者，再定义两个观察者来观察天气的变化，一旦变化了就打印出天气的情况，注意，一定要用register方法来注册，否则观察者收不到变化的信息，而一旦不感兴趣，就可以调用unregister方法
public class Main {
public static void main(String [] args){
Observable observable=new Observable();
Observer observer1=new Observer() {
@Override
public void onUpdate(Observable observable, Weather data) {
System.out.println(观察者1：+data.toString());
}
};
Observer observer2=new Observer() {
@Override
public void onUpdate(Observable 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);

}
}
输出也没有问题
观察者1：Weather{description=’晴转多云’}
观察者2：Weather{description=’晴转多云’}
观察者1：Weather{description=’多云转阴’}
观察者2：Weather{description=’多云转阴’}
观察者2：Weather{description=’台风’}

Android中的观察者模式：onClick、EventBus的register、unregister、post事件都有观察者模式

本文由职坐标整理并发布，希望对同学们有所帮助。了解更多详情请关注职坐标移动开发之Android频道！

Android应用开发Android 常见的设计模式

更多相关文章

随机推荐