java设计模式

设计模式目的：
代码重用性，
可读性，
可扩展性，
可靠性，
高内聚，低耦合

设计模式基本原则：（设计模式为什么这样设计的原则）
（1）单一职责原则：对类来说，即一个类应该只负责一个职责。如类A负责两个不同职责：职责1，职责2；当职责1需求变更而改变A时，可能造成职责2执行错误，所以需将类A的粒度分解为A1，A2
（2）接口隔离原则：客户端不应该依赖它不需要的接口，即一个类对另一个类的依赖应该建立在最小的接口上。

	public class demo1 {
public static void main(String args[]) {
	A a = new A();
	a.depend1(new B());
}

}

-------------.00000000000-
interface Interface1 {
void operation1();

void operation2();

	}

	interface Interface2 {
	void operation3();
}

class B implements Interface1, Interface2 {
	public void operation1() {
		System.out.println("B");
	}

	public void operation2() {
		System.out.println();
	}

	public void operation3() {
	}
}

class C implements Interface2 {

	public void operation3() {
		System.out.println();
	}
}

class A {
	// 通过接口依赖类B
	public void depend1(Interface1 i) {
		i.operation1();
	}

	public void depend2(Interface1 i) {
		i.operation2();
	}

	public void depend3(Interface2 i) {
		i.operation3();
	}
}

class D {

	public void depend4(Interface2 i) {
		i.operation3();
	}
}

（3）依赖倒转原则：
高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该依赖细节，细节应该依赖抽象；依赖倒转的中心思想是面向接口编程；

  		interface I{
	public void open(F f);
	public void open();
	public void setF(F f2);
}
interface F{
	public void close();
}
class ab implements F{
	public void close(){}
}
class ap implements I{
	//接口传递
	public void open(F f){
		f.close();
	}
	//通过构造器依赖
	public F f1;
	public ap(F f1){
		this.f1=f1;
	}
	//通过setter方法
	public void setF(F f2){
		this.f1=f2;
	}
	
	
	public void open(){
		f1.close();
	}
}

（4）里式替换原则
所有引用基类的的地方必须能透明地使用其子类的对象。如果对每个类型为T1的对象o1，都有类型为T2的对象o2，使得以T1定义的所有程序p在所有的对象o1都代换成o2时，程序p的行为没有发生变化，那么类型T2是类型T1的子类型；
在使用继承时，遵循里式替换原则在子类中尽量不要重写父类的方法
继承实际上让两个类的耦合性增强了，在适当的情况下，可以通过聚合、组合、依赖来解决问题。

		class Base{
	public void fun1(){}
}
class Person1{
	public void fun2(){
		
	}
}
class Person2{
	//使用组合关系使用Person1的方法
	private Person1 p=new Person1();
	public void fun3(){
		p.fun2();
	}
}

（5）开闭原则
一个软件实体如类，模块和函数应该是对扩展开放（对提供方），对修改关闭（对使用方）。用抽象构建框架，用实现扩展细节。
当软件需要变化时，尽量通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码来实现变化。
编程中遵循其他原则，以及使用设计模式的目的就是遵循开闭原则。
（6）迪米特法则
一个对象对其他对象保持最少的了解；
类与类关系越密切，耦合度越大
迪米特原则又称最少知道原则，即一个类对自己依赖的类知道的越少越好；对于被依赖的类不管多么复杂，都尽量将逻辑封装在类的内部，对外处理提供public方法，不对外泄露任何信息
即只与直接的朋友通信，（直接的朋友：每个对象都会与其他对象有耦合关系，只要两个对象之间与耦合关系，这两个对象之间就是朋友关系，耦合的方式有很多，依赖，关联，组合，聚合等，其中，出现在成员变量，方法参数，方法返回值中的类为直接的朋友，而出现在局部变量中的类不是最直接的朋友，）
（7）合成复用原则
原则上使用合成/聚合，而不是使用继承
设计原则核心思想：
找出应用中可能需要变化之处，把他们独立出来，
针对接口编程，而不是针对实现编程
为了交互对象之间的松耦合设计而努力
类与类之间六大关系：
依赖（使用）：在类中用到了对方；可以是类的成员属性，方法的返回类型，方法接受的参数类型，方法中使用的
泛化（继承）：依赖关系的一种特例
实现
关联：依赖关系的特例

	//单向一对一关系
	public class Person{
		private IDCard card;
	}
	public class IDCard{
		
	}
	//双向一对一关系
	public class Person{
		private IDCard card;
	}
	public class IDCard{
		private Person person;
	}

聚合：表示整体和部分的关系，
组合：表示整体与部分之间的关系，两者之间不可分离

	public class Person{
		private IDCard card;//聚合
		private Heard head=new Head();//组合
	}

