设计模式学习前置笔记

一、设计模式常用的七大原则（有些书上是六大原则）：

1、单一职责原则；

2、接口分离原则；

3、依赖倒转原则；

4、里氏替换原则；

5、开闭原则；

6、迪米特法则；

7、合成复用原则。

二、设计模式的作用

1、代码的重用性；

2、可读性；（即编码的规范性）

3、可扩展性；

4、可靠性；（即增加新功能的时候对原有的代码没有影响）

5、高内聚低耦合的特性；

三、七大原则简介

1、单一职责原则
1）基本介绍：对类来说，即一个类应该只负责一项职责。如果A类负责两个职责：职责1和职责2，则当职责1的需求发生改变的时候，可能会造成职责2执行错误。所以应该将A的粒度分为A1,A2.

2)注意事项和细节
a.应该尽可能的降低类的复杂度，一个类只负责一项职责；
b.提高类的可读性和可维护性；
c.降低变更带来的风险；
d.通常情况下，我们应该遵守单一职责原则，但是逻辑足够简单的情况下，才可以再代码级别违反单一职责原则；只有类中的方法足够少的情况下，可以在方法级别保持单一职责原则。

2、接口分离原则
1）客户端不应该依赖它不需要的接口，即一个类应该对另一个类的依赖建立在最小接口上。
2）举例：A、B、C、D实现接口E（E有五个方法1，2，3，4，5），其中A需要1，2，3；B需要4，5；C需要1，4，5；D需要2，3。此时需要将E拆分为E1（方法1）、E2（方法2，3）、E3（方法4，5）三个接口。

3、依赖倒转原则
1）基本介绍
a、高层模块不应该依赖底层模块，两者都应该依赖抽象；
b、抽象不应该依赖细节，细节应该依赖抽象；
c、依赖倒转的中心思想是面向接口编程；
d、依赖倒转的设计理念：相对于细节的多变性，抽象的东西稳定的多。以抽象为基础搭建的框架，比以细节为基础搭建的框架稳定的多，在java中抽象指的是接口或抽象类，细节指的是实现类；
e、使用抽象和接口的目的是制定好规范，不涉及任何具体的操作，把展现细节的任务交给具体的实现类。
2）依赖倒转实现的三种方式
a、接口传递；
b、构造方法传递
c、set方法传递

public class DependecyInversion {

	public static void main(String[] args) {
		
		//1、通过接口传递实现方式
		ChangHong ch = new ChangHong();
		OpenAndClose oc = new OpenAndClose();
		oc.open(ch);
		
		//2、通过构造方法传递依赖
		OpenAndClose2 op2 = new OpenAndClose2(new ChangHong2());
		op2.open();
		
		//3、通过setter方法进行依赖传递
		OpenAndClose3 op3 = new OpenAndClose3();
		op3.setTV(new ChangHong3());
		op3.open();
	}

}

//依赖倒转实现的三种方式
//方式1、通过接口传递实现
interface IOpenAndClose{
	public void open(ITV tv);
}

interface ITV{
	public void play();
}

class OpenAndClose implements IOpenAndClose{
	@Override
	public void open(ITV tv) {
		tv.play();
	}
}

class ChangHong implements ITV{
	@Override
	public void play() {
		System.out.println("长虹电视打开");
	}	
}

//------------------------------------------------------------------------------------------------------------------------
//方式2、通过构造方法进行依赖传递
interface IOpenAndClose2{
	public void open();
}

interface ITV2{
	public void play();
} 

class OpenAndClose2 implements IOpenAndClose2{
	public ITV2 tv;
	OpenAndClose2(ITV2 tv) {
		this.tv = tv;
	}
	public void open() {
		tv.play();
	}
}

class ChangHong2 implements ITV2{
	@Override
	public void play() {
		System.out.println("长虹电视2打开");
	}	
}




//--------------------------------------------------------------------------------
//方式3、通过setter方法传递
interface IOpenAndClose3{
	public void open();
	public void setTV(ITV3 tv);
}

interface ITV3{
	public void play();
} 

class OpenAndClose3 implements IOpenAndClose3{
	public ITV3 tv;

	public void open() {
		tv.play();
	}
	@Override
	public void setTV(ITV3 tv) {
		this.tv = tv;
	}
}

class ChangHong3 implements ITV3{
	@Override
	public void play() {
		System.out.println("长虹电视3打开");
	}	
}

3）依赖倒转原则注意事项和细节
a、底层模块要尽量依赖接口和抽象，或者两者都有，这样程序的稳定性比较好；
b、变量的声明类型尽量是接口或抽象类，这样变量的引用和对象之间会有缓冲区，利于程序的扩展和优化；
c、继承时遵循里氏替换原则。

4、里氏替换原则
1）对继承的思考和说明
a、继承包含这样一层含义，凡是父类中已经实现实现好的方法，实际上是在设定规范和契约，虽然它不强制子类去遵守，但是子类对这些已经实现的类进行任意修改，就会对整个继承体系造成破坏；
b、继承在成程序带来便利的同时，也带来了一些弊端，比如给程序带来了侵入性，降低了程序的可移植性，增加了程序间的耦合性，如果一个父类进行修改，则需要考虑它的所有子类，一旦父类做出修改，可能造成所有子类的使用故障。

2）基本介绍
a、所有引用父类的地方都要能透明的使用其子类对象；
b、里氏替换原则要求子类尽量不要重写父类方法；
c、继承实际上增强了两个类之间的耦合性，一定情况下可以通过聚合和组合的方式解决问题；
d、通常情况下遇到必须要重写父类方法的时候，让原来的父类抽取出来公共方法，再让原来的父类和子类继承这个公告方法。

5、开闭原则
1）基本介绍
a、开闭原则是编程中最基本最重要的设计原则；
b、一个软件实体如类，模块和函数应该对扩展开放（对提供方），对修改关闭（对使用发），用抽象构建架构，用实现扩展细节；
c、当软件需要变化的时候，尽量通过扩展实体的方式来实现变化，而不是修改原有的代码。
d、编程中遵循的其它原则，以及使用设计模式的目的就是遵循开闭原则。

6、迪米特法则（最少知道原则）
1）基本介绍
a、一个对象应该对其他对象保持最少的了解；
b、类与类之间越密切，耦合度越高；
c、只与直接朋友通讯。
2）注意事项和细节
a、迪米特法则要求降低类之间的耦合；
b、降低耦合性，而不是要求完全没有依赖。

7、合成复用原则
1）基本介绍
原则是尽量使用聚合/合成的方式，而不是继承；

四、设计原则核心思想

1、找出应用之中可能变化之处，把他们独立出来，不要和不需要变化的代码混在一块；
2、针对接口编程，而不是针对实现编程；
3、为了交互对象之间的松耦合设计而努力。