单例模式

设计模式总分类

创建型模式( 5种 )

单例模式
工厂模式
抽象工厂模式
建造者模式
原型模式

结构型模式( 7种 )

适配器模式
桥接模式
装饰模式
组合模式
外观模式
享元模式
代理模式

行为型模式( 11种 )

模版方法模式
命令模式
迭代器模式
观察者模式
中介者模式
备忘录模式
解释器模式
状态模式
策略模式
职责链模式
访问者模式

建造者模式

实质

分离了对象子组件的单独构造(由Builder来负责)和装配(由Director负责)。从而可以构造出复杂的对象。这个模式适用于：某个对象的构建过程复杂的情况下使用。
由于实现了构建和装配的解耦。不同的构建器，相同的装配，也可以做出不同的对象；相同的构建器，不同的装配顺序也可以做出不同的对象。也就是实现了构建算法、装配算法的解耦，实现了更好的复用。

应用场景

StringBuilder类的append方法
SQL中的PreparedStatement
JDOM中，DomBuilder、SAXBuilde
实际开发中，我们所需要的对象构建时，也非常复杂，有很多步骤需要处理时。例如 : 我们要建造一个复杂的产品。比如：神州飞船,Iphone。

演示代码

uml类图

基础类

package ah.szxy.builder;

/**
 * 构建飞船
 * 三个属性 : 轨道舱 发动机 逃逸塔
 * 创建相关的类, 定义其name属性
 */
public class AirShip {
	
	private OrbitalModule orbitalModule;  //轨道舱
	private Engine engine; //发动机
	private EscapeTower escapeTower;  //逃逸塔
	
	
	public void launch(){
		System.out.println("发射！");
	}
	
	
	
	public OrbitalModule getOrbitalModule() {
		return orbitalModule;
	}
	public void setOrbitalModule(OrbitalModule orbitalModule) {
		this.orbitalModule = orbitalModule;
	}
	public Engine getEngine() {
		return engine;
	}
	public void setEngine(Engine engine) {
		this.engine = engine;
	}
	public EscapeTower getEscapeTower() {
		return escapeTower;
	}
	public void setEscapeTower(EscapeTower escapeTower) {
		this.escapeTower = escapeTower;
	}
	
	
	
}

class OrbitalModule{
	private String name;

	public OrbitalModule(String name) {
		this.name = name;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	
}

class Engine {
	private String name;

	public Engine(String name) {
		this.name = name;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	
	
}

class EscapeTower{
	private String name;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public EscapeTower(String name) {
		super();
		this.name = name;
	}
	
}

package ah.szxy.builder;

/**
 * 构建建造飞船抽象方法: 创建引擎 轨道舱 逃逸塔
 * @author chy
 *
 */
public interface AirShipBuilder {
	Engine builderEngine();
	OrbitalModule builderOrbitalModule();
	EscapeTower  builderEscapeTower();
}

package ah.szxy.builder;
/**
 * 组装接口
 * @author chy
 *
 */
public interface AirShipDirector {
	
	/**
	 * 组装飞船对象
	 * @return
	 */
	AirShip   directAirShip();
	
}

建造者类与实现类

package ah.szxy.builder;

/**
 * 建造工厂
 * 实现构造者工厂的三种方法
 * @author chy
 *
 */
public class SxtAirShipBuilder implements AirShipBuilder {
	//StringBuilder, 以后学习XML解析中，JDOM库中的类：DomBuilder,SaxBuilder
	@Override
	public Engine builderEngine() {
		System.out.println("构建发动机！");
		return new Engine("发动机启动！");
	}

	@Override
	public EscapeTower builderEscapeTower() {
		
		System.out.println("构建逃逸塔");
		return new EscapeTower("逃逸塔启动");
	}

	@Override
	public OrbitalModule builderOrbitalModule() {
		System.out.println("构建轨道舱");
		return new OrbitalModule("轨道舱启动");
	}	
	
}

package ah.szxy.builder;
/**
 * 装配实现类
 * 实现装配接口 ,引入构造者实现类
 * 装配引擎 ,调用构造者实现类的构造引擎 ,以此类推
 * 创建一个飞船对象 ,然后获取装配好的东西
 * @author chy
 *
 */
public class SxtAirshipDirector implements AirShipDirector {

	private AirShipBuilder builder;

	public SxtAirshipDirector(AirShipBuilder builder) {
		this.builder = builder;
	}


