Android中使用软件设计模式之观察者模式、Builder模式、单例模式、简单工厂模式

工作内容：

1.观察者模式

2.Builder模式

3.单例模式

4.简单工厂模式

学习分享：

一、观察者模式【代码参考例1】

在此种模式中，一个目标物件管理所有相依于它的观察者物件，并且在它本身的状态改变时主动发出通知。这通常透过呼叫各观察者所提供的方法来实现。此种模式通常被用来实现事件处理系统。[观察者和被观察者之间存在“观察”的逻辑关联，当被观察者发生改变的时候，观察者就会观察到这样的变化，并且做出相应的响应。]

观察者：（Observer）将自己注册到被观察对象（Subject）中，被观察对象将观察者存放在一个容器（Container）里。

被观察：被观察对象发生了某种变化（如图中的SomeChange），从容器中得到所有注册过的观察者，将变化通知观察者。

二、Builder模式【代码参考例2】

(1) 意图：将一个“复杂对象的构建算法”与它的“部件及组装方式”分离，使得构件算法和组装方式可以独立应对变化；复用同样的构建算法可以创建不同的表示，不同的构建过程可以复用相同的部件组装方式。
(2) 适用性：
当同时满足以下情况的时候可以使用Builder模式
    a. 当创建复杂对象的算法应该独立于该对象的组成部分以及他们的装配方式；
    b. 当构造过程必须允许构造的对象有不同的表示；

(3)Builder模式的核心是“聚合”

三、单例模式【代码参考例1中的Subject】

在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中一个类只有一个实例。

“保证一个类仅有一个实例，并提供一个访问它的全局访问点。”

单例模式的要点有三个；一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。

具体实现角度来说，就是以下三点：一是单例模式的类只提供私有的构造函数，二是类定义中含有一个该类的静态私有对象，三是该类提供了一个静态的公有的函数用于创建或获取它本身的静态私有对象。

优点
一、实例控制
单例模式会阻止其他对象实例化其自己的单例对象的副本，从而确保所有对象都访问唯一实例。
二、灵活性
因为类控制了实例化过程，所以类可以灵活更改实例化过程。
缺点
一、开销
虽然数量很少，但如果每次对象请求引用时都要检查是否存在类的实例，将仍然需要一些开销。可以通过使用静态初始化解决此问题。
二、可能的开发混淆
使用单例对象（尤其在类库中定义的对象）时，开发人员必须记住自己不能使用new关键字实例化对象。因为可能无法访问库源代码，因此应用程序开发人员可能会意外发现自己无法直接实例化此类。
三、对象生存期
不能解决删除单个对象的问题。在提供内存管理的语言中（例如基于.NET Framework的语言），只有单例类能够导致实例被取消分配，因为它包含对该实例的私有引用。在某些语言中（如 C++），其他类可以删除对象实例，但这样会导致单例类中出现悬浮引用。。

注意;在Android中的多线程中调用此方法应该在getInstance方法中用用synchronized来锁定该类（这里是Subject.class）

四、工厂模式【代码参考例3】

工厂模式在《Java与模式》中分为三类：
1）简单工厂模式（Simple Factory）：不利于产生系列产品；
2）工厂方法模式（Factory Method）：又称为多形性工厂；
3）抽象工厂模式（Abstract Factory）：又称为工具箱，产生产品族，但不利于产生新的产品；
一、简单工厂模式
简单工厂模式又称静态工厂方法模式。重命名上就可以看出这个模式一定很简单。它存在的目的很简单：定义一个用于创建对象的接口。在简单工厂模式中,一个工厂类处于对产品类实例化调用的中心位置上,它决定那一个产品类应当被实例化, 如同一个交通警察站在来往的车辆流中,决定放行那一个方向的车辆向那一个方向流动一样。
        先来看看它的组成：
         1) 工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑。在java中它往往由一个具体类实现。
         2) 抽象产品角色：它一般是具体产品继承的父类或者实现的接口。在java中由接口或者抽象类来实现。
         3) 具体产品角色：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。
