设计模式（一）

   ----笔记：

   一 单例模式：

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

    全局只有一个该类的实例，不能在外部通过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();
    }
}

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