设计模式（一）

----笔记：

一 单例模式：

单例模式-- 确保一个类只有要一个实例，并提供一个全局的访问点。

全局只有一个该类的实例，不能在外部通过new 来实例化对象，因此类中的构造器应该声明为private.由类内部调用进行实例化。

package com.example.arze.design;

/**
* Created by arze on 2015/11/6.
*/
public class Singeton {
private static Singeton mSington;

//声明为私有的构造器
private Singeton() {
}

//提供一个全局访问点
public static Singeton getInstance() {
if (null == mSington)
mSington = new Singeton();
return mSington;
}
}

上面的单例模式代码存在一个问题，自己明明把类写成了单例模式，按照单例模式的思维去写程序。在单线程可能不会有问题，但在多线程就不一定了。问题就出现在获取实例时没有对线程进行同步。当两条线程都进入了 null == mSington 这种情况，会出现问题，单例模式不再是单例，而自己之前以单例为前提写的代码可能就会出问题，改正：

package com.example.arze.design;

/**
* Created by arze on 2015/11/6.
*/
public class Singeton {
private static Singeton mSington;

//声明为私有的构造器
private Singeton() {
}

//提供一个全局访问点
public static  Singeton getInstance() {
if (null == mSington)
synchronized (Singeton.class) {
if (null == mSington)
mSington = new Singeton();
}
return mSington;
}
}

二 工厂模式：

简单工厂，简单工厂又称为静态工厂，一般通过静态的方法接受不同的参数达到返回不同的实例。

public interface Car {
//产品抽象类 ,这里是接口
}

Benz和Buick继承Car

public class SimpleFactory {
static Car creatCar(String str) {
if ("Benz".endsWith(str))
return new Benz();
else if ("Buick".endsWith(str))
return new Buick();
else
return null;
}
}

这个是一个简单的工厂例子，通过输入的参数创建Benz或者Buick，但当我们需要新增一类BMW时，需要修改creatCar（）方法，每增加一个类就要修改一次代码，要是不想修改代码，又想实现扩展，简单工厂实现不了，这也是简单工厂的缺点。为了解决这个问题，可用工厂方法。

工厂方法，定义一个创建对象的接口，由子类实现。比如上面的例子要做到扩展并遵循对修改关闭，可以定义一个接口。

public interface Factory {
Car creatCar();
}

由子类去实现建造什么类型的Car,例如

public class BenzFactory extends Factory {
@Override
public Car creatCar() {
return new Benz();
}
}

当然每新增一个类型就要新建一个实现了Factory的工厂，这样就可以做到不修改代码又能实现扩展。

三 抽象工厂 提供一个接口，用于创建产品家族。

定义一个接口，里面定义了创建一个家族产品的方法。

public interface AbstractFactory {
Car creatCar ();
Bus creatBus ();
Truck creatTruck ();
}

<pre name="code" class="java" style="font-size: 13.3333px;">通过继承这个接口可以实现一系列的工厂来生产不同的产品。

Factory1

<pre name="code" class="java">public class Factory1 implements AbstractFactory {
@Override
public Car creatCar() {
return new Benz();
}

@Override
public Bus creatBus() {
return new BigBus();
}

@Override
public Truck creatTruck() {
return new BigTruck();
}
}

Factory2

<pre name="code" class="java">public class Factory2 implements AbstractFactory {
@Override
public Car creatCar() {
return new Buick();
}

@Override
public Bus creatBus() {
return new SmallBus();
}

@Override
public Truck creatTruck() {
return new SmallTruck();
}
}

抽象工厂的具体类经常通过实现工厂方法来创建产品。当我们要从这组产品中增加一个新产品时需要改变接口，改变接口意味着我们需要改变其他子类的，万一子类多也是件麻烦的事。这也是这个方法的缺点。