【设计模式】叩心自问：什么是设计模式？设计模式的目的是什么？设计模式依据哪些（七种）原则设计的？设计模式有哪些？分类？

aas

叩心自问 1 ：设计模式的目的是什么？
叩心自问 2 ：什么是设计模式？
叩心自问 3：设计模式依据哪些（七种）原则设计的？
- 3.1、单一职责原则
- 3.2、接口隔离原则
- 3.3、依赖倒转原则
- 3.4、里氏替换原则
- 3.5、开闭原则
- 3.6、迪米特法则
- 3.7、合成复用原则（Composite Reuse Principle）
叩心自问 4：什么是UML?
- 4.1 UML图分类
叩心自问 5：设计模式分类？

叩心自问 1 ：设计模式的目的是什么？

sadasd编写软件过程中，程序员面临着来自耦合性，内聚性以及可维护性，可扩展性，重用性，灵活性等多方面的挑战，设计模式是为了让程序(软件)，具有更好的：

sadasd①：代码重用性 (即：相同功能的代码，不用多次编写)
sadasd②：可读性 (即：编程规范性, 便于其他程序员的阅读和理解)
sadasd③：可扩展性 (即：当需要增加新的功能时，非常的方便，称为可维护)
sadasd④：可靠性 (即：当我们增加新的功能后，对原来的功能没有影响)

使程序呈现 高内聚，低耦合 的特性。

叩心自问 2 ：什么是设计模式？

sadasd设计模式（design pattern）是对软件设计中 普遍存在（反复出现）的各种问题，所提出的解决方案。这个术语是由埃里希·伽玛（Erich Gamma）等人在1990年代从建筑设计领域引入到计算机科学的。设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理来与之对应，每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因。

叩心自问 3：设计模式依据哪些（七种）原则设计的？

sadasd① ：单一职责原则 sadasd② ：接口隔离原则sadasd③ ：依赖倒转(倒置)原则sadasd④ ：里氏替换原则

sadasd⑤ ：开闭原则sadasd⑥ ：迪米特法则sadasd⑦ ：合成复用原则

3.1、单一职责原则

sadasd对类来说的，即一个类应该只负责一项职责。如类A负责两个不同职责：职责1，职责2。当职责1需求变更而改变A时，可能造成职责2执行错误，所以需要将类A的粒度分解为 A1，A2。

sadasd【注】：通常情况下，我们应当遵守单一职责原则，只有逻辑足够简单，才可以在代码级违反单一职责原则；只有类中方法数量足够少，可以在方法级别保持单一职责原则。

sadasd以交通工具对其进行代码分析：

public class singleresponsibility {public static void main(String[] args) {Vehicle vehicle = new Vehicle();vehicle.run("摩托车");vehicle.run("自行车");vehicle.run("飞机");}
}class Vehicle{  public void run(String vehicle){System.out.println(vehicle+"在陆地上运行...");}
}
-------------------------------------------------------------------------------------------
摩托车在陆地上运行...
自行车在陆地上运行...
飞机在陆地上运行...

sadasd通过上述结果我们就发现违反了单一职责，对代码改进：

public class singleresponsibility {public static void main(String[] args) {Vehicle vehicle = new Vehicle();vehicle.run("摩托车");vehicle.runAir("飞机");vehicle.runWater("潜艇");}
}class Vehicle{public void run(String vehicle){System.out.println("在陆地上运行...");}public void runAir(String vehicle){System.out.println(vehicle+"在天空上运行...");}public void runWater(String vehicle){System.out.println(vehicle+"在水中运行...");}
}
-------------------------------------------------------------------------------------------
在陆地上运行...
飞机在天空上运行...
潜艇在水中运行...

sad通过对原来的类进行修改，这里虽然没有在类这个级别上遵守单一职责原则，但是在方法级别上，仍然是遵守单一职责。

3.2、接口隔离原则

sadasd这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。 还是一个降低类之间的耦合度的意思，从这儿我们看出，其实设计模式就是一个软件的设计思想，从大型软件架构出发，为了升级和维护方便。所以上文中多次出现：降低依赖，降低耦合。
sadasdeg：类A通过接口1依赖类B，类C通过接口1依赖类D，如果接口1对于类A和类C来说不是最小接口，那么类B和D必须去实现他们不需要的方法，这样就违反了接口隔离原则。

