Java设计模式系列2-----单例模式,原型模式,建造者模式

1.单例模式

单例模式是一种对象创建性模式,使用单例模式,可以保证为一个类值只生成唯一的实例对象.也就是说,在整个程序空间中,该类只存在一个实例对象.
其实,GoF对单例模式的定义是:保证一个类、只有一个实例存在,同时提供能对该实例加以访问的全局访问方法.

为什么要使用单例模式?
在应用系统开发中,我们常常有以下需求:
/-在多个线程之间,比如servlet环境,共享同一个资源或者操作同一个对象.
/-在整个程序空间使用全局变量,共享资源
/-大规模系统中,为了性能的考虑,需要节省对象的创建时间等等.
因为Singleton模式可以保证为一个类只生成唯一的实例对象,所以这些情况,SIngleto模式就派上用场了.
单例模式实现

1. 饿汉式
2. 懒汉式
3. 双重检查

/*
* 饿汉式   (耗费资源)
*/
public class Person {
	public static final Person person = new Person();
	private String name;	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	//构造函数私有化
	private Person() {
	}
	//提供一个全局的静态方法
	public static Person getPerson() {
		return person;
	}
}

/*
* 懒汉式 (多线程下不安全,会创造多个对象)
* 如果想保证多线程下安全,需要同步
*/
public class Person2 {
	private String name;
	private static Person2 person;
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	//构造函数私有化
	private Person2() {
	}	
//	//提供一个全局的静态方法
//	public static Person2 getPerson() {
//		if(person == null) {
//			person = new Person2();
//		}
//		return person;
//	}
	//提供一个全局的静态方法，使用同步方法
	public static synchronized Person3 getPerson() {
		if(person == null) {
			person = new Person3();
		}
		return person;
	}
}

/*
*双重检查 (节省资源)
*/

public class Person4 {
	private String name;
	private static Person4 person;	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}	
	//构造函数私有化
	private Person4() {
	}	
	//提供一个全局的静态方法
	public static Person4 getPerson() {
		if(person == null) {
			synchronized (Person4.class) {
				if(person == null) {
					person = new Person4();
				}
			}
		}
		return person;
	}
}

2.原型模式

Prototype模式是一种对象创建型模式,它采用复制原型对象的方法来创建对象的实例.使用Prototype模式创建的实例,具有与原型一样的数据.

原型模式的特点
1.由原型对象自身创建目标对象.也就是说,对象创建这一动作发自原型对象本身.
2.目标对象是原型对象的一个克隆.也就是说,通过Prototype模式创建的对象,不仅仅与原型对象具有相同的结构,还与原型对象具有相同的值.
3.根据对象克隆深度层次的不同,有浅度克隆与深度克隆.(区别是是否克隆引用类型)

/*
*实现Cloneable接口,调用clone方法
*/
import java.util.ArrayList;
import java.util.List;

public class Person implements Cloneable{
	// 姓名
	private String name;
	// 年龄
	private int age;
	// 性别
	private String sex;
	//朋友
	private List<String> friends;

	public List<String> getFriends() {
		return friends;
	}

	public void setFriends(List<String> friends) {
		this.friends = friends;
	}

	public String getName() {
		return name;
	}

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

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}
	
	public Person clone() {
		try {
			Person person  = (Person)super.clone();
			List<String> newfriends = new ArrayList<String>();
			for(String friend : this.getFriends()) {
				newfriends.add(friend);
			}
			person.setFriends(newfriends);
			return  person;
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
			return null;
		}
	}

}

原型模式应用场景
/- 在创建对象的时候,我们不只希望被创建的对象继承其基类的基本结构,还希望继承原型对象的数据.
/- 希望对目标对象的修改不影响既有的原型对象(深度克隆的时候可以完全互不影响).
/- 影藏克隆操作的细节.很多时候,对对象本身的克隆需要涉及到类本身的数据细节.

3.建造者模式

Builder模式也叫建造者模式或者生成器模式,是由GoF提出的23中设计模式中的一种.
Builder模式是一种对象创建性模式之一,用来隐藏复合对象的创建过程,它把复合对象的创建过程加以抽象,通过子类继承和重载的方式,动态地创建具有复合属性的对象.

/*
 * 房子
 */
public class House {
	// 地板
	private String floor;
	// 墙
	private String wall;
	// 屋顶
	private String housetop;

	public String getFloor() {
		return floor;
	}

	public void setFloor(String floor) {
		this.floor = floor;
	}

	public String getWall() {
		return wall;
	}

	public void setWall(String wall) {
		this.wall = wall;
	}

	public String getHousetop() {
		return housetop;
	}

	public void setHousetop(String housetop) {
		this.housetop = housetop;
	}
}
/*
 * 工程队
 */
public interface HouseBuilder {
	//修地板
	public void makeFloor();
	//修墙
	public void makeWall();
	//修屋顶
	public void makeHousetop();
	public House getHouse();
}
/*
 * 平房工程队
 */

public class PingFangBuilder implements HouseBuilder {
	House house = new House();
	
	public void makeFloor() {
		house.setFloor("平房-->地板");
	}

	public void makeHousetop() {
		house.setHousetop("平房-->房顶");
	}

	public void makeWall() {
		house.setWall("平房-->墙");
	}

	public House getHouse() {
		return house;
	}

}
/*
 * 公寓工程队
 */
public class GongyuBuilder implements HouseBuilder{
	House house = new House();
	
	public House getHouse() {
		return house;
	}

	public void makeFloor() {
		house.setFloor("公寓-->地板");
	}

	public void makeHousetop() {
		house.setHousetop("公寓-->房顶");
	}

	public void makeWall() {
		house.setWall("公寓-->墙");
	}
	
}
/*
*设计师
*/
public class HouseDirector {	
	
	public void makeHouse(HouseBuilder builder) {
		builder.makeFloor();
		builder.makeWall();
		builder.makeHousetop();
	}
	
}

public class MainClass {

	public static void main(String[] args) {
//		//客户直接造房子
//		House house = new House();
//		house.setFloor("地板");
//		house.setWall("墙");
//		house.setHousetop("屋顶");
		
		
		//由工程队来修
		HouseBuilder builder = new GongyuBuilder();
		//设计者来做
		HouseDirector director = new HouseDirector();
		director.makeHouse(builder);
		
		House house = builder.getHouse();
		System.out.println(house.getFloor());
		System.out.println(house.getWall());
		System.out.println(house.getHousetop());
	}

}

建造者模式应用场景
/- 对象的创建:Builder模式是为对象的创建而设计的模式.
/-创建的是一个复合对象:被创建的对象为一个具有复合属性的复合对象.
/-关注对象创建的各部分的创建过程:不同的工厂(这里指builder生成器)对产品属性有不同的创建方法.