单例模式和工厂模式

1.单例模式（Singleton Pattern）：

         属于创建型模式，涉及到一个单一的类，该类创建了唯一的对象，并提供了访问对象的方式，可直接访问，不需要实例化该类的对象。

注意：
1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例

一、目的：保证一个类仅有一个实例，有效的节省资源

二、主要方法：将构造 变成私有的-->做一个静态的生成对象的方法-->造一个静态的存储对象-->return 静态的对象

三、单例模式的实现方式

懒汉式： 

1。声明一个私有的，静态的本类对象，但并不在声明的时候就初始化，因此，它 的值为null。
2。私有化构造器
3。对外提供一个全局的，共有的，静态的，唯一的方法，用来获得该实例，但注意的是：必须要手动保持线程同步（synchronized）
4.在该方法里，判断对象是否为null，如果是null的话，表示这个类还没有被实例化，就会初始化这个对象，再返回如果不是null的话，就直接返回。
饿汉式：
1.声明一个私有的，静态的本类对象，并在声明的时候就初始化
2.私有构造器
3.对外提供一个全局的，共有的，静态的，唯一的方法，用来获得该实例（饿汉式线程本身就是同步的）
4.在该方法里，直接返回该对象即可
从资源利用效率角度来讲，这个比懒汉式单例类稍微差些。从速度和反应时间角度来讲，则比懒汉式单例类稍好些。

四、实例

创建一个 Singleton 类。
SingleObject.java

饿汉式：

public class SingleObject {

   //创建 SingleObject 的一个对象
   private static SingleObject instance = new SingleObject();

   //让构造函数为 private，这样该类就不会被实例化
   private SingleObject(){}

   //获取唯一可用的对象
   public static SingleObject getInstance(){
      return instance;
   }

   public void showMessage(){
      System.out.println("Hello World!");
   }
}

懒汉式：

class SingleObject {
		private static SingleObject instance;	
		private SingleObject(){}
		public static synchronized SingleObject getInstance() {
			if(instance == null)
				 instance = new SingleObject();
			return instance;
		}
		public void showMessage(){
			System.out.println("Hello World!");
		}
}

从 singleton 类获取唯一的对象。
SingletonPatternDemo.java

public class SingletonPatternDemo {
   public static void main(String[] args) {

      //获取唯一可用的对象
      SingleObject object = SingleObject.getInstance();

      //显示消息
      object.showMessage();
   }
}

2.工厂模式（Factory Pattern）

    属于创建型模式，创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象

一、目的：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类
二、何时使用：不同条件下创建不同实例时使用，解决接口选择的问题
三、实例
1.创建一个接口shape

public interface Shape {
   void draw();
}

2.创建实现接口的实体类
Rectangle.java

public class Rectangle implements Shape {
   public void draw() {
      System.out.println("Inside Rectangle::draw() method.");
   }
}

Square.java

public class Square implements Shape {
   public void draw() {
      System.out.println("Inside Square::draw() method.");
   }
}

Circle.java

public class Circle implements Shape {
   public void draw() {
      System.out.println("Inside Circle::draw() method.");
   }
}

3、创建一个工厂，生成基于给定信息的实体类的对象。
ShapeFactory.java

public class ShapeFactory {
	
   //使用 getShape 方法获取形状类型的对象
   public Shape getShape(String shapeType){
      if(shapeType == null){
         return null;
      }		
      if(shapeType.equalsIgnoreCase("CIRCLE")){
         return new Circle();
      } else if(shapeType.equalsIgnoreCase("RECTANGLE")){
         return new Rectangle();
      } else if(shapeType.equalsIgnoreCase("SQUARE")){
         return new Square();
      }
      return null;
   }
}

4.使用该工厂，通过传递类型信息来获取实体类的对象。

FactoryPatternDemo.java

public class FactoryPatternDemo {

   public static void main(String[] args) {
      ShapeFactory shapeFactory = new ShapeFactory();

      Shape shape1 = shapeFactory.getShape("CIRCLE");
      shape1.draw();

      Shape shape2 = shapeFactory.getShape("RECTANGLE");
      shape2.draw();

      Shape shape3 = shapeFactory.getShape("SQUARE");
      shape3.draw();
   }
}