package www.wwj.com;public class Sergregation {public static void main(String[] args) {A a = new A();a.depend1(new B());a.depend2(new B());a.depend3(new B());C c = new C();c.depend1(new D());c.depend4(new D());c.depend5(new D());}
}
interface Interface1{void operation1();void operation2();void operation3();void operation4();void operation5();
}
class B implements  Interface1{@Overridepublic void operation1() { System.out.println("B实现了operation1"); }@Overridepublic void operation2() { System.out.println("B实现了operation2"); }@Overridepublic void operation3() { System.out.println("B实现了operation3");}@Overridepublic void operation4() { System.out.println("B实现了operation4");}@Overridepublic void operation5() {System.out.println("B实现了operation5"); }
}
class D implements  Interface1{@Overridepublic void operation1() { System.out.println("D实现了operation1"); }@Overridepublic void operation2() { System.out.println("D实现了operation2");}@Overridepublic void operation3() {System.out.println("D实现了operation3"); }@Overridepublic void operation4() { System.out.println("D实现了operation4");}@Overridepublic void operation5() { System.out.println("D实现了operation5");}
}class A {   //A类通过接口Interface1依赖使用B类，但是只用到1、2、3方法public void depend1(Interface1 i){i.operation1();}public void depend2(Interface1 i){i.operation2();}public void depend3(Interface1 i){i.operation3();}
}class C {   //A类通过接口Interface1依赖使用B类，但是只用到1、4、5方法public void depend1(Interface1 i){i.operation1();}public void depend4(Interface1 i){i.operation4();}public void depend5(Interface1 i){i.operation5();}
}
------------------------------------------------------------------------------------------------
B实现了operation1
B实现了operation2
B实现了operation3
D实现了operation1
D实现了operation4
D实现了operation5

sad改进：我们接口1分成几个独立的接口：

interface Interface1{void operation1();
}
interface Interface2{void operation2();void operation3();
}
interface Interface3{void operation4();void operation5();
}
class B implements  Interface1,Interface2{@Overridepublic void operation1() { System.out.println("B实现了operation1"); }@Overridepublic void operation2() { System.out.println("B实现了operation2"); }@Overridepublic void operation3() { System.out.println("B实现了operation3");}
}
class D implements  Interface1,Interface3{@Overridepublic void operation1() { System.out.println("D实现了operation1"); }@Overridepublic void operation4() { System.out.println("D实现了operation4");}@Overridepublic void operation5() { System.out.println("D实现了operation5");}
}class A {   //A类通过接口Interface1依赖使用B类，但是只用到1、2、3方法public void depend1(Interface1 i){i.operation1();}public void depend2(Interface2 i){i.operation2();}public void depend3(Interface2 i){i.operation3();}
}class C {   //A类通过接口Interface1依赖使用B类，但是只用到1、4、5方法public void depend1(Interface1 i){i.operation1();}public void depend4(Interface3 i){i.operation4();}public void depend5(Interface3 i){i.operation5();}
}

3.3、依赖倒转原则

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

sadasd依赖倒转原则(Dependence Inversion Principle)是指：

sadasd①：高层模块不应该依赖低层模块，二者都应该依赖其抽象
sadasd②：抽象不应该依赖细节，细节应该依赖抽象
sadasd③：依赖倒转(倒置)的中心思想是面向接口编程
sadasd④：依赖倒转原则是基于这样的设计理念：**相对于细节的多变性，抽象的东西要稳定的多。**以抽象为基础搭建的架构比以细节为基础的架构要稳定的多。在java中，抽象指的是接口或抽象类，细节就是具体的实现类。
sadasd⑤：使用接口或抽象类的目的是制定好规范，而不涉及任何具体的操作，把展现细节的任务交给他们的实现类去完成。

sadasd依赖关系传递的三种方式：①、接口传递 ②、构造方法传递 ③、setter方式传递。

sadasd【注】：低层模块尽量都要有抽象类或接口，或者两者都有，程序稳定性更好。变量的声明类型尽量是抽象类或接口, 这样我们的变量引用和实际对象间，就存在一个缓冲层，利于程序扩展和优化。 继承时遵循里氏替换原则。

sadasd代码示例：

package www.wwj.com;public class DependecyInversion {public static void main(String[] args){Person person = new Person();person.receive(new Email());}
}class Email{public String getInfo(){return "电子邮件信息";}
}class Person{public void receive (Email email){System.out.println(email.getInfo());}
}

sadasd改进：如果我们获取的信息不是邮件，而是微信短信等，则还要改Person中对应的方法，所以我们应该引入一个抽象的接口，表示接收者，让Person类与该接口发生依赖，代码如下：

