黑马程序员——单例设计模式、装饰设计模式以及享元设计模式

------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

设计模式：对问题行之有效的解决方式。其实它是一种思想。

一、单例设计模式

解决的问题：就是可以保证一个类在内存中的对象唯一性。
必须对于多个程序使用同一个配置信息对象时，就需要保证该对象的唯一性。

那么如何保证对象唯一性呢？

1，不允许其他程序用new创建该类对象。

2，在该类创建一个本类实例。

3，对外提供一个方法让其他程序可以获取该对象。

步骤：

1，私有化该类构造函数。

2，通过new在本类中创建一个本类对象。

3，定义一个公有的方法，将创建的对象返回。

/**
 * 饿汉式
 * 类一加载，对象就已经存在了。
 */
class Single{
	private static Single s = new Single();
	private Single(){}
	public static Single getInstance(){
		return s;
	}
}

/**
 * 懒汉式
 * 类加载进来，没有对象，只有调用了getInstance方法时，才会创建对象。
 * 延迟加载形式。 
 */
class Single2{
	private static Single2 s = null;
	private Single2(){}
	public static Single2 getInstance(){
		if(s==null)
			s = new Single2();
		return s;
	}
}

/**
 * 懒汉式存在线程安全隐患，
 * 解决方案
 * 所以在开发时优先选择饿汉式
 */
class Single3{
	private static Single3 s = null;
	private Single3(){}
	public static Single3 getInstance(){
		if(s==null){
			synchronized (Single3.class) {
				if(s==null){
					s = new Single3();
				}
			}
		}
		return s;
	}
}

二、装饰设计模式

当想要对已有的独享进行功能增强时，可以定义类，将已有的对象传入，基于已经有的功能，并提供加强功能，那么自定义的该类称为装饰类。装饰类通常会通过构造方法接收被装饰的对象，并基于被装饰的对象的功能，提供更强的功能。

装式设计模式比继承灵活，避免了继承体系的臃肿，而且降低了类与类之间的关系。装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过提供了更强的功能，所以装饰类都属于一个体系中。

代码演示，将Person类中的chifan方法增强

public class PersonDemo {

	public static void main(String[] args) {
		Person p = new Person();
//		p.chifan();
		
		NewPerson p1 = new NewPerson(p);
		p1.chifan();
		
		NewPerson2 p2 = new NewPerson2();
		p2.chifan();
	}
}

class Person{
	void chifan(){
		System.out.println("吃饭");
	}
}

//这个类的出现是为了增强Person而出现的。
class NewPerson{
	private Person p ;
	NewPerson(Person p){
		this.p = p;
	}
	public void chifan(){
		System.out.println("开胃酒");
		p.chifan();
		System.out.println("甜点");
	}
}

class NewPerson2 extends Person{
	public void chifan(){
		System.out.println("开胃酒");
		super.chifan();
		System.out.println("甜点");
	}
}

自定义一个装饰类，对BufferedReader类中的ReadLine方法进行增强。

public class MyBufferedReader  {
	
	private Reader r;
		

    	public MyBufferedReader(Reader r) {
		super();
		this.r = r;
	}

	//可以一次读取一行的方法
	 public String myReadLine() throws IOException{
	 	//定义一个临时容器。StringBulider容器，应用于存储字符数组
	 	StringBuilder sb=new StringBuilder();
	 	int ch=0;
	 	while((ch=r.read())!=-1){
	 	<span style="white-space:pre">	</span>if(ch=='\r')
	 			continue;
	 		if(ch=='\n')
	 			return sb.toString();
	 		else
	 			sb.append((char)ch);
	 	}	
	 	if(sb.length()!=0)
	 		return sb.toString();
	 	return null;
	 }
	 	
	 //复写reader中的抽象方法
	 //复写close方法
	 public  void  close() throws IOException{
	 	r.close();
	 }
	 //复写read方法
	 public int read (char[] c,int off,int len) throws IOException{
	 	return r.read(c, off, len);
	 }
}

三、享元设计模式flyweight

享元设计模式是说在一个系统中如果有多个相同的对象，那么只共享一份就可以了，不必每个都去实例化一个对象。比如说一个文本系统，每个字母定一个对象，那么大小写字母一共就是52个，那么就要定义52个对象。如果有一个1M的文本，那么字母是何其的多，如果每个字母都定义一个对象那么内存早就爆了。那么如果要是每个字母都共享一个对象，那么就大大节约了资源。

基本数据的自动装箱与拆箱就会用到这种设计模式（以Integer为例）

		//打印结果true
Integer i1 = 12;
Integer i2 = 12;
System.out.println(i1 == i2);
//打印结果false
Integer i3 = 137;
Integer i4 = 137;
System.out.println(i3 == i4);
/*
 * 若整型对象的值若在-128~127之间，则他们是相等的，因为他们都共享了同一个对象
 * 但若超出这个范围，则不相等，每创建一个整型都需要去实例化
 * 这种设计模式就被称为享元设计模式
 */