Android-设计模式

Android-设计模式

1. 单例模式

1.1 饿汉式

饿汉式写法简单,线程安全,但没有懒加载的效果,如果没有使用过会浪费内存

1
2
3
4
5
public class Singleton {
private Singleton() {}
private static final Singleton singleton = new Singleton();
pubilc static Singleton getInstance() { return singleton; }
}

1.2 懒汉式

懒汉式:懒加载,节约内存,但线程不安全

1
2
3
4
5
6
7
8
9
10
public class Singleton {
private Singleton() {}
private stati Singleton singleton = null;
pubilc static Singleton getInstance() {
if (singleton == null) {
singleton = new Singleton();
}
return singleton;
}
}

1.3 线程安全的懒汉式

线程安全的懒汉式:懒加载同时线程安全,但使用锁会造成不必要的同步开销,大部分情况下用不到同步

1
2
3
4
5
6
7
8
9
10
public class Singleton {
private Singleton() {}
private stati Singleton singleton = null;
pubilc static synchronized Singleton getInstance() {
if (singleton == null) {
singleton = new Singleton();
}
return singleton;
}
}

1.4 双锁检测DCL

双锁检测:懒加载,线程安全,效率高,但 volatile 影响一点性能,高并发下有一定的缺陷。volatile 关键字可以禁止代码重排序,所有的写(write)操作都将发生在读(read)操作之前,保证singleton是一定被初始化了的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Singleton {
private volatile static Singleton singleton;
private Singleton() { }
public Singleton getInstance() {
if (null == singleton) {
synchronized (Singleton.class) {
if (null == singleton) {
singleton = new Singleton();
}
}
}
return singleton;
}
}

1.5 静态内部类

静态内部类:懒加载,线程安全,推荐使用

1
2
3
4
5
6
7
8
9
10
11
public class Singleton {
private Singleton() { }
public static Singleton getInstance() {
//第一次调用getInstance方法时才加载SingletonHolder并初始化sInstance
return SingletonHolder.sInstance;
}
//静态内部类
private static class SingletonHolder {
private static final Singleton sInstance = new Singleton();
}
}

2. 工厂模式

2.1 简单工厂模式

(1)定义抽象产品类及公共接口

1
2
3
public abstract class Product {
public abstract void show();
}

(2)定义具体产品类

1
2
3
4
5
6
7
8
9
10
11
12
public class ProductA extends Product {
@Override
public void show() {
System.out.println("product A");
}
}
public class ProductB extends Product {
@Override
public void show() {
System.out.println("product B");
}
}

(3)创建工厂类,创建具体的产品

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Factory {
public static Product create(String productName) {
Product product = null;
switch (productName) {
case "A":
product = new ProductA();
break;
case "B":
product = new ProductB();
break;
}
return product;
}
}

2.2 抽象工厂模式

抽象工厂最复杂,假如有 N 种产品,M 个工厂实体,则一共会有 N * M 种产品实体。

(1)创建抽象产品类

1
2
3
4
5
6
7
8
9
public abstract class CPU {
public abstract void showCPU();
}
public abstract class Memory {
public abstract void showMemory();
}
public abstract class HD {
public abstract void showHD();
}

(2)创建产品实体类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class IntelCPU extends CPU {
@Override
public void showCPU() {
System.out.println("Intet CPU");
}
}
public class SamsungMemory extends Memory {
@Override
public void showMemory() {
System.out.println("三星 内存");
}
}
public class WdHD extends HD {
@Override
public void showHD() {
System.out.println("西部数据 硬盘");
}
}

(3)创建抽象工厂类

1
2
3
4
5
public abstract class ComputerFactory {
public abstract CPU createCPU();
public abstract Memory createMemory();
public abstract HD createHD();
}

(4)创建工厂实体类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class DellComputerFactory extends ComputerFactory {
@Override
public CPU createCPU() {
return new IntelCPU();
}
@Override
public Memory createMemory() {
return new SamsungMemory();
}
@Override
public HD createHD() {
return new WdHD();
}
}

2.3 工厂方法模式

工厂方法模式可以看成是抽象工厂模式的一个特例,当抽象工厂中,只有一种产品时,就和工厂方法一样了。

(1)创建抽象产品类

1
2
3
public abstract class Product {
public abstract void show();
}

(2)创建产品实体类

1
2
3
4
5
6
7
8
9
10
11
12
public class ProductA extends Product {
@Override
public void show() {
System.out.println("product A");
}
}
public class ProductB extends Product {
@Override
public void show() {
System.out.println("product B");
}
}

(3)创建抽象工厂类

