1.创建型模式_接口中 public string pack();-CSDN博客

本文链接：https://blog.csdn.net/caohang103215/article/details/71550416

创建对象同时隐藏创建逻辑的方式，而不是用新的运算符直接实例化对象。这使得判断针对某个给定实例需要创建哪些对象时更加灵活。（多态？）

一、工厂设计模式（Factory Pattern）

创建对象不会客户端暴露创建逻辑，并且使用一个公共接口来指向新创建的对象。

1.创建接口,Shape.java

public interface Shape{
	void  draw();
}

2.创建实现接口实体类

//Rectangle.java 
public class Rectangle implements Shape{
	@override
	public void draw(){
		System.out.println("Rectangle:draw() called");
	}
}
//Square.java
public class Square implements Shape{
	@override
	public void draw(){
		System.out.println("Square:draw() called");
	}
}
//Circle.java
public class Circle implements Shape{
	@override
	public void draw(){
		System.out.println("Square:draw() called");
	}
}

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

public class ShapeFactory{
	public Shape getShape(String shape){
		if(shape==null){
			return null;
		}
		if(shape.equalsIgnoreCase("circle")){
		return new Circle();
		}else if(shape.equalsIgnoreCase("rectangle")){
		return new Rectangle();
		}else if(shape.equalsIgnoreCase("square")){
		return new Square();
		}
	}
}

4.使用工厂类,FactoryShapeDemo.java

public class FactoryShapeDemo{
	ShapeFactory shapeFactory=new ShapeFactory();
	Shape shape1=shapeFactory.getShape("circle");
	Shape shape2=shapeFactory.getShape("rectangle");
	Shape shape3=shapeFactory.getShape("square");
	shape1.draw();
	shape2.draw();
	shape3.draw();
}

二、抽象工厂模式（Abstract Factory Pattern）

超级工厂创建其他工厂。接口只是负责创建一个相关对象的工厂，不需要显示指定他们的类，每个生成的工厂都能按照工厂模式提供对象

1.创建接口//Shape.java

public interface Shape{
	void  draw();
}

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

public class Rectangle implements Shape{
	@override
	public void draw(){
		System.out.println("Rectangle:draw() called");
	}
}
//Square.java
public class Square implements Shape{
	@override
	public void draw(){
		System.out.println("Square:draw() called");
	}
}
//Circle.java
public class Circle implements Shape{
	@override
	public void draw(){
		System.out.println("Square:draw() called");
	}
}

3.创建颜色接口Color.java

public interface Color{
	void fill();
}

4.创建实现接口的实体

//Red.java
public class Red implements Color{
	@override
	public void fill(){
		System.out.println("Red:fill()");
	}
}
//Green.java
public class Green implements Color{
	@override
	public void fill(){
		System.out.println("Green:fill()");
	}
}
//Blue.java
public class Blue implements Color{
	@override
	public void fill(){
		System.out.println("Blue:fill()");
	}
}

5.为Color和Shape对象来创建抽象类获取工厂AbstractFactory.java

public abstract class AbstractFactory{
	abstract Color getColor(String color);
	abstract Shape getShape(String shape);
}

6.创建扩展AbstractFactory工厂类，基于给定信息创建对象.

public class ShapeFactory extends AbstractFactory{
	@override
	public Shape getShape(String shape){
		if(shape==null){
			return null;
		}
		if(shape.equalsIgnoreCase("circle")){
		return new Circle();
		}else if(shape.equalsIgnoreCase("rectangle")){
		return new Rectangle();
		}else if(shape.equalsIgnoreCase("square")){
		return new Square();
		}
		return null;
	}
	@override
	Color getColor(String color){
		return null;
	}
}
public class ColorFactory extends AbstractFactory{
	@override
	public Color getColor(String color){
		if(color==null){
			return null;
		}
		if(color.equalsIgnoreCase("red")){
		return new Red();
		}else if(color.equalsIgnoreCase("green")){
		return new Green();
		}else if(color.equalsIgnoreCase("blue")){
		return new Blue();
		}
		return null;
	}
	@override
	Shpae getShape(String shape){
		return null;
	}
}

