设计模式之创建型模式

1. 工厂模式【生产对象】

1. 创建接口，然后根据我们传送给工厂的信息来生产我们需要的对象。【生产对象】

2. 工厂模式实现流程

//1. 创建接口
public interface Shape{}

//2. 创建接口实体类
public class Rectangle implements Shape{}
public class Square implements Shape{}
public class Circle implements Shape{}

//3.创建工厂类，生成基于给定信息的实体类的信息
public class ShapeFactory{}

2. 抽象工厂模式【用来生产小工厂的大工厂】

1. 工厂的工厂，先生产工厂，然后再由工厂生产对象。【用来生产小工厂的大工厂】

2. 抽象工厂模式实现流程

// 1. 创建形状和颜色接口
public interface Shape();
public interface Color();

//2.创建接口的实现类
public class Rectangle implements Shape{}
public class Square implements Shape{}
public class Circle implements Shape{}

public class Red implements Color {}
public class Green implements Color {}
public class Blue implements Color {}

//3.为Color和Shape创建抽象类来获取工厂
public abstract class AbstractFactory{}

//4.创建扩展里AbstractFactory的工厂类，基于给定的信息生成实体类的对象
public class ShapeFactory extends AbstratFactory{}  //生成shape的几个实现类
public class ColorFactory extends AbstratFactory{}	//生成color的几个实现类

//5.创建一个工厂创造器，通过传递的信息来获取对应的ShapeFactory 或者 ColorFactory 
public class factoryProducer{}

3. 单例模式【共享同一个对象】

1. 确保只有单个对象被创建【共享同一个对象】

2. 单例模式多个实现方式

• 懒汉式：Lazy初始化

public class Singleton {  
    private static Singleton instance;  
    private Singleton (){}  
  
  	//线程不安全
    public static Singleton getInstance() {  
    if (instance == null) {  
        instance = new Singleton();  
    }  
    //线程安全，但效率低
    //public static synchronized Singleton getInstance() {  
    //if (instance == null) {  
    //    instance = new Singleton();  
    //}  
    return instance;  
    }  
}

• 饿汉式

public class Singleton {  
    private static Singleton instance = new Singleton();  
    private Singleton (){}  
    public static Singleton getInstance() {  
    return instance;  
    }  
}

• 双检索(DCL)

public class Singleton {  
    private volatile static Singleton singleton;  
    private Singleton (){}  
    public static Singleton getSingleton() {  
	    if (singleton == null) {  
	        synchronized (Singleton.class) {  
		        if (singleton == null) {  
		            singleton = new Singleton();  
		        }  
	        }  
	    }  
	    return singleton;  
    }  
}

• 登记式(静态内部类)

public class Singleton {  
    private static class SingletonHolder {  
    	private static final Singleton INSTANCE = new Singleton();  
    }  
    private Singleton (){}  
    public static final Singleton getInstance() {  
    	return SingletonHolder.INSTANCE;  
    }  
}

• 枚举

public enum Singleton {  
    INSTANCE;  
    public void whateverMethod() {}  
}
//Singleton.INSTANCE

4. 建造者模式【一层层的完善】

1. 使用多个简单的对象一步一步的构建成一个复杂的对象。相同的构建过程可以创建不同的表示。【一层层的完善】

2. 建造者模式实现流程

//1. 创建item和packing的接口
public interface Item{public Packing packing()}
public inteface Packing{}

//2. 创建实现packing接口的实现类
public class Wrapper implements Packing{}
public class Bottle implements Packing{}

//3. 创建实现Item接口的抽象类
public abstract class Burger implements Item{
	@Override
	public Packing packing(){
		return new Wrapper();
	}
}
public abstract class ColdDrink implements Item{
	@Override
	public Packing packing(){
		return new Bottle();
	}
}

//4. 创建扩展了Burger和ColdDrink的实体类
public class VegBurger extends Burger{}
public class ChickenBurger extends Burger{}
public class Coke extends ColdDrink{}
public class Pepsi extends ColdDrink{}

//5. 创建一个Meal类，带有上面定义的Item对象
public class Meal {
   private List<Item> items = new ArrayList<Item>();    
   public void addItem(Item item){
      items.add(item);
   }
}

//6. 创建一个MealBuilder类，负责生产Meal对象
public class MealBuilder {
 
   public Meal prepareVegMeal (){
      Meal meal = new Meal();
      meal.addItem(new VegBurger());
      meal.addItem(new Coke());
      return meal;
   }   
 
   public Meal prepareNonVegMeal (){
      Meal meal = new Meal();
      meal.addItem(new ChickenBurger());
      meal.addItem(new Pepsi());
      return meal;
   }
}

5. 原型模式【Hashtable和Cloneable】

1. 用于创建重复的对象，同时又能保证性能。用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。【Hashtable和Cloneable】

2. 原型模式实现流程

//1. 创建一个实现了Cloneable接口的抽象类
//Cloneable是java内置的一个接口
public abstract class Shape implements Cloneable{
	public Object clone() {
		Objec clone = null;
		try{
			clone = super.clone();
		} catch(CloneNotSupportedException e) {
			e.printStackTrace();
		}
		return clone;
	}
}

// 2. 创建Shape抽象类的实体类
public class Rectangle extends Shape{}
public class Square extends Shape {}
public class Circle extends Shape {}

// 3. 创建一个类，从数据库获取到实体类，并把它们存储在一个Hashtable中
public class ShapeCache {
    
   private static Hashtable<String, Shape> shapeMap 
      = new Hashtable<String, Shape>();
 
   public static Shape getShape(String shapeId) {
      Shape cachedShape = shapeMap.get(shapeId);
      return (Shape) cachedShape.clone();
   }
   
   public static void loadCache() {
      Circle circle = new Circle();
      circle.setId("1");
      shapeMap.put(circle.getId(),circle);
 
      Square square = new Square();
      square.setId("2");
      shapeMap.put(square.getId(),square);
 
      Rectangle rectangle = new Rectangle();
      rectangle.setId("3");
      shapeMap.put(rectangle.getId(),rectangle);
   }
}