二、工厂方法模式
工厂方法模式是简单工厂模式的进一步抽象化和推广，工厂方法模式里不再只由一个工厂类决定那一个产品类应当被实例化,这个决定被交给抽象工厂的子类去做。
　　来看下它的组成：
       1)抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。
       2)具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。
       3)抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。
       4)具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。
       工厂方法模式使用继承自抽象工厂角色的多个子类来代替简单工厂模式中的“上帝类”。正如上面所说，这样便分担了对象承受的压力；而且这样使得结构变得灵活 起来——当有新的产品（即暴发户的汽车）产生时，只要按照抽象产品角色、抽象工厂角色提供的合同来生成，那么就可以被客户使用，而不必去修改任何已有的代 码。可以看出工厂角色的结构也是符合开闭原则的！

//抽象产品角色
public interface Moveable {
    void run();
}
//具体产品角色
public class Plane implements Moveable {
    @Override
    public void run() {
        System.out.println("plane....");
    }
}

public class Broom implements Moveable {
    @Override
    public void run() {
        System.out.println("broom.....");
    }
}

//抽象工厂
public abstract class VehicleFactory {
    abstract Moveable create();
}
//具体工厂
public class PlaneFactory extends VehicleFactory{
    public Moveable create() {
        return new Plane();
    }
}
public class BroomFactory extends VehicleFactory{
    public Moveable create() {
        return new Broom();
    }
}
//测试类
public class Test {
    public static void main(String[] args) {
        VehicleFactory factory = new BroomFactory();
        Moveable m = factory.create();
        m.run();
    }
}

可以看出工厂方法的加入，使得对象的数量成倍增长。当产品种类非常多时，会出现大量的与之对应的工厂对象，这不是我们所希望的。因为如果不能避免这种情 况，可以考虑使用简单工厂模式与工厂方法模式相结合的方式来减少工厂类：即对于产品树上类似的种类（一般是树的叶子中互为兄弟的）使用简单工厂模式来实 现。
简单工厂和工厂方法模式的比较
工厂方法模式和简单工厂模式在定义上的不同是很明显的。工厂方法模式的核心是一个抽象工厂类,而不像简单工厂模式, 把核心放在一个实类上。工厂方法模式可以允许很多实的工厂类从抽象工厂类继承下来, 从而可以在实际上成为多个简单工厂模式的综合,从而推广了简单工厂模式。 
反过来讲,简单工厂模式是由工厂方法模式退化而来。设想如果我们非常确定一个系统只需要一个实的工厂类, 那么就不妨把抽象工厂类合并到实的工厂类中去。而这样一来,我们就退化到简单工厂模式了。
三、抽象工厂模式
在抽象工厂模式中，抽象产品 (AbstractProduct) 可能是一个或多个，从而构成一个或多个产品族(Product Family)。 在只有一个产品族的情况下，抽象工厂模式实际上退化到工厂方法模式。

//抽象工厂类
public abstract class AbstractFactory {
    public abstract Vehicle createVehicle();
    public abstract Weapon createWeapon();
    public abstract Food createFood();
}
//具体工厂类，其中Food,Vehicle，Weapon是抽象类，
public class DefaultFactory extends AbstractFactory{
    @Override
    public Food createFood() {
        return new Apple();
    }
    @Override
    public Vehicle createVehicle() {
        return new Car();
    }
    @Override
    public Weapon createWeapon() {
        return new AK47();
    }
}
//测试类
public class Test {
    public static void main(String[] args) {
        AbstractFactory f = new DefaultFactory();
        Vehicle v = f.createVehicle();
        v.run();
        Weapon w = f.createWeapon();
        w.shoot();
        Food a = f.createFood();
        a.printName();
    }
}

例1：观察者模式+单列模式

//观察者接口【发现被观察的对象的状态或者数据发生改变时要做的事】
public interface CallBackObserver {
    void afterChangeDo();//被观察的数据/状态改变后执行
}
class Observer_1 implements CallBackObserver{
    private String observerName="";
    public String getObserverName() {
        return observerName;
    }
    public void setObserverName(String observerName) {
        this.observerName = observerName;
    }
    //构造函数，传入观察者名称，便于区分
    public Observer_1(String observerName) {
        super();
        this.observerName = observerName;
    }
    @Override
    public void afterChangeDo() {
        System.out.println(observerName+"执行afterChangeDo");
    }
}

//被观察者（类）的父类
public abstract class SubjectFather {
    public abstract void bindObserver(Observer_1 observer);//绑定
    public abstract void disBindObserver(Observer_1 observer);        //解绑
    public abstract void notifyAllObserver();        //通知所有观察者
}