	@Override
	public AirShip directAirShip() {
		Engine e = builder.builderEngine();
		OrbitalModule o = builder.builderOrbitalModule();
		EscapeTower et = builder.builderEscapeTower();
		
		//装配成飞船对象
		AirShip ship = new AirShip();
		ship.setEngine(e);
		ship.setEscapeTower(et);
		ship.setOrbitalModule(o);
		
		return ship;
	}

}

package ah.szxy.builder;
/**
 * 测试建造者类
 * @author chy
 *
 */
public class Client {
	public static void main(String[] args) {
		
		AirShipDirector director = new SxtAirshipDirector(new SxtAirShipBuilder());

		AirShip ship = director.directAirShip();
		
		System.out.println(ship.getEngine().getName());
		
		ship.launch();
		
	}
}

运行结果

原型模式

实质

通过new产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式。
对应java中的克隆技术，以某个对象为原型，复制出新的对象。显然，新的对象具备原型对象的特点
克隆类似于new，但是不同于new。new创建新的对象属性采用的是默认值。克隆出的对象的属性值完全和原型对象相同。并且克隆出的新对象改变不会影响原型对象。然后，再修改克隆对象的值
优势：效率高(直接克隆，避免了重新执行构造过程步骤) 。

应用场景

spring中作用域声明的一种
javascript语言里面也有prototype,Prototype允许我们在创建对象之后来改变对象或类的行为，并且这些通过prototype属性添加的字段或方法所有对象实例是共享的。详情见 : https://www.jb51.net/article/79549.htm
现实生活中 , 生物的细胞克隆技术

实现方式

Cloneable接口和clone方法 Prototype模式中实现起来最困难的地方就是内存复制操作，所幸在Java中提供了 clone()方法替我们做了绝大部分事情。

演示代码

测试浅克隆/复制

package ah.szxy.prototype;

import java.io.Serializable;
import java.util.Date;

/**
 * 创建羊 ,定义羊的名称
 * 定义克隆方法
 * @author chy
 *
 */
public class Sheep implements Cloneable,Serializable {   
	private String sname;
	private Date birthday;

	
	@Override
	protected Object clone() throws CloneNotSupportedException {
		 //直接调用object对象的clone()方法！
		Object obj = super.clone(); 
		return obj;
	}


	public String getSname() {
		return sname;
	}


	public void setSname(String sname) {
		this.sname = sname;
	}


	public Date getBirthday() {
		return birthday;
	}


	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}


	public Sheep(String sname, Date birthday) {
		super();
		this.sname = sname;
		this.birthday = birthday;
	}
	
	public Sheep() {
	}
	
}

package ah.szxy.prototype;

import java.util.Date;

/**
 * 测试原型模式(浅克隆)
 * 使用带参构造方法创建一个羊,打印其属性
 * 克隆这个羊,打印其属性
 * 对比可知 ,浅克隆只能克隆该对象最后的属性 ,无法克隆最初的属性
 * @author chy
 *
 */
public class Client {
	public static void main(String[] args) throws Exception {
		Date date = new Date(12312321331L);
		Sheep s1 = new Sheep("少利",date);
		System.out.println(s1);
		System.out.println(s1.getSname());
		System.out.println(s1.getBirthday());
		
		date.setTime(23432432423L);
		
		System.out.println(s1.getBirthday());
		
		Sheep s2 = (Sheep) s1.clone();
		s2.setSname("多利");
		System.out.println(s2);
		System.out.println(s2.getSname());
		System.out.println(s2.getBirthday());
		
		
	}
}

测试结果

测试深克隆/复制

package ah.szxy.prototype;

import java.util.Date;


/**
 * 定义深克隆
 * @author 曹海洋
 *
 */
public class Sheep2 implements Cloneable {   //1997,英国的克隆羊，多利！
	private String sname;
	private Date birthday;
	@Override
	protected Object clone() throws CloneNotSupportedException {
		Object obj = super.clone();  //直接调用object对象的clone()方法！	
		//添加如下代码实现深复制(deep Clone)
		Sheep2 s = (Sheep2) obj;
		s.birthday = (Date) this.birthday.clone();  //把属性也进行克隆！	
		return obj;
	}


	public String getSname() {
		return sname;
	}


	public void setSname(String sname) {
		this.sname = sname;
	}
	public Date getBirthday() {
		return birthday;
	}

	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}

	public Sheep2(String sname, Date birthday) {
		super();
		this.sname = sname;
		this.birthday = birthday;
	}
	public Sheep2() {
	}
	
}



package ah.szxy.prototype;

import java.util.Date;

/**
 * 原型模式(深复制)
 * 对比可知 ,深克隆可以克隆最初的属性
 * @author chy
 *
 */