1
2
3
public abstract class Factory {
public abstract Product create();
}

(4)创建工厂实体类

1
2
3
4
5
6
7
8
9
10
11
12
public class FactoryA extends Factory {
@Override
public Product create() {
return new ProductA();//创建ProductA
}
}
public class FactoryB extends Factory {
@Override
public Product create() {
return new ProductB();//创建ProductB
}
}

3. 建造者模式

(1)创建产品实体类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Computer {
private String mCPU;
private String mMemory;
private String mHD;

public void setCPU(String CPU) {
mCPU = CPU;
}
public void setMemory(String memory) {
mMemory = memory;
}
public void setHD(String HD) {
mHD = HD;
}
}

(2)创建建造者抽象类

1
2
3
4
5
6
public abstract class Builder {
public abstract void buildCPU(String cpu);//组装CPU
public abstract void buildMemory(String memory);//组装内存
public abstract void buildHD(String hd);//组装硬盘
public abstract Computer create();//返回组装好的电脑
}

(3)创建建造者实体类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class ConcreteBuilder extends Builder {
//创建产品实例
private Computer mComputer = new Computer();

@Override
public void buildCPU(String cpu) {//组装CPU
mComputer.setCPU(cpu);
}
@Override
public void buildMemory(String memory) {//组装内存
mComputer.setMemory(memory);
}
@Override
public void buildHD(String hd) {//组装硬盘
mComputer.setHD(hd);
}
@Override
public Computer create() {//返回组装好的电脑
return mComputer;
}
}

(4)创建指挥者实体类,用于控制建造者进行建造任务

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Director {
private Builder mBuild = null;

public Director(Builder build) {
this.mBuild = build;
}
//指挥装机人员组装电脑
public void Construct(String cpu, String memory, String hd) {
mBuild.buildCPU(cpu);
mBuild.buildMemory(memory);
mBuild.buildHD(hd);
}
}

4. 观察者模式

java.util.Observable:抽象被观察者。

  • 需要继承并根据不同功能重写 Observable,表示被观察者。使用单例模式,由静态内部类管理一个实例,将构造方法私有化。
  • Observable 的实例(单例)对象也就是被观察者,在内部根据需要添加方法,方法内部调用 setChanged()notifyObservers(Object data)
  • 而被观察者需要通过调用 Observable#addObserver(Object observer) 来添加观察者。
  • notifyObservers(Object data) 方法内部会遍历所有添加给被观察者的观察者,并调用观察者的 update(Observable observable, Object arg) 方法,也即表示带着数据 data 通知所有观察者。
  • 因此充当观察者的类(添加给被观察者的类)需要实现 Observe 接口,重写 update(Observable o, Object arg) 方法,用 instanceof 判断参数 observable 到底是哪一个被观察者,然后用数据 arg 做相应的操作。

(1)一个被观察者可以被多个观察者观察,也即给被观察者 add 多个观察者,并添加业务方法,当业务执行的时候,业务方法内部会通知所有被添加的观察者,所有被添加的观察者都会收到通知,但一个被观察者可以有多个业务,并不是每个观察者都需要用到每个业务,因此可以在不同业务的方法内的 notifyObservers(Object data) 中,传不同类型的数据 data,在观察者的 update(Observable observable, Object arg) 方法内,需要用 instanceof 判断数据 arg 的类型,来判断自己是否需要处理。

(2)一个观察者可以观察多个被观察者,也就是多个被观察者调用 Observable.addObserver() 的时候,可以添加同一个观察者,因此当观察者的 update(Observable observable, Object arg) 方法被调用时,还要先用 instanceof 来判断参数 observable 到底是来自哪个被观察者,然后再用 instanceof 判断数据 arg 是由被观察者中哪个业务方法调用传递过来的,这样才能唯一确定一个业务逻辑。

(3)接口回调与观察者模式的选择:回调是一对一的关系,只监听一个事件;观察者模式则是可以一对多也可以多对一,因此观察者模式的数据流图是网状结构,如果业务逻辑比较简单的时候,用回调反而能提升代码可读性以及降低开发复杂度。


5. 中介者模式

当程序存在大量的类时,多个对象之间存在着依赖的关系,呈现出网状结构,那么程序的可读性和可维护性就变差了,并且修改一个类需要牵涉到其他类,不符合开闭原则。

当多个类之间有复杂交互时,通过创建一个中介者类,用于处理其他类之间的交互问题,提高耦合但也提高了代码逻辑清晰度和可读性,在类和类交互时,也不需要针对不同的类定制专用的接口,只需要通过中介者提供的公用接口调用即可。