//被观察者（实体类）：
class Subject  extends SubjectFather{
    private List<Observer_1> list;
   <span style="color:#ff6666;"> /**
     * 这里使用了单例模式（懒汉式）来构造一个Subject对象
     * 单例模式：私有化构造函数，常用一个public static Subject getInstance()方法来获得Subject的对象
     */</span>
    private static Subject subject=null;
    public static Subject getInstance(){
        if(subject == null){
            subject = new Subject();
        }
        return subject;
    }
    // 私有化构造函数【不允许在外部通过new来构造对象】
    private Subject() {
        list = new ArrayList<>();
    }
    @Override
    public void bindObserver(Observer_1 observer) {
        list.add(observer);
        System.out.println("绑定——"+observer.getObserverName());
    }

    @Override
    public void disBindObserver(Observer_1 observer) {
        list.remove(observer);
        System.out.println("解绑——"+observer.getObserverName());
    }

    public void dataChange(int i) {
        System.out.println("数据发生第"+i+"次改变");
        notifyAllObserver();
    }
    @Override
    public void notifyAllObserver() {
        for (Observer_1 observer_1 : list) {
            observer_1.afterChangeDo();
        }
    }
}

//观察者模式的演示类
public class ObserverDemo {
    public static void main(String[] args) {
        Subject subject = Subject.getInstance();
        Observer_1 observer_1 = new Observer_1("观察者1");
        Observer_1 observer_2 = new Observer_1("观察者2");
        Observer_1 observer_3 = new Observer_1("观察者3");
        // 绑定
        subject.bindObserver(observer_1);
        subject.bindObserver(observer_2);
        subject.bindObserver(observer_3);

        // 数据改变
        subject.dataChange(1);
        subject.dataChange(2);
        subject.dataChange(3);

        // 解绑
        subject.disBindObserver(observer_1);
        subject.disBindObserver(observer_2);
        subject.disBindObserver(observer_3);
    }
}

运行结果:

绑定——观察者1
绑定——观察者2
绑定——观察者3
数据发生第1次改变
观察者1执行afterChangeDo
观察者2执行afterChangeDo
观察者3执行afterChangeDo
数据发生第2次改变
观察者1执行afterChangeDo
观察者2执行afterChangeDo
观察者3执行afterChangeDo
数据发生第3次改变
观察者1执行afterChangeDo
观察者2执行afterChangeDo
观察者3执行afterChangeDo
解绑——观察者1
解绑——观察者2
解绑——观察者3

例2：Builder简单写法[写法有很多种，可以自己多去尝试]

public class Apple {
	private String name;	//名称
	private double price;	//价格
	private int color;			//颜色
	private int memory;	//存储空间大小
	private int mode;		//联网方式
	//构造函数私有化，防止直接生成对象
	private Apple(String name, double price, int color, int memory, int mode) {
		super();
		this.name = name;
		this.price = price;
		this.color = color;
		this.memory = memory;
		this.mode = mode;
	}
	//测试用
	@Override
	public String toString() {
		return "Apple [name=" + name + ", price=" + price + ", color=" + color + ", memory=" + memory + ", mode=" + mode
				+ "]";
	}
	static class Builder{
		private String name;	//名称
		private double price;	//价格
		private int color;			//颜色
		private int memory;	//存储空间大小
		private int mode;
		public Apple build(){
			//返回Apple的对象
			//可以在这里设置默认值【当传入值为空或者没有set时的默认值】
			return new Apple(name,price,color,memory,mode);
		}
		//方法返回是Builder，就可以一直使用.方法名，来调用Builder中的方法
		//可以在方法中约束传入的值得“范围”
		public Builder setName(String name) {
			this.name = name;
			return this;
		}
		public Builder setPrice(double price) {
			this.price = price;
			return this;
		}
		public Builder setColor(int color) {
			this.color = color;
			return this;
		}
		public Builder setMemory(int memory) {
			this.memory = memory;
			return this;
		}
		public Builder setMode(int mode) {
			this.mode = mode;
			return this;
		}		
	}
}

//测试Builder的Demo
public class TespBuilder {
	public static void main(String[] args) {
		Apple apple = new Apple.Builder()
				.setColor(0)
				.setMemory(64)
				.setMode(1)
				.setName("iphone5s")
//				.setPrice(2600)
				.build();
		System.out.println(apple);
	}
}

运行结果：

Apple [name=iphone5s, price=0.0, color=0, memory=64, mode=1]