设计模式分为三种类型：
创建型：单例模式、抽象工厂模式、原型模式、建造者模式、工厂模式
结构型模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式
行为型：模板方法模式、命令模式、访问者模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式

单例模式：采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得对象实例的方法
（1）饿汉式（静态常量）
优缺点：写法较简单，在类装载时就完成实例化避免了线程同步问题；
但如果至始至终都没用到这个实例（可能是其他原因造成类装载，而不是调用getInatance），则会造成内存浪费。

	public class demo1 {
		public static void main(String[] args){
		Singleton instance=Singleton.getInstance();
	}
}
class Singleton{
	//构造器私有化，外部不能new
	private Singleton(){
		
	}
	//本类内部创建对象实例
	private final static Singleton instance=new Singleton();
	//提供一个公有的静态方法，返回实例对象
	public static Singleton getInstance(){
		return instance;
	}
}

(2)饿汉式（静态代码块）
优缺点：同上

	public class demo1 {
	public static void main(String[] args){
		Singleton instance=Singleton.getInstance();
	}
	
}
class Singleton{
	//构造器私有化，外部不能new
	private Singleton(){
		
	}
	//本类内部创建静态变量
	private  static Singleton instance;
	//在静态代码块中创建单例对象
	static{
		instance=new Singleton();
	}
	//提供一个公有的静态方法，返回实例对象
	public static Singleton getInstance(){
		return instance;
	}
}

(3)懒汉式（线程不安全）
优缺点：起到了lazy loading的效果，但是只能在单线程下使用；如果在多线程下，一个线程进入if（Singleton==null）判断语句块中，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例

		public class demo2 {
	Singleton instance=Singleton.getInstance();
}
class Singleton{
	private static Singleton instance;
	private Singleton(){}
	//当使用到该静态方法时才创建instance
	public static Singleton getInstance(){
		if(instance==null){
			instance=new  Singleton();
		}
		return instance;
	}
}

（4）懒汉式（线程安全，同步方法）
优缺点：解决了线程不安全问题，但效率太低了，每个线程在想要获得类的实例时，执行getInstance()方法都要进行同步，而其实这个方法只需执行一次实例化代码，后面的想要获取该类实列，直接return就行了，方法进行同步效率太低

		public class demo2 {
	Singleton instance=Singleton.getInstance();
}
class Singleton{
	private static Singleton instance;
	private Singleton(){}
	//当使用到该静态方法时才创建instance,加入同步处理的代码，
	public static synchronized Singleton getInstance(){
		if(instance==null){
			instance=new  Singleton();
		}
		return instance;
	}
}

（5）懒汉式（线程安全，同步代码块）
优缺点：这种同步并不能起到线程同步的作用，不能用

		public class demo2 {
			Singleton instance=Singleton.getInstance();
		}
		class Singleton{
			private static Singleton instance;
			private Singleton(){}
			//当使用到该静态方法时才创建instance,
			public static  Singleton getInstance(){
				if(instance==null){
					synchronized(Singleton.class){
						instance=new  Singleton();
					}
					
				}
				return instance;
			}
		}

（6）双重检查
优点：线程安全，延迟加载，效率较高，推荐使用

public class demo2 {
	Singleton instance=Singleton.getInstance();
}
class Singleton{
	private static volatile Singleton instance;
	private Singleton(){}
	public static  Singleton getInstance(){
		if(instance==null){
			synchronized(Singleton.class){
				if(instance==null){
					instance=new  Singleton();
				}
			}
		}
		return instance;
	}
}			                                                        

（7）静态内部类
当外部类加载时，静态内部类不会加载，而是在需要实例化时才会装载SingletonInstance，保证了懒加载
类的静态属性只会在第一次类加载时初始化，jvm帮我们保证了线程的安全性，因为在类加载时，别的线程是无法进入的。
推荐使用

public class demo2 {
	Singleton instance=Singleton.getInstance();
}
class Singleton{
	
	private Singleton(){}
	private static class SingletonInstance{
		private static final Singleton instance=new Singleton();
	}
	public static  Singleton getInstance(){
		return SingletonInstance.instance;
	}
}		                                                        

（8）枚举
避免了多线程同步问题，而且还能防止反序列化重新创建新的对象
推荐使用

public class demo1 {
	public static void main(String[] args){
		Singleton instance=Singleton.INSTANCE;
	}
	
}
enum Singleton{
	INSTANCE;
	public void sayOK(){
		
	}
}

单例模式保证了系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能；
适用场景：需要频繁的进行创建和销毁的对象，创建对象时耗时过多或耗费资源过多，但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象

工厂模式
简单工厂模式:定义了一个创建对象的类，由这个类来封装实例化对象的行为，属于创建型模式，
工厂方法模式：定义一个创建对象的抽象方法，由子类决定要实例化的类，