package www.wwj.com;public class DependecyInversion {public static void main(String[] args){Person person = new Person();person.receive(new Email());person.receive(new WeiXin());}
}
interface  IReceive{public String getInfo();
}
class Person{public void receive (IReceive iReceive){System.out.println(iReceive.getInfo());}
}
class Email implements IReceive {public String getInfo(){return "电子邮件信息";}
}
class WeiXin implements IReceive {public String getInfo(){return "微信信息";}
}
------------------------------------------------------------------------------------------------------
电子邮件信息
微信信息

sadasd实现依赖方式 1 : 通过接口传递

package www.wwj.com;public class DependencyPass {public static void main(String[] args) {OpenAndClose openAndClose = new OpenAndClose();openAndClose.open(new ChangHong());}
}interface IopenAndClose{public void open(ITV itv); //抽象方法，接收接口
}
interface ITV{public void play();
}class ChangHong implements ITV{@Overridepublic void play() {System.out.println("长虹电视机打开");}
}
class OpenAndClose implements IopenAndClose{@Overridepublic void open(ITV itv) {itv.play();}
}
------------------------------------------------------------------------------------------------------
长虹电视机打开

sadasd通过上面代码我们可以发现：对于谁能打开电视，还是打开的什么电视，我们都是用接口来表示，然后分别由具体类来实现。

sadasd实现依赖方式 2 : 通过构造方法：

package www.wwj.com;public class DependencyPass {public static void main(String[] args) {OpenAndClose openAndClose = new OpenAndClose(new ChangHong());openAndClose.open();}
}interface IopenAndClose{public void open(); //抽象方法，接收接口
}
interface ITV{public void play();
}class ChangHong implements ITV{@Overridepublic void play() {System.out.println("长虹电视机打开");}
}
class OpenAndClose implements IopenAndClose{private ITV itv;public OpenAndClose(ITV itv) {this.itv = itv;}@Overridepublic void open() {this.itv.play();}
}

sadasd实现依赖方式 3 : 通过setter方法传递：

package www.wwj.com;public class DependencyPass {public static void main(String[] args) {OpenAndClose openAndClose = new OpenAndClose();openAndClose.setTv(new ChangHong());openAndClose.open();}
}interface IopenAndClose{public void open(); //抽象方法，接收接口public void setTv(ITV itv);
}
interface ITV{public void play();
}class ChangHong implements ITV{@Overridepublic void play() {System.out.println("长虹电视机打开");}
}
class OpenAndClose implements IopenAndClose{private ITV itv;@Overridepublic void open() {this.itv.play();}@Overridepublic void setTv(ITV itv) {this.itv=itv;}
}
------------------------------------------------------------------------------------------
长虹电视机打开

3.4、里氏替换原则

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

sa①：所有引用基类的地方必须能透明地使用其子类的对象。
sa②：在使用继承时，遵循里氏替换原则，在子类中尽量不要重写父类的方法
sd③：里氏替换原则告诉我们，继承实际上让两个类耦合性增强了，在适当的情况下，可以通过聚合，组合，依赖来解决问题。

sd【注】：继承在给程序设计带来便利的同时，也带来了弊端。比如使用继承会给程序带来侵入性，程序的可移植性降低，增加对象间的耦合性，如果-一个类被其他的类所继承，则当这个类需要修改时，必须考虑到所有的子类，并且父类修改后，所有涉及到子类的功能都有可能产生故障.

sadasd代码示例：

package www.wwj.com;public class Liskov {public static void main(String[] args) {A1 a1 = new A1();System.out.println("3+8=" + a1.func(3,8));B1 b1 = new B1();System.out.println("8-3="+b1.func(8,3));}
}
class A1{public int func(int i , int j){return i+j;}
}
class  B1 extends  A1{public int func(int i , int j){return i-j;}
}
------------------------------------------------------------------------------------------
3+8=11                  8-3=5

sadasd修改：这时我们应让原来的父类和子类都集成一个更通俗的基类，原有的继承关系去掉，采用依赖，聚合，组合等关系替代：

package www.wwj.com;public class Liskov {public static void main(String[] args) {B1 b1 = new B1();System.out.println("3+8=" + b1.func1(3,8));}
}class Base{//把更加基础的方法和成员加到Base类
}class A1 extends Base{public int func(int i , int j){return i+j;}
}
class  B1 extends  Base{private A1 a1 = new A1();public int func(int i , int j){return i-j;}//若想重新使用A的方法public int func1(int i , int j){return this.a1.func(i , j);}
}
------------------------------------------------------------------------------------------
3+8=11

3.5、开闭原则

sadasd开闭原则（Open Closed Principle）是编程中最基础、最重要的设计原则。

sadasd一个软件实体如类，模块和函数应该对扩展（提供方）开放，对修改(使用方)关闭。用抽象构建框架，用实现扩展细节。

