设计模式之创建型模式（一）

设计模式的六大原则

1、开闭原则（Open Close Principle）

开闭原则就是说对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。所以一句话概括就是：为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。

2、里氏代换原则（Liskov Substitution Principle）

里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。 里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。 LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。—— From Baidu 百科

3、依赖倒转原则（Dependence Inversion Principle）

这个是开闭原则的基础，具体内容：真对接口编程，依赖于抽象而不依赖于具体。

4、接口隔离原则（Interface Segregation Principle）

这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。还是一个降低类之间的耦合度的意思，从这儿我们看出，其实设计模式就是一个软件的设计思想，从大型软件架构出发，为了升级和维护方便。所以上文中多次出现：降低依赖，降低耦合。

5、迪米特法则（最少知道原则）（Demeter Principle）

为什么叫最少知道原则，就是说：一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。

6、合成复用原则（Composite Reuse Principle）

原则是尽量使用合成/聚合的方式，而不是使用继承。

（上面是摘录的0。0）

创建型模式包括：

Fctory（工厂模式）

Abstract Factory （抽象工厂模式）

 Prototype（原型模式）

Builder（建造者模式）

单例模式

 Factory（工厂模式）

1.意图

  定义一个工厂类，对实现同一接口的类进行实例化。

这里我们以计算为例

1.2普通工厂方法

首先建立一个公共接口：

public interface  Calculate{
	public int calcualte(int a,int b);
}

创建实现类

public class Add implments Calculate{
	public int calculate(int a ,int b){
		return a+b;
	}
}

public class Minus implments Calculate{
	public int calculate(int a,int b){
		return a-b;
	}
}

创建生产类的工厂

public class CalculateFactory{
	public Calculate create(String type){
		if("add".equals(type)){
			return new Add();
		}
		else if ("minus".equals(type)){
			return new Minus();
		}
		eles 
		{
			System.out.println("请输入正确的操作");
		}
	}
}

1.3多个工厂方法

多个工厂方法是对普通工厂方法的改进，在普通工厂方法模式中，如果船体的字符串出错，则不能正确的创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象。

则上面的代码可以改成如下的，对于公共接口以及实现类都不用改变值需改变Factory就可以

public class CalculateFactory{
	public Calculate createAdd(){
		return new Add();
	}
	public Calculate createMinus(){
		return new Minus();
	}
}

1.4静态方法模式，也是我们常用的因为不用产生实例化工厂类

public class CalculateFactory{
	public static Calculate createAdd(){
		return new Add();
	}
	public static Calculate createMinus(){
		return new Minus();
	}
}

AbstractFactory（抽象工厂）

额， 这个模式研究了半天才最终明白的， 希望能互相学习。

工厂模式中有：工厂方法（Factory Method）和抽象工厂(Abstract Factory),这两个模式区别在于需要创建对象的复杂程度上，如果我们创建对象的方法变得复杂了，此时就用到了抽象工厂例如我们现在要生产美国小汽车，美国卡车，和中国小汽车，中国卡车。

先看看我画的类图

测试类

package org.lei.abstractfactory;

public class Test {
	public static void main(String []args){
		//美国牌汽车生产工厂
		AbstractVehicleFactory aFactory = new AmericaFatory();
		//生产美国牌小轿车
		Vehicle acar = aFactory.createCar();
		acar.buildDoor();
		acar.buildEngine();
		//生产美国牌卡车
		Vehicle atrunck = aFactory.creaTrunck();
		
		
		//中国牌汽车生产工厂
		AbstractVehicleFactory chinaFactory = new ChinaFactory();
		//中国牌小轿车
		Vehicle chinaCar  = chinaFactory.createCar();
		//中国牌卡车
		Vehicle chinaTrunck = chinaFactory.creaTrunck();
		
	}
}

测试结果

中间代码太多，我传成资源文件了，不过相信通过上面的类图应该能够明白。如果需要源码可以通过下面的链接去下载

这里就不贴出抱歉。

抽象工厂

Prototype 原型模式

原型模式定义:

用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象，该模式的思想就是将一个对象作为原型，对其进行复制、克隆，产生一个和原对象类似的新对象。

以勺子为例：

package org.lei.server;

public abstract class AbstractSpoon implements Cloneable{
	private String spoonName; 

	public void setSpoonName(String spoonName) {this.spoonName = spoonName;}
	public String getSpoonName() {return this.spoonName;}

