目录

• 一、设计模式的目的
• 二、设计模式的七大原则
• • 1.单一职责原则
  • 2.开放-关闭原则

一、设计模式的目的

设计模式的目的是为了提高代码重用性、可读性、可扩展性、可靠性，使得程序呈现出高内聚、低耦合的特性。

• 代码重用性（相同功能的代码，不用多次编写）
• 可读性（编程规范性，便于其他程序员的阅读和理解）
• 可扩展性（当需要增加新的功能时，非常的方便，称为可维护性）
• 可靠性（当我们增加新的功能时，对原来的功能没有影响）
• 使程序呈现高内聚、低耦合的特性
  
  

二、设计模式的七大原则

我们在设计一些设计模式时，一般遵循如下七项基本原则，它们分别是:

1. 单一职责原则 (Single Responsibility Principle)
2. 开放-关闭原则 (Open-Closed Principle)
3. 里氏替换原则 (Liskov Substitution Principle)
4. 依赖倒转原则 (Dependence Inversion Principle)
5. 接口隔离原则 (Interface Segregation Principle)
6. 迪米特法则（Law Of Demeter）
7. 组合/聚合复用原则 (Composite/Aggregate Reuse Principle)

1.单一职责原则

  单一职责原则的核心就是控制类的粒度大小、将对象解耦、提高其内聚性。如果遵循单一职责原则将有以下优点。

• **降低类的复杂度。**一个类只负责一项职责，其逻辑肯定要比负责多项职责简单得多。
• **提高类的可读性。**复杂性降低，自然其可读性会提高。
• **提高系统的可维护性。**可读性提高，那自然更容易维护了。
• **变更引起的风险降低。**变更是必然的，如果单一职责原则遵守得好，当修改一个功能时，可以显著降低对其他功能的影响。

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

  以下假设一个场景并用代码演示（项目代码名称为SRP）：
有一个鸟类，它会飞翔，用一个类描述鸟类飞行这个场景：
创建类Fly.java，代码如下：

public class Fly {public void birds(String birds){System.out.println(birds + "会在空中飞翔");}
}

创建运行类Client.java，代码如下：

public class Client{public static void main(String[] args){Fly fly = new Fly();fly.birds("老鹰");fly.birds("猫头鹰");fly.birds("喜鹊");}
}   

运行结果如下所示：

老鹰会在空中飞翔
猫头鹰会在空中飞翔
喜鹊会在空中飞翔

  在后来发现新问题，并不是所有的鸟类都会飞翔的，比如企鹅就不会了，修改时如果遵循单一职责原则的话，那么需要添加一个类
创建类NoFly.java，代码如下：

public class NoFly {public void birds(String birds){System.out.println("\n");System.out.println(birds + "不会在空中飞翔");}
}

修改运行类Client.java，代码如下：

public class Client{public static void main(String[] args){Fly fly = new Fly();fly.birds("老鹰");fly.birds("猫头鹰");fly.birds("喜鹊");NoFly noFly = new NoFly();noFly.birds("企鹅");}
}  

运行结果如下所示：

老鹰会在空中飞翔
猫头鹰会在空中飞翔
喜鹊会在空中飞翔企鹅不会在空中飞翔

2.开放-关闭原则

  开放封闭原则就是软件实体应该对扩展开放，而对修改封闭。开放封闭原则是所有面向对象原则的核心。软件设计本身所追求的目标就是封装变化，降低耦合，而开放封闭原则正是对这一目标的最直接体现。
  开放封闭原则主要体现在两个方面：

• 对扩展开放，意味着有新的需求或变化时，可以对现有代码进行扩展，以适应新的情况。
• 对修改封闭，意味着类一旦设计完成，就可以独立其工作，而不要对类尽任何修改。

  如果一个软件能够满足 OCP 原则，那么它将有以下两项优点：

1. 能够扩展已存在的系统，能够提供新的功能满足新的需求，因此该软件有着很强的适应性和灵活性。
2. 已存在的模块，特别是那些重要的抽象模块，不需要被修改，那么该软件就有很强的稳定性和持久性

开闭原则的实现方法

1. 通过“抽象约束、封装变化”来实现开闭原则
2. 参数类型,引用对象尽量使用接口或抽象类,而不是现实类;
3. 通过接口或抽象类为软件实体定义一个相对稳定的抽象层，一旦确定就不允许修改;
4. 将相同的变化封装到一个接口或抽象类中;
5. 将不同的变化封装到不同的接口或抽象类中;

  以下假设一个场景并用代码演示（项目代码名称为OCP）：
以商场卖东西为例：
创建类shopping.java，代码如下：

public class Shopping {public static void main(String[] args) {Shop shopping = new Shop();shopping.shop(new Apple());shopping.shop(new Pear());shopping.shop(new Watermelon());}
}class Shop {public void shop(Type s) {if (s.type == 1) {apple(s);} else if (s.type == 2) {pear(s);} else if (s.type == 3) {watermelon(s);}}//出售苹果public void apple(Type r) {System.out.println(" 出售苹果 ");}//出售梨public void pear(Type r) {System.out.println(" 出售梨 ");}//出售西瓜public void watermelon(Type r) {System.out.println(" 出售西瓜 ");}
}class Type {int type;
}class Apple extends Type {Apple() {super.type = 1;}
}class Pear extends Type {Pear() {super.type = 2;}
}class Watermelon extends Type {Watermelon() {super.type = 3;}}

运行结果如下所示：

 出售苹果 出售梨 出售西瓜 

修改代码，改为用OCP原则：
创建代码ShoppingOCP.java，代码如下：

public class ShoppingOCP {public static void main(String[] args) {ShopOCP shopping = new ShopOCP();shopping.shop(new Apple1());shopping.shop(new Pear1());shopping.shop(new Watermelon1());shopping.shop(new Cherry1());}
}class ShopOCP {public void shop(Type1 s) {s.type1();}
}abstract class Type1 {abstract void type1();
}class Apple1 extends Type1 {@Overridevoid type1() {System.out.println(" 出售苹果 ");}
}class Pear1 extends Type1 {@Overridevoid type1() {System.out.println(" 出售梨 ");}
}class Watermelon1 extends Type1 {@Overridevoid type1() {System.out.println(" 出售西瓜 ");}
}class Cherry1 extends Type1 {@Overridevoid type1() {System.out.println(" 出售樱桃 ");}
}

运行结果如下所示：

 出售苹果 出售梨 出售西瓜 出售樱桃 

把创建Type1 类做成抽象类，并提供一个抽象的 type方法，让子类去实现即可，这样我们有新的水果种类时，只需要让新的水果类继承 Type1 ，并实现 type方法即可，使用方的代码就不需要修改了， 从而满足了开闭原则。

以上代码下载请点击该链接：https://github.com/Yarrow052/Java-package.git