创建型设计模式

设计模式的分类

•基础设计模式(Gof)：不与特定域，平台或编程语言关联

•根据目的, 也就是这个设计模式是干什么的进行分类:

•1)创建模式: 涉及对象的创建

•    单例模式, 工厂模式, 建造者模式，原型模式

•2)结构模式:涉及类和对象的组合

•    Facade外观模式, 代理模式, 适配器模式, 装饰模式

• 3)行为模式: 刻画了类和对象交换及分配职责的方式.主要目标是解耦

•    观察者模式, 命令模式, 模板模式

工厂模式Factory

•定义：工厂模式就是集中创建实例对象

•使用工厂模式的好处：

   1）客户类和工厂类分开。消费者任何时候需要某种产  品，只需向工厂请求即可。消费者无须修改就可以接纳新产品

   2）对象的创建由工厂来完成, 类之间的耦合大大减少，变成为类和工厂之间的耦合了.

• 3）对象的创建和使用分离，达到解耦合的目的。

•对面向对象设计原则的支持：

   1）简单工厂模式一定程序上是支持开闭原则的；但是对开闭原则支持不够。(引入新产品的时候要修改工厂类)

   2）工厂方法模式可以满足开闭原则

   3)为了满足依赖倒置原则常常需要使用工厂模式

Factory-简单工厂模式

public class Factory{

　　public static Sample creator(int which){

　//getClass 产生Sample 一般可使用动态类装载装入类。

　　if (which==1)

　　　　return new SampleA();

　　else if (which==2)

　　　　return new SampleB();

　　}

}

//Sample sampleA=Factory.creator(1);

//不涉及到Sample的具体子类,达到封装效果,也就减少错误修改的机会 

Factory-工厂方法模式

•使用工厂方法要注意几个角色

首先你要定义产品接口，如上面的Sample,

产品接口下有Sample接口的实现类,如SampleA,

  其次要有一个factory类，用来生成产品Sample

• interfaceIFactory{

•      Sample createProduct();

•}

•ClassAFactory implements IFactory{

•      Sample createProduct(){

•            return new SampleA();    

•}

•}对象的创建委托给子类来实现, 子类实现工厂方法来创建对象. 当然

也可以在子类中实现对系列具体产品的实现. 由子类来决定实例化到底

哪个具体的产品. 

Factory-抽象工厂

public abstract class Factory{

　　publicabstract Sample creator();

　　publicabstract Sample2 creator(String name);

}

public class SimpleFactory extends Factory{

　　publicSample creator(){
　　　　.........
　　　　return new SampleA
　　}

　　publicSample2 creator(String name){
　　　　.........
　　　　return new Sample2A
　　}

}

public class BombFactory extends Factory{

　　publicSample creator(){
　　　　......
　　　　return new SampleB
　　}

　　publicSample2 creator(String name){
　　　　......
　　　　return new Sample2B
　　}

}

多个产品系列，多个工厂方法一起就构成了抽象工厂模式。

单例模式Singleton

•主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。

•

•比如建立目录,数据库连接都需要这样的单线程操作

•

•好处在于可以节省内存，因为它限制了实例的个数，有利于Java垃圾回收 

使用单例模式Singleton(1)

public class Singleton {

　　private Singleton(){}

　　//在自己内部定义自己一个实例,注意这是private

//预加载

　　private static Singletoninstance = new Singleton();

　　

       //这里提供了一个供外部访问本class的静态方法，

       //可以直接访问　　
　　public static Singleton getInstance(){
　　　　return instance; 　　
　　 }
} 

使用单例模式Singleton(2)

public class Singleton {

//延迟加载

　　private static Singleton instance = null;
　public static synchronized Singleton getInstance(){
　　//这个方法比上面有所改进，不用每次都进行生成

       //对象，只是第一次使用时生成实例，提高了效率！
　　if (instance==null)
　　　　instance＝newSingleton();
　　return instance; 　　}

}

这种方式在多线程的情况下，由于每次获取实例的时候都要对getInstance（）方法加锁，获取锁才能运行，效率会受影响。

使用单例模式Singleton(3)

双锁机制：

    public class Singleton {

　  private static Singleton instance =null;
　public static  Singleton  getInstance(){
　　if (instance==null)
--1       synchronized(Singleton.class){
---2                 if (instance ==null) {

    ---3                      instance = newSingleton();
                  }
            }

      return instance; 　

　   }

}这种方式只是在初始化Singleton那部分代码的时候添加同步锁，这样提高了效率。

使用单例模式Singleton(4)

public class Teacher3 {

private static class Test{
public static Teacher3 t = new Teacher3();
}
public synchronized static Teacher3 getInstance(){

return Test.t;
}

private Teacher3(){}
}