文章目录
- 引言
- 1.设计模式
- 1.1 设计模式的目的
- 1.2 设计模式六大原则
- 1.2.1 单一职责原则（类、方法和接口，保持职责单一性，如:Activity和Adapter分成两个类）
- 1.2.2. 开闭原则（扩展开放，修改关闭；如：抽离出接口和抽象类，具体实现和功能新增交由实现类完成）
- 1.2.3. 里氏替换原则（描述父类和子类之间的关系，如：子类不修改父类的非抽象方法的代码，子类对扩展功能增加新的方法进行实现）
- 1.2.4. 依赖倒置原则（依赖抽象类或接口，而不是具体实现类对象；如：List list = new ArrayList ()）
- 1.2.5. 接口隔离原则（接口按照功能细分，如:一个接口应该职责单一，而不应该将所有方法封装在一个接口中，否则会重写无用的方法）
- 1.2.6. 迪米特法则(最少知道原则)（类与类之间的亲疏关系，如：两个没有关联的类可以通过第三个代理类来完成通信）
引言
设计模式是我们平时软件开发过程中经常会听到的，那么设计模式有什么作用呢？设计模式有没有什么规范是我们需要遵循的呢？
可重用、可扩展、稳定性、低耦合和高类聚这些都是设计模式的作用。
而单一职责原则、开闭原则、里氏替换原则、依赖倒置原则、接口隔离原则和迪米特法则作为设计模式的六大原则，是我们在编码过程中所要遵守的。
1.设计模式
1.1 设计模式的目的
设计模式是为了让程序，具有更好的：
- 代码可重用性(即:相同功能的代码，不用多次编写)
- 可读性(即:编程规范性，便于其他程序员的阅读和理解)
- 可扩展性(即:当需要增加新的功能时，非常的方便，称为可维护性)
- 可靠性(即:当我们增加新的功能后，对原来的功能没有影响)
- 使程序呈现高内聚,低耦合的特性
1.2 设计模式六大原则
1.2.1 单一职责原则（类、方法和接口，保持职责单一性，如:Activity和Adapter分成两个类）
其核心就是控制类的粒度大小、将对象解耦、提高其内聚性。
- 举例：
RegisterInterface接口中包含了注册和修改手机号方法，很明显，我们可以将这个接口细分成RegisterInterface和UserInfoInterface两个接口；保持其单一职责，同时类和方法也是一样，可以拆分的尽量拆分。- 优点：
- 降低类的复杂度。一个类只负责一项职责，其逻辑肯定要比负责多项职责简单得多。
- 提高类的可读性。复杂性降低，自然其可读性会提高。
- 提高系统的可维护性。可读性提高，那自然更容易维护了。
- 变更引起的风险降低。变更是必然的，如果单一职责原则遵守得好，当修改一个功能时，可以显著降低对其他功能的影响
- 优点：
1.2.2. 开闭原则（扩展开放，修改关闭；如：抽离出接口和抽象类，具体实现和功能新增交由实现类完成）
可以通过“抽象约束、封装变化”来实现实现开闭原则。即通过接口或者抽象类为软件实体定义一个相对稳定的抽象层，而将相同的可变因素封装在相应的具体实现类中。
因为抽象灵活性好，适应性广，只要抽象的合理，可以基本保持软件架构的稳定。而软件中易变的细节可以从抽象派生出来的实现类进行扩展，当软件需求发生变化时，只需要根据需求重新派生出一个实现类来扩展就可以了。
- 举例说明
// 矩形 public class Rectangle { public double getWidth() { return width; } public double getHeight() { return height; } } 需要计算矩形的面积~~~ // 面积计算器 public class AreaCalculator { public double area(Rectangle shape){ return shape.getWidth() * shape.getHeight(); } } 假设这时候，又多了一个圆形类~~~ // 圆形 public class Circular { public double getRadius(){ return radius; } } 同样也需要计算他的面积，这时候就会变成下面这样子：~~~ public class AreaCalculator { public double area(Object shape){ if(shape instanceof Rectangle) { Rectangle rectangle = (Rectangle) shape; return rectangle.getWidth() * rectangle.getHeight(); } else if (shape instanceof Circular) { Circular circular = (Circular) shape; return circular.getRadius() * circular.getRadius() * Math.PI; } else { throw new RuntimeException("There is no such type."); } } } 这么更改完成，完全没有问题。但是在真实的生产环境中，情况更为复杂， 更改涉及的部分较多，那样就可能导致牵一发动全身。 并且，以前编写的经过测试的一些功能需要重新测试，甚至导致某些功能不可用。~~~ 改进版，把计算面积这个公有逻辑变成一个接口：~~~ public interface Shape { public double getArea(); } public class Rectangle implements Shape{ public double getWidth() { return width;] } public double getHeight() { return height; } public double getArea() { return getWidth() * getHeight(); } } 这样，当需求变更，需要计算圆形面积的时候，我们只需创建一个圆形的类， 并实现 Shape 接口即可:~~~ public class Circular implements Shape { public double getRadius(){ return radius; } public double getArea() { return getRadius() * getRadius() * Math.PI; } } 计算三角形面积、四边形面积... 的时候，我们只需让它们去实现 Shape 接口即可， 无需修改原来的代码。~~~
1.2.3. 里氏替换原则（描述父类和子类之间的关系，如：子类不修改父类的非抽象方法的代码，子类对扩展功能增加新的方法进行实现）
里氏替换原则通俗来讲就是：子类可以扩展父类的功能，但不能改变父类原有的功能。也就是说：子类继承父类时，除添加新的方法完成新增功能外，尽量不要重写父类的方法。
根据上述理解，对里氏替换原则的定义可以总结如下：
- 子类可以实现父类的抽象方法，但不能覆盖父类的非抽象方法
- 子类中可以增加自己特有的方法
- 当子类的方法重载父类的方法时，方法的前置条件（即方法的输入参数）要比父类的方法更宽松（
没有理解） - 当子类的方法实现父类的方法时（重写/重载或实现抽象方法），方法的后置条件（即方法的的输出/返回值）要比父类的方法更严格或相等（
没有理解）
注意事项：
通过重写父类的方法来完成新的功能写起来虽然简单，但是整个继承体系的可复用性会比较差，特别是运用多态比较频繁时，程序运行出错的概率会非常大。
1.2.4. 依赖倒置原则（依赖抽象类或接口，而不是具体实现类对象；如：List list = new ArrayList ()）
依赖倒置原则是实现开闭原则的重要途径之一，它降低了客户与实现模块之间的耦合。
由于在软件设计中，细节具有多变性，而抽象层则相对稳定，因此以抽象为基础搭建起来的架构要比以细节为基础搭建起来的架构要稳定得多。这里的抽象指的是接口或者抽象类，而细节是指具体的实现类。
使用接口或者抽象类的目的是制定好规范和契约，而不去涉及任何具体的实现操作，把展现细节的任务交给它们的实现类去完成。
- 依赖倒置原则的作用：
- 可以降低类与类之间的耦合性
- 可以提高系统的稳定性
- 可以减少并行开发引起的风险
- 可以提高代码的可读性和可维护性
- 依赖导致原则的实现方式：
依赖倒置原则的目的是通过面向接口编程来降低类之间的耦合性，所以我们在实际编程中只要遵循以下4点，就能在项目中满足这个规则。- 每个类尽量提供接口或抽象类，或者两者都具备
- 变量的声明类型尽量是接口或者是抽象类
- 任何类都不应该从具体类派生
- 使用继承时尽量遵循里氏替换原则
- 举例说明：
依赖倒置原则在“顾客购物程序”中的应用。 分析：本程序反映了 “顾客类”与“商店类”的关系。商店类中有 sell() 方法， 顾客类通过该方法购物以下代码定义了顾客类通过韶关网店 ShaoguanShop 购物 class Customer { public void shopping(ShaoguanShop shop) { //购物 System.out.println（shop.sell()); } } 但是，这种设计存在缺点，如果该顾客想从另外一家商店（如婺源网店 WuyuanShop）购物， 就要将该顾客的代码修改如下： class Customer { public void shopping(WuyuanShop shop) { //购物 System.out.println(shop.sell()); } } 顾客每更换一家商店，都要修改一次代码，这明显违背了开闭原则。 存在以上缺点的原因是：顾客类设计时同具体的商店类绑定了，这违背了依赖倒置原则。 解决方法是：定义“婺源网店”和“韶关网店”的共同接口 Shop，顾客类面向该接口编程，其代码修改如下： class Customer { public void shopping(Shop shop) { //购物 System.out.println(shop.sell()); } } class Customer { public void shopping(Shop shop) { //购物 System.out.println(shop.sell()); } } 这样，不管顾客类 Customer 访问什么商店，或者增加新的商店，都不需要修改原有代码了，其类如下图所示： 顾客购物程序的类图 程序代码如下： package principle; public class DIPtest{ public static void main(String[] args){ Customer wang = new Customer(); System.out.println("顾客购买以下商品："); wang.shopping(new ShaoguanShop()); wang.shopping(new WuyuanShop()); } } //商店 interface Shop{ public String sell(); //卖 } //韶关网店 class ShaoguanShop implements Shop{ public String sell(){ return "韶关土特产：香菇、木耳……"; } } //婺源网店 class WuyuanShop implements Shop{ public String sell(){ return "婺源土特产：绿茶、酒糟鱼……"; } } //顾客 class Customer{ public void shopping(Shop shop){ //购物 System.out.println(shop.sell()); } } 程序的运行结果如下： 顾客购买以下商品： 韶关土特产：香菇、木耳…… 婺源土特产：绿茶、酒糟鱼……
1.2.5. 接口隔离原则（接口按照功能细分，如:一个接口应该职责单一，而不应该将所有方法封装在一个接口中，否则会重写无用的方法）
目的：为了约束接口、降低类对接口的依赖性；
说明：要为各个类建立它们需要的专用接口，而不要试图去建立一个很庞大的接口供所有依赖它的类去调用。
接口隔离原则和单一职责都是为了提高类的内聚性、降低它们之间的耦合性，体现了封装的思想，但两者是不同的：
- 单一职责原则注重的是职责，而接口隔离原则注重的是对接口依赖的隔离。
- 单一职责原则主要是约束类，它针对的是程序中的实现和细节；接口隔离原则主要约束接口，主要针对抽象和程序整体框架的构建。
接口隔离原则的优点：
接口隔离原则是为了约束接口、降低类对接口的依赖性，遵循接口隔离原则有以下5个优点。
- 将臃肿庞大的接口分解为多个粒度小的接口，可以预防外来变更的扩散，提高系统的灵活性和可维护性。
- 接口隔离提高了系统的内聚性，减少了对外交互，降低了系统的耦合性。
- 如果接口的粒度大小定义合理，能够保证系统的稳定性；但是，如果定义过小，则会造成接口数量过多，使设计复杂化；如果定义太大，灵活性降低，无法提供定制服务，给整体项目带来无法预料的风险。
- 使用多个专门的接口还能够体现对象的层次，因为可以通过接口的继承，实现对总接口的定义。
- 能减少项目工程中的代码冗余。过大的大接口里面通常放置许多不用的方法，当实现这个接口的时候，被迫设计冗余的代码。
接口隔离原则的实现方式：
在具体应用接口隔离原则时，应该根据以下几个规则来衡量。
- 接口尽量小，但是要有限度。一个接口只服务于一个子模块或业务逻辑。
- 为依赖接口的类定制服务。只提供调用者需要的方法，屏蔽不需要的方法。
- 了解环境，拒绝盲从。每个项目或产品都有选定的环境因素，环境不同，接口拆分的标准就不同，深入了解业务逻辑。
- 提高内聚，减少对外交互。使接口用最少的方法去完成最多的事情。
举例说明：
对于接口隔离，大家还是可以参考单一职责提到的示例：
public interface UserService {
public void login(String username, String password);
public void register(String email, String username, String password);
public void logError(String msg);
public void sendEmail(String email);
}
这时候，应该就能理解拆分的好处了。
1.2.6. 迪米特法则(最少知道原则)（类与类之间的亲疏关系，如：两个没有关联的类可以通过第三个代理类来完成通信）
要求限制软件实体之间通信的宽度和深度。
其含义是：
如果两个软件实体无须直接通信，那么就不应当发生直接的相互调用，可以通过第三方转发该调用。其目的是降低类之间的耦合度，提高模块的相对独立性。
迪米特法则的优点：
- 降低了类之间的耦合度，提高了模块的相对独立性。
- 由于亲合度降低，从而提高了类的可复用率和系统的扩展性。
迪米特法则的缺点：
但是，过度使用迪米特法则会使系统产生大量的中介类，从而增加系统的复杂性，使模块之间的通信效率降低。所以，在釆用迪米特法则时需要反复权衡，确保高内聚和低耦合的同时，保证系统的结构清晰。
迪米特法则的实现方法：
- 从依赖者的角度来说，只依赖应该依赖的对象。
- 从被依赖者的角度说，只暴露应该暴露的方法。
迪米特法则使用时的6个注意事项：
- 在类的划分上，应该创建弱耦合的类。类与类之间的耦合越弱，就越有利于实现可复用的目标。
- 在类的结构设计上，尽量降低类成员的访问权限。
- 在类的设计上，优先考虑将一个类设置成不变类。
- 在对其他类的引用上，将引用其他对象的次数降到最低。
不暴露类的属性成员，而应该提供相应的访问器（set 和 get 方法）。- 谨慎使用序列化（
Serializable）功能
代码举例：
明星与经纪人的关系实例。
分析：明星由于全身心投入艺术，所以许多日常事务由经纪人负责处理，
如与粉丝的见面会，与媒体公司的业务洽淡等。
这里的经纪人是明星的朋友，而粉丝和媒体公司是陌生人，所以适合使用迪米特法则，其类图如下图所示。
代码如下：
package principle;
public class LoDtest{
public static void main(String[] args) {
Agent agent=new Agent();
agent.setStar(new Star("林心如"));
agent.setFans(new Fans("粉丝韩丞"));
agent.setCompany(new Company("中国传媒有限公司"));
agent.meeting();
agent.business();
}
}
//经纪人
class Agent{
private Star myStar;
private Fans myFans;
private Company myCompany;
public void setStar(Star myStar){
this.myStar=myStar;
}
public void setFans(Fans myFans){
this.myFans=myFans;
}
public void setCompany(Company myCompany){
this.myCompany=myCompany;
}
public void meeting(){
System.out.println(myFans.getName()+"与明星"+myStar.getName()+"见面了。");
}
public void business(){
System.out.println(myCompany.getName()+"与明星"+myStar.getName()+"洽淡业务。");
}
}
//明星
class Star {
private String name;
Star(String name) {
this.name=name;
}
public String getName() {
return name;
}
}
//粉丝
class Fans {
private String name;
Fans(String name) {
this.name=name;
}
public String getName() {
return name;
}
}
//媒体公司
class Company{
private String name;
Company(String name){
this.name=name;
}
public String getName(){
return name;
}
}
程序的运行结果如下：
粉丝韩丞与明星林心如见面了。
中国传媒有限公司与明星林心如洽淡业务。
参考文章