public class Client2 {
	public static void main(String[] args) throws CloneNotSupportedException {
		Date date = new Date(12312321331L);
		Sheep2 s1 = new Sheep2("少利",date);
		Sheep2 s2 = (Sheep2) s1.clone();   //实现深复制。s2对象的birthday是一个新对象！
		
		
		System.out.println(s1);
		System.out.println(s1.getSname());
		System.out.println(s1.getBirthday());
		
		date.setTime(23432432423L);
		
		System.out.println(s1.getBirthday());
		
		
		s2.setSname("多利");
		System.out.println(s2);
		System.out.println(s2.getSname());
		System.out.println(s2.getBirthday());
		
		
		
	}
}

测试结果

序列化方式实现原型模式的深复制

package ah.szxy.prototype;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Date;

/**
 * 原型模式(深复制,使用序列化和反序列化的方式实现深复制)
 * @author chy
 *
 */
public class Client3 {
	public static void main(String[] args) throws CloneNotSupportedException, Exception {
		Date date = new Date(12312321331L);
		Sheep s1 = new Sheep("少利",date);
		System.out.println(s1);
		System.out.println(s1.getSname());
		System.out.println(s1.getBirthday());
		System.out.println("----------------");
		
//		使用序列化和反序列化实现深复制
		ByteArrayOutputStream bos = new ByteArrayOutputStream();
		ObjectOutputStream    oos = new ObjectOutputStream(bos);
		oos.writeObject(s1);
		byte[] bytes = bos.toByteArray();
		
		ByteArrayInputStream  bis = new ByteArrayInputStream(bytes);
		ObjectInputStream	  ois = new ObjectInputStream(bis);
		
		Sheep s2 = (Sheep) ois.readObject();   //克隆好的对象！
		
		System.out.println("修改原型对象的属性值");  
		date.setTime(23432432423L);
		
		System.out.println(s1.getBirthday());
		System.out.println("----------------");
		s2.setSname("多利");
		System.out.println(s2);
		System.out.println(s2.getSname());
		System.out.println(s2.getBirthday());
		
		
	}
}

测试结果

测试原型模式与new 方式在创建大量对象上性能差异

package ah.szxy.prototype;

/**
 * 测试普通new方式创建对象和clone方式创建对象的效率差异！
 * 如果需要短时间创建大量对象，并且new的过程比较耗时。则可以考虑使用原型模式！
 * @author chy
 *
 */
public class Client4 {
	
	public static void testNew(int size){
		long start = System.currentTimeMillis();
		for(int i=0;i<size;i++){
			Laptop t = new Laptop();
		}
		long end = System.currentTimeMillis();
		System.out.println("new的方式创建耗时："+(end-start));
	}
	
	public static void testClone(int size) throws CloneNotSupportedException{
		long start = System.currentTimeMillis();
		Laptop t = new Laptop();
		for(int i=0;i<size;i++){
			Laptop temp = (Laptop) t.clone();
		}
		long end = System.currentTimeMillis();
		System.out.println("clone的方式创建耗时："+(end-start));
	}
	
	
	public static void main(String[] args) throws Exception {	
		testNew(1000);
		testClone(1000);
	}
}


class Laptop implements Cloneable {  //笔记本电脑
	public Laptop() {
		try {
			Thread.sleep(10);  //模拟创建对象耗时的过程!
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	
	@Override
	protected Object clone() throws CloneNotSupportedException {
		Object obj = super.clone();  //直接调用object对象的clone()方法！
		return obj;
	}
	
}

测试结果

牢记原型模式应用场景

短时间大量创建对象时，通过原型模式和普通new方式效率测试可知 ,原型模式效果优异
spring中bean的创建实际就是两种：单例模式和原型模式。（当然，原型模式需要和工厂模式搭配起来）
原型模式很少单独出现，一般是和工厂方法模式一起出现，通过clone 的方法创建一个对象，然后由工厂方法提供给调用者。

创建型模式的总结

模式名称	使用场景
单例模式	保证一个类只有一个实例，并且提供一个访问该实例的全局访问点。
工厂模式	简单工厂模式 , 用来生产同一等级结构中的任意产品。（对于增加新的产品，需要修改已有代码）工厂方法模式 , 用来生产同一等级结构中的固定产品。（支持增加任意产品）抽象工厂模式 , 用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族）
建造者模式	分离了对象子组件的单独构造(由Builder来负责)和装配(由Director负责)。从而可以构造出复杂的对象。
原型模式	通过new产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式

注 : 重点掌握与理解单例模式 , 简单工厂模式 , 原型模式

设计模式之建造者模式与原型模式

单例模式

设计模式总分类

创建型模式( 5种 )

结构型模式( 7种 )

行为型模式( 11种 )

建造者模式

实质

应用场景

演示代码

原型模式

实质

应用场景

实现方式

演示代码

创建型模式的总结