7.创建工厂生成器，通过传递形状或颜色来获取工厂FactoryProducer.java

public class FactoryProducer{
	public static AbstractFactory getFactory(String choice){
	if(choice.equalsIgnoreCase（"SHAPE"）){
		return new ShapeFactory();
	}else if(choice.equalsIgnoreCase("COLOR")){
		return new ColorFactory();
	}
	return null;
	}
}

8.使用FactoryProducer来获取AbstractFactroy,通过信息传递来获取实体类对象

public class AbstractFactoryDemo{
	public static void main(String args[]){
		AbstractFactroy shapeFactory=FactoryProducer.getFactoy("shape");
		Shape shape1=shapeFactory.getShape("circle");
		shape1.draw();
		AbstractFactory colorFactroy=FactoryProducer.getFactory("COLOR");
		Color color1=colorFactory.getColor("red");
		color1.fill();
	}
}

三、单例模式（Singleton Pattern）

这种模式设计创建一个单一的类，该类负责创建自己的对象，同事确保只有单个对象被创建。

3.1.懒汉式，线程不安全。

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

3.2.懒汉式，线程安全

能够在多线程很好工作，但是效率很低，99%情况下，不需要同步

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

3.3.饿汉式，线程安全

常用易产生垃圾对象,类加载就初始化，浪费空间。

基于classloader机制避免了线程同步的问题，加载过程很多，getInstance方式或者其他静态方法导致类装载

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

3.4.双检索/双重校验

jdk 1.5起,采用双锁机制，安全且在多线程保持高新能

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

3.5.登记式、静态内部类

和3.3区别：利用singleHolder方式避免classloader加载其他方式。但是如果getInstance方法很耗资源，又不希望在类加载实例化，那么这不合理的。

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

3.6.枚举

JDK1.5起，这是单利模式最佳方式，自动支持序列化机制，防止多次实例化。

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

不建议使用3.1和3.2，建议使用3.3方式
只有明确实现lazy loading方式才使用3.5
如果设计到反序列化创建对象，使用3.6.
考虑第4种双检索方式

四、建造者模式（Builder Pattern）

使用多个简单的对象，一步一步建造成一个复杂对象。一个Builder类会一步一步构造最终的对象。该Builder类是独立于其他对象。

1.创建一个表示食物条目和食物包装的接口。

public interface Packing{
	public String pack();
}
public interface Item{
	public String name();
	public Packing packing();
	public float price();
}

2.创建实现Packing接口实体类Wrapper.java Bottle.java

public class Wrapper implements Packing{
	@override
	public String pack(){
		return "Wrapper";
	}
}
public class Bottle implements Packing{
	@override
	public String pack(){
		return "Bottle";
	}
}

3.创建实现Item抽象对象，对该接口提供默认功能

public abstract class Burger implements Items{
	@override
	public Packing packing(){
		return new Wrapper();
	}
	@override
	public abstract float price();
}
public abstract class ColdDrink implements Item{
	@override
	public Packing packing(){
		return new Bottle();
	}
	@override
	public abstract float price();
}

4.创建扩展Burger和ColdDrink的实体类

public class VegBurger extends Burger{
	@override
	public float price(){
		return 25.0f;
	}
	@override
	public String name(){
		return "Veg" Burger";
	}
}
pubic class ChickenBurger extends Burger{
	@override
	public float price(){
		return 50.5f;
	}
	@override String name(){
		return "Chicken Burger"
	}
}
public class Coke extends ColdDrink{
	@override
	public float price(){
		return 30.0f;
	}
	@override
	public String name(){
		return "Coke";
	}
}
public class Pepsi extends ColdDrink{
	@override
	public void price(){
		return 35.0f;
	}
	@override
	public void name(){
		return "Pepsi"
	}
}