sadasd当软件需要变化时，尽量通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码来实现变化。

sadasd编程中遵循其它原则，以及使用设计模式的目的就是遵循开闭原则。

sadasd代码示例：

package www.wwj.com;public class Ocp {public static void main(String[] args) {Circle circle = new Circle();Rectangle rectangle = new Rectangle();GraphicEditor graphicEditor = new GraphicEditor();graphicEditor.drawShap(circle);graphicEditor.drawShap(rectangle);}
}class GraphicEditor{public void drawShap(Shape s){if(s.m_type == 1){drawRectangle(s);}else if(s.m_type == 2){drawCircle(s);}}public void drawCircle(Shape s){System.out.println("绘制圆形");}public  void drawRectangle(Shape s){System.out.println("绘制三角形");}
}class Shape{int m_type;
}
class Circle extends Shape {Circle(){super.m_type = 2;}
}
class Rectangle extends Shape{Rectangle(){super.m_type = 1;}
}
------------------------------------------------------------------------------------------------------
绘制圆形
绘制三角形

sadasd改进：上述代码虽然好理解，但是违反了开闭原则，因为如果我们想绘制矩形等都需要修改已有的代码，而这时我们应该把Shape形改成抽象类，并提供一个抽象的draw方法，让子类去实现即可。

package www.wwj.com;public class Ocp {public static void main(String[] args) {GraphicEditor graphicEditor = new GraphicEditor();graphicEditor.drawShape(new Circle());graphicEditor.drawShape(new Rectangle());graphicEditor.drawShape(new OtherGraphic());}
}class GraphicEditor{public void drawShape(Shape s){s.draw();}
}abstract class Shape{public abstract void draw();
}
class Circle extends Shape {@Overridepublic void draw() {System.out.println("绘制圆形");}
}
class Rectangle extends Shape{@Overridepublic void draw() {System.out.println("绘制矩形");}
}
//新增
class OtherGraphic extends Shape{@Overridepublic void draw() {System.out.println("绘制其他图形");}
}

3.6、迪米特法则

sadasd①：一个对象应该对其他对象保持最少的了解
sadasd②：类与类关系越密切，耦合度越大
sadasd③：迪米特法则(Demeter Principle)又叫最少知道原则，即一个类对自己依赖的类知道的越少越好。也就是说，对于被依赖的类不管多么复杂，都尽量将逻辑封装在类的内部。对外除了提供的public 方法，不对外泄露任何信息。
sadasd④：迪米特法则还有个更简单的定义：只与直接的朋友通信
sadasd⑤：直接的朋友： 每个对象都会与其他对象有耦合关系，只要两个对象之间有耦合关系，我们就说这两个对象之间是朋友关系。耦合的方式很多，依赖，关联，组合，聚合等。其中，我们称出现成员变量，方法参数，方法返回值中的类为直接的朋友，而出现在局部变量中的类不是直接的朋友。也就是说，陌生的类最好不要以局部变量的形式出现在类的内部。

3.7、合成复用原则（Composite Reuse Principle）

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

叩心自问 4：什么是UML?

sadasdUML——Unified modeling language UML (统一建模语言)，是一种用于软件系统分析和设计的语言工具，它用于帮助软件开发人员进行思考和记录思路的结果。

sadasdUML本身是一套符号的规定，就像数学符号和化学符号一样，这些符号用于描
述软件模型中的各个元素和他们之间的关系，比如类、接口、实现、泛化、依赖、组合、聚合等。
sadadsdsdsdsdsdsdsd

4.1 UML图分类

sadasd①：用例图
sadasd②：静态结构图：类图，对象图，包图，组件图，部署图
sadasd③：动态行为图：交互图（时序图与协作图）、状态图、活动图

sadasd【注】：类图是描述类与类之间的关系的，是UML图中最核心的。类之间的关系有：依赖、泛化（继承）、实现、关联、聚合与组合。

sadasd1、依赖：只要是在类中用到了对方，那么他们之间就存在依赖关系。

sadasd2、泛化（继承）：泛化关系实际上就是继承关系，他是依赖关系的特例。

sadasd3、实现：实现关系实际上就是A类实现B接口，他是依赖关系的特例

sadasd4、关联：关联关系实际上就是类与类之间的联系，他是依赖关系的特例

sadasd5、聚合：聚合关系（Aggregation）表示的是整体和部分的关系，整体与部分可以分开。
sadsdsd
sadasd6、组合：也是整体与部分的关系，但是整体与部分不可以分开。
sadsddsdsdssd

叩心自问 5：设计模式分类？

sadasd总体来说分成三大类：

sadasd根据作用范围来分：