设计模式之单例模式

一：设计模式

设计模式简介

设计模式（Design pattern）代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。

设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。项目中合理地运用设计模式可以完美地解决很多问题，每种模式在现实中都有相应的原理来与之对应，每种模式都描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是设计模式能被广泛应用的原因。

简单点说：设计模式是一套被大多数人知晓，经过分类，总结并且被人们反复使用的代码设计。

为什么要用设计模式：为了提高代码的可重用性，让代码更容易让人理解，并且保证代码的可靠性，设计模式
能使我们的编码更加的规范，工程化，简单点理解设计模式就是我们软件工程的基石

设计模式的六大原则:

1、单以职责原则

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

2、理氏替换原则

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

3、依赖倒转原则

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

4、接口隔离原则

这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。它还有另外一个意思是：降低类之间的耦合度。由此可见，其实设计模式就是从大型软件架构出发、便于升级和维护的软件设计思想，它强调降低依赖，降低耦合。
比如有一个接口，有三个子类，这个接口中的方法应该是三个子类都能使用的到。

5、迪米特法则(也叫最少知道原则)

最少知道原则是指：一个实体应当尽量少地与其他实体之间发生相互作用，使得系统功能模块相对独立。
一个类对于自己依赖的类知道的越少越好,也就是说所依赖的类无论多么的复杂,都应该封装在其
方法内部,让外部的类直接调用即可。

6、合成复用原则

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

总原则：开闭原则

对于修改关闭,对于扩充打开。

具体的介绍可以参考链接：
设计模式

二、单例设计模式

为什么需要单例?
当不使用单例设计模式的时候,假如我们在项目中new了100个对象的情况下,10000个人每人访问一次
我们的项目会产生100W个对象,假如1W个人每人访问我们的项目1W次那会产生对少个对象？会产生
100亿个对象,这个时候就很容易出现硬件内存不足的问题(内存溢出)。
如果使用单例设计模式来保证我们每一次程序运行使用的都是同一个对象,那么1W人访问1W次使用的
都是相同的100个对象,这样就避免了内存溢出问题。

单例的写法分为两种：
一：饿汉式(永远吃不饱)
两种常用写法
二：懒汉式(不喊不干活)
三种常用写法
三：枚举
枚举之中,所有无类型的变量都是自身实例化对象,默认全部都是常量,不能被其他访问修饰符修饰,并且默认
是调用自身无参构造,如果需要调用有参构造的话,写法为： 变量名(参数值…),多个自身对象需要用,分割
最后结束的时候需要加上;
无论是懒汉式,还是饿汉式的核心第一要点,都是先私有化构造方法,不让外部直接new对象。

具体代码展示

饿汉写法一：

/**
 * 饿汉模式的一个测试对象
 */
public class XXUtil {
	// 1、私有化构造方法
	private XXUtil() {
	}

	// 2、在类中创建一个自身的静态实例化对象，被static修饰的对象在内存中永远只存在一份
	private static XXUtil xxUtil = new XXUtil();

	// 3、提供一个public方法，用于返回上面的静态对象，让外界见访问
	public static XXUtil getXXUtil() {
		return xxUtil;
	}
}

测试函数

public class TestMainClass {

	public static void main(String[] args) {
		//获得10次xxutil对象
		for (int i = 0; i < 10; i++) {
			//10次的内存地址不相同，证明创建了10个对象
//			System.out.println(new XXUtil());
			//使用饿汉模式的写法一，发现十个对象的地址一样
			System.out.println(XXUtil.getXXUtil());		
		}
	}
}

饿汉模式写法二：