	public Object clone(){
		Object object =null;
		try {
			object = super.clone();
		} catch (Exception e) {
			System.out.println("error");
		}
		return object;
		
	}
	@Override
	public String toString() {
		return "AbstractSpoon [spoonName=" + spoonName + "]";
	}
	
}

具体实现

public class SoupSpoon extends AbstractSpoon{
	SoupSpoon(){
		setSpoonName("soup spoon");
	}
}

测试

public static void main(String []args){
		AbstractSpoon abstractSpoon =  new SoupSpoon();
		System.out.println(abstractSpoon.toString());
		AbstractSpoon abstractSpoon2 = (AbstractSpoon)abstractSpoon.clone();
		System.out.println(abstractSpoon2.toString());
		abstractSpoon2.setSpoonName("change spoon");
		System.out.println(abstractSpoon.toString());
	}

结果：

AbstractSpoon [spoonName=soup spoon]
AbstractSpoon [spoonName=soup spoon]
AbstractSpoon [spoonName=soup spoon]

建造者模式Builder

将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。
如何使用：
首先假设一个复杂对象是由多个部件组成的,Builder模式是把复杂对象的创建和部件的创建分别开来,分别用Builder类和Director类来表示.

这里以制造汽车为例

首先定义一个接口用来定义如何创建车的各个部件

public  interface Builder {
	//创建车门
	 void builderDoor();
	//创建车轮
	 void builderWheel();
	//创建
	 void builderEngine();
	//返回最后组装成品结果 (返回最后装配好的汽车)
　　//成品的组装过程不在这里进行,而是转移到下面的Director类中进行.
　　//从而实现了解耦过程和部件
	 Product getResult();
}

复杂对象部件

public interface Part{}

public class Engine implements Part{}

public class Wheel  implements Part{}

public class Door   implements Part{}

复杂对象的产品：

public interface Product{}

public class Car implements Product{
	private Engine engine;
	private Wheel wheel;
	private Door door;
	public Engine getEngine() {
		return engine;
	}
	public void setEngine(Engine engine) {
		this.engine = engine;
	}
	public Wheel getWheel() {
		return wheel;
	}
	public void setWheel(Wheel wheel) {
		this.wheel = wheel;
	}
	public Door getDoor() {
		return door;
	}
	public void setDoor(Door door) {
		this.door = door;
	}
	
}

Builder的具体实现ConcreteBuilder

public class ConcreteBuilder implments Builder{
	Part engine,wheel,door;
	public void builderEngine(){
		//builderEngine的具体实现
		engine = new Engine();
	}
    public void builderWheel(){
		//builderWheel的具体实现
		wheel = new Wheel();
	}
	public void builderDoor(){
		//builderDoor的具体实现
		door = new Door();
	}
	public Product getResult(){
		//
		Product product = new Car();
		product.setWheel(wheel);
		product.setDoor(door);
		product.setEngine(engine);
		return product;
	}
}

用Director构建最后的复杂对象，而在上面的Builder接口封装的是如何创建一个个部件（复杂对象是有这些部件组成的），也就是说Director的内部是如何将不见最后组装成成品的

public class Director{
	private Builder builder;
	Director(builder){
		this.builder = builder;
	}
	//这里是将车轮 方向盘和发动机组装成汽车的过程
	public void construct(){
		builder.builderDoor();
		builder.builderWheel();
		builder.builderEngine();
	}
}

调用

ConcreteBuilder builder = new ConcreteBuilder();
Director director = new director(builder);
director.construct();
Product product = builder.getResult();

singleton（单例模式）

单例定义：

singleton的主要作用是在程序中，一个Class只有一个实例存在在很多操作中，比如建立目录 数据库连接都需要这样的单线程操作。
还有, singleton能够被状态化; 这样，多个单态类在一起就可以作为一个状态仓库一样向外提供服务。

一般使用Singleton的几种方式

public class Singleton {
	private Singleton(){}
	//注意这里的private只供内部调用
	private   static Singleton instance = new Singleton();
	//这里提供了一个供外部访问本class的静态方法，可以直接访问　
	public static Singleton getInstance(){
		return instance;
	}
}

第二种形式

public class Singleton{
	private static Singleton instance = null;
	//注意下面的synchronized很重要，如果没有synchronized
	//,那么使用getInstance()是有可能得到多个Singleton的实例
	public static synchronized Singleton getInstance (){
		if(instance== null){
			instance = new Singleton();
		}
		return instance;
	}
}

一般认为第一种形式更加安全一点。