单例模式

      单例模式保证一个类仅有一个实例，并提供一个访问它的全局访问点。通常我们可以让一个全局变量使得一个对象被访问，但它不能阻止你实例化多个对象。一个最好的办法是，让类自身负责保存它的唯一实例。这个类可以保证没有其他实例可以被创建，并且它可以提供一个访问该实例的方法。

      也就是说，很多时候我们需要全局的对象，如一个工程中，数据库访问对象只有一个，这时，可以考虑使用单例模式。单例模式比全局对象好还包括：单例类可以继承，如下例中的C++代码。

     单例模式的关键点在于：构造函数私有，静态的GetInstance。

     另外，在C++中必须注意内存的释放。C++、Java、C#中还要注意多线程时的同步问题，另外在多线程可以以合适的方式保证共享变量仅初始化一次

 

以下列出懒汉式的单例模式

C++实现：

class Singleton  {    public:      static Singleton * GetInstance()      {          if(NULL == m_pInstance)              m_pInstance = new Singleton();          return m_pInstance;      }      static void Release()                    //必须，否则会导致内存泄露       {          if(NULL != m_pInstance)          {              delete m_pInstance;              m_pInstance = NULL;          }      }           protected:       Singleton()       {           cout<<"C++ Singleton"<
     
      Release();      return 0;  }
     

 

Java实现(这里仅给出类实现部分)：

public class Singleton{     private static Singleton instance=NULL;          private Singleton(){          System.out.println("Java Singleton");     }     public static Singleton getInstance(){          if(instance == NULL)               instance = new Singleton();          return instance;     }}

还有另一种形式： 饿汉单例,也就是,类被加载的时候就已经创建好了单例，相比懒汉式只是加载new的地方发生了改变，这里代码重略

 

饿汉式和懒汉式的比较：

1 饿汉式单例,由于类被加载的时候就将自己实例化,所以,从资源利用的角度来说,饿汉式单例比懒汉式单例效率更差

2 懒汉式单例在实例化的时候,必须处理好多个线程同时引用造成的访问限制问题.也就是,很有可能有两个线程同时去调用了这个获取单例的方法,造成了单例被创建了多次，懒汉式单例模式线程安全问题：假如现在有两个线程A和线程B，线程A执行到 this.singletonPattern = new SingletonPattern()，正在申请内存分配，可能需要0.001微秒，就在这0.001微秒之内，线程B执行到if(this.singletonPattern == null)，你说这个时候这个判断条件是true还是false？是true，那然后呢？线程B也往下走，于是乎就在内存中就有两个SingletonPattern的实例了。所以，在编写懒汉式单例模式时，应注意线程安全问题（由全局变量及静态变量引起的），这里可以用互斥同步的方式去解决。（面试可考的地方）

3 饿汉式单例类可以在Java 语言内实现， 但不易在C++ 内实现，因为静态初始化在C++ 里没有固定的顺序，因而静态的m_instance 变量的初始化与类的加载顺序没有保证，可能会出问题。这就是为什么GoF 在提出单例类的概念时，举的例子是懒汉式的。他们的书影响之大，以致Java 语言中单例类的例子也大多是懒汉式的

 

工厂模式

首先需要说一下工厂模式。工厂模式根据抽象程度的不同分为三种：简单工厂模式（也叫静态工厂模式）、这里所讲述的工厂方法模式、以及抽象工厂模式。工厂模式是编程中经常用到的一种模式。它的主要优点有：

• 可以使代码结构清晰，有效地封装变化。在编程中，产品类的实例化有时候是比较复杂和多变的，通过工厂模式，将产品的实例化封装起来，使得调用者根本无需关心产品的实例化过程，只需依赖工厂即可得到自己想要的产品。
• 对调用者屏蔽具体的产品类。如果使用工厂模式，调用者只关心产品的接口就可以了，至于具体的实现，调用者根本无需关心。即使变更了具体的实现，对调用者来说没有任何影响。
• 降低耦合度。产品类的实例化通常来说是很复杂的，它需要依赖很多的类，而这些类对于调用者来说根本无需知道，如果使用了工厂方法，我们需要做的仅仅是实例化好产品类，然后交给调用者使用。对调用者来说，产品所依赖的类都是透明的。

C++实现：

#include 
     
      using namespace std;class IProduct{public:    virtual void productMethod() = 0;};class Product:public IProduct{public:    void productMethod()     {          cout<<"C++ productMethod call"<
      
       CreateProduct();   p->productMethod();   delete p;   return 1;}
      
     

Java实现

interface IProduct {      public void productMethod();  }    class Product implements IProduct {      public void productMethod() {          System.out.println("Java productMethod call");      }  }    interface IFactory {      public IProduct createProduct();  }    class Factory implements IFactory {      public IProduct createProduct() {          return new Product();      }  }    public class Client {      public static void main(String[] args) {          IFactory factory = new Factory();          IProduct prodect = factory.createProduct();          prodect.productMethod();      }  }