/**
 * 优点：写法简单，由于被static修饰的在内存中只存在一份，所以天生线程安全，并且静态内部类不会
 * 跟随静态成员同时加载，而是在什么时候使用什么时候加载，避免了内存占用的问题
 */
 public class XXUtil2{
 	//1、私有化构造方法
 	private XXUtil2(){
 	}
 	//2、创建一个静态内部类，优点是当加载这个XXUtil2类的时候，不会加载这个类，而是什么时候使用什么时候加载。
 	private static class Sinleton{
 		//3、在静态内部类中声明静态变量
 		private static XXUtil2 xxUtil2= new XXUtil2();
 	}
 	//4、在XXUtil2中提供一个public方法，用户返回静态内部类对象
 	public static XXUtil2 getXXUtil2(){
 		return Sinleton.xxUtil2;
 	}

测试函数：

	public static void main(String[] args) {
		//获得10次xxutil对象
		for (int i = 0; i < 10; i++) {
			//10次的内存地址不相同，证明创建了10个对象
//			System.out.println(new XXUtil());
			//使用饿汉模式的写法二，发现十个对象的地址一样
			System.out.println(XXUtil2.getXXUtil2());		
		}
	}

懒汉模式写法一：

/**
 * 懒汉式一：
 * 在声明的时候不实例化对象，而是什么时候使用，什么时候实例化对象
 * 优点：在不使用的情况下，对象是空的不占用内存
 * 缺点：多线程的情况下，有可能会有多个线程同时进入到if之中，这样就会创建多个对象。
 * @author Administrator
 *
 */
public class XXUtil{
	//1、私有化构造方法
	private XXUtil(){
	}
	//2、懒汉模式在声明的时候不进行实例化
	private static XXUtil xxUtil = null;
	//3、提供实例化对象
	public static XXXUtil getXXUtil(){
		if(xxUtil == null){
			xxUtil = new XXUtil();
		}
		return xxUtil;
	}
}

懒汉模式写法二：

public class XXUtil2 {

	//2、懒汉式在声明的时候不进行实例化
	private static XXUtil2 xxUtil= null;
	//1：私有化构造方法
	private XXUtil2() {
		
	}
	//3、提供实例化对象的方法
	public static synchronized XXUtil2 getXXUtil(){
		if(xxUtil == null){
			xxUtil = new XXUtil2();
		}
		return xxUtil;
	}
}

懒汉模式写法三：

public class XXUtil3 {

	// 2、懒汉式在声明的时候不进行实例化
	private static XXUtil3 xxUtil = null;

	// 1：私有化构造方法
	private XXUtil3() {

	}

	// 3、提供实例化对象的方法  		5个线程执行100次这个方法A,b,c,d,e
	public static XXUtil3 getXXUtil() {

		//所有线程第一次访问的时候xx等于null，进入下面排队，但是第二次访问xx不等于null
		//然后就不进入下面的同步代码块排队了
		if (xxUtil == null) {
			synchronized (XXUtil3.class) {	//第一个线程第一次访问进入到这来那锁
				if (xxUtil == null) {	//第一个线程第一次访问判断xx是null，第二个线程第一个次访问时xx不是null，直接return
					xxUtil = new XXUtil3();	//第一个线程第一次访问new了一个对象
				}
			}
			//第一个线程第一次访问释放了锁
		}
		return xxUtil;
	}
}

枚举
首先要创建一个枚举对象，然后在枚举中创建对象变量使用，具体见下面代码：

public enum XXUtil {
	//这一个句	XXUtil1()	相当于 public static XXUtil xx = new XXUtil();
	XXUtil1(),	//这边声明的变量，实际上就是一个xxutil的实例化对象
	XXUtil2(),	//这边声明的变量，实际上就是一个xxutil的实例化对象
	XXUtil3,	//这边声明的变量，实际上就是一个xxutil的实例化对象
	a();
	public int b;//这个就是一个普通的数字b，因为前面指定了类型
	public void method(){
		System.out.println("枚举的实例的方法");
	}
	private XXUtil() {
		
	}
}

测试代码：

public class MainClass {

	public static void main(String[] args) {
		XXUtil util = XXUtil.XXUtil1;
	}
}