5.创建一个Meal.java，带有上面定义Item对象

public class Meal{
	private List<Item> items=new ArrayList<Item>();
	public void addItem(Item item){
		items.add(item);
	}
	public float getCost(){
		float cost=0.0f;
		for(Item item:items){
			cost+=item.price();
		}
		return cost;
	}
	public void showItems(){
		for(Item item:items){
			System.out.println("Item:"+item.name());
			System.out.println("Item:"+item.packing().pack());
			System.out.println("Item:"+item.price());
		}
	}
}

6.创建一个MealBuilder类，实际builder类负责创建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;
	}
}

7.使用MealBuider来演示建造者模式

public class BuilderPatternDemo{
	public void static main(String[] args){
		MealBuilder mealBuilder =new MealBuilder();
		Meal vegMeal=mealBuilder.prepareVegMeal();
		vegMeal.showItems();
		Meal nonVegMeal=mealBuilder.prepareNonMeal();
		nonVegMeal.showItems();
	}
}

五、原型模式（Prototype Pattern）

创建重复对象，同时保证性能。当创建对象代价较大，可以缓冲该对象，下一个请求时还回它的克隆。

原型模式与通过一个类实例化构造对象不同的是，原型模式是通过拷贝一个现有对象生成新的对象。浅拷贝实现Cloneable。重写，深拷贝是通过实现Serializable读取二进制流。
1.创建一个实现Clone接口抽象类

public abstract class Shape implements Cloneable{
	private String id;
	protect String type;
	abstract void draw();
	public String getType(){
		return type;
	}
	public String getId(){
		return id;
	}
	public void setId(String id){
		this.id=id;
	}
	public Object clone(){
		Object clone=null;
		try{
			clone=super.clone();
		}catch(CloneNotSupportedException e){
			e.printStackTrace();
		}
	}
}

2.创建扩展上面抽象类的实体

public class Rectangle extends Shape{
	public Rectangle(){
		 type="Rectangle"
	}
	@override
	public void draw(){
		System.out.println("Rectangle:draw()");
	}
}
public class Square extends Shape{
	public Square(){
		type="Square";
	}
	@override
	public void draw(){
		System.out.println("Square:draw()");
	}
}
public class Circle extends Shape{
	public Circle(){
		type="Circle";
	}
	public void draw(){
		System.out.println("Circle:draw()");
	}
}

3.创建一个类，从数据库获取实体类，并且他们存储在一个Hashtable中

public class ShapeCache{
	private static Hashtable<String,Shape> shapeMap=new Hashtable<String,Shape>();
	public static Shape getShape(String shapeId){
	Shape cacheShpae =shapeMap.get(shapeId);
	return (Shape)cacheShape.clone();
	}
	//每种形状都运行数据查询，并创建形状
	//shapMap.put(shapekey,shape);
	//添加三种形状
	public static void loadCache(){
		Circle circle=new Circle();
		circle.setId("1");
		shapMap.put(circle.getId(),circle);
		Square square=new Square();
		square.setId("2");
		shapeMap.put(square.getId(),square);
		Rectangle retangle =new Rectangle();
		rectangle.setId("3");
		shapeMap.put(rectangle.getId(),rectangle);
	}
}

4.PrototypePatternDemo使用ShapeCache类获取存储在Hashtabele的形状克隆

public class PrototypePatternDemo{
	public void static main(String[] args){
		ShapeCache.loadCache();
		Shape cloneShape=(Shape)ShapeCache.getShape("1");
		System.out.println("Shape:"+cloneShape.getType());
		Shape cloneShape2=(Shape)ShapeCache.getShape("2");
		System.out.println("Shape:"+cloneShape.getType());
		Shape cloneShape3=(Shape)ShapeCache.getShape("3");
		System.out.println("Shape:"+cloneShape.getType());
	}
}