[Java学习之路篇] 设计原则与设计模式

编程可谓博大精深，按照不同的思路逻辑、框架规范编写出来的程序运行的效率都大相径庭。本篇并不只针对Java程序，应适用于所有编写的程序，是编程世界中的一套方法论，俗称编程套路。它们会出现在目前很多大公司开发常用库的源码中，让整套开发库运行更高效。

1. 六大设计原则

1. 开闭原则 (Open Closed Principle, OCP)

开闭原则简言之就是对拓展开放，对修改关闭。这样可以减少遇到新问题、新需求时对原有代码的修改次数，提高代码的重用率和可维护性。实例有JAVA版本的迭代，对不推荐使用的代码，官方并不会进行删除，而是在不推荐使用的代码划一刀横线，表示不推荐使用，但不会禁止使用。

开闭原则的作用

1. 测试程序可以对拓展部分分块测试，避免了测试局部功能时一定要在功能正常部分的基础上重复测试；
2. 提高代码的重用率；
3. 可以提高软件的可维护性。

2. 单一职责原则 (Single Responsibility Principle, SRP)

单一职责原则是指一个功能模块 (如接口、类、方法) 只负责一类相近事务。如Java中的Arrays工具类只负责与数组操作相关的事务，Collections工具类只负责跟集合相关的事务。

单一职责原则的优点

1. 降低类的复杂度，使得类内部的逻辑更清晰；
2. 提高类的可读性；
3. 提高系统的可维护性；
4. 降低引发风险的可能性，减少局部功能异常对整体的影响。

3. 里氏替换原则 (LIskov Substitution Principle, LSP)

里氏替换原则是针对父子类之间存在创造出来的概念，是指子类可以替代父类，内部藏有四层含义：

1. 子类必须完全实现父类的方法

这条是子类替代父类的必要条件，也符合继承关系的定义。

2. 子类可以增加自己特有的方法

这条有点开闭原则的意思，子类是可以在父类实现功能的基础上，拓展新的、独特的、属于自己本身的功能。

3. 当子类覆盖或实现父类的方法时，方法的输入参数（方法的形参）要比父类方法的输入参数更宽松

这条也是继承所要求的条件，子类方法中接收的参数类型可以是父类方法中参数类型的父类，如父类方法接收String对象，子类方法就可以接收String或Object对象。

4. 当子类覆盖或实现父类的方法时，方法的后置条件（方法的返回值）要比父类更严格

与3相似，子类方法的返回值类型只能是父类方法的返回值类型及其子类。

里氏替换原则的优点

1. 代码共享，减少创建类的工作量，可以在父类的基础上使用相同的功能；
2. 提高代码的重用率；
3. 提高代码的可扩展性；
4. 提供产品或项目的开放性。

里氏替换原则的缺点

1. 继承是侵入性的，只要继承就必须拥有父类的所有方法和属性；
2. 降低了代码的灵活性，子类会被父类的属性和方法所约束；
3. 增加了代码的耦合，一旦属于父类的属性和方法被修改，子类相应的属性和方法也会被影响，可能会发生毁灭性的后果。

以上提到的缺点，促成了java开发出了接口interface这种新 "类型 "，提高了灵活性。

里氏替换原则的作用与意义：

1. 实现开闭原则的重要方式之一；
2. 克服了继承中重写父类造成的可复用性变差的缺点；
3. 使代码不易引入新的错误，因为新的功能是在已有的类的基础上拓展得来的，降低代码出错的可能性。

4. 依赖倒置原则 (Dependence Inversion Principle, DIP)

依赖倒置原则是指编程要面向接口或抽象类，不应该面向实现（具体实现类）。它也是实现开闭原则的重要途径之一，以这种原则进行编程使并行开发成为可能，不同的功能模块之间耦合程度被大大降低。

依赖倒置原则的作用与意义

1. 降低类间的耦合性；
2. 提高了系统的稳定性；
3. 降低了并行开发引起的风险；
4. 提高代码的可读性和可维护性。

依赖倒置原则的实现方法

1. 每个类尽量提供接口或抽象类，或两者兼备；
2. 变量的声明类型尽量使用接口或抽象类；
3. 任何类都不应该从具体类派生；
4. 尽量避免覆写基类的方法；
5. 使用继承时结合里氏替换原则。

5. 接口隔离原则 (Interface Segregation Principle, ISP)

接口隔离原则指的是将庞大臃肿、实现了很多功能的大接口拆分成多个较小的、功能较单一的接口，使得每个小接口之间在功能上是互补的、相互隔离的。

与单一职责原则的区别

1. 单一职责原则注重职责（具体实现的功能），相对底层，而接口隔离原则注重对接口依赖的隔离，相对高层；
2. 单一职责原则主要是约束实现类，针对程序中的实现细节，而接口隔离原则主要是约束接口，针对抽象和程序整体框架的构建。

两者都是为了提高类的内聚性，降低类之间的耦合性，体现封装的思想。

接口隔离原则的优点

1. 将大接口分解为多个粒度小的接口，可以将外来变更的影响隔离起来，提高系统的灵活性和可维护性；
2. 提高系统的内聚性，减少对外交互，降低系统的耦合性；
3. 接口粒度大小合理可以保证系统的稳定性，太小会使系统设计复杂化，太大又会降低系统的灵活性；
4. 使用多个专门的接口可以体现对象的层次，因为接口是可以继承于接口的；
5. 小接口可以避免实现类代码的冗余，避免实现没用的代码。

接口隔离原则的实现方法

1. 接口尽量小，但是又限度，一个接口只服务于一个子模块或业务逻辑；
2. 为依赖接口的类定制服务，只提供调用者需要的方法，屏蔽不需要的方法；
3. 根据不同的环境、项目所需要实现的功能，以不同的标准拆分接口；
4. 提高内聚，减少对外交互，使接口用最少的方法去完成最多的事情。

6. 迪米特法则 (Law of Demeter, LoD)

迪米特法则也叫最少知识原则 (Least Knowledge Principle, LKP)，是指一个对象与其他对象应尽量保持较少的联系，减少耦合。因为类之间的耦合越弱，越有利于复用。一个处于弱耦合的类被修改，不会对有关系的类造成影响，其中信息的隐藏就促进了程序的复用。
对象与对象之间的联系称为朋友关系，这种耦合关系包括以下几类：

1. 当前对象本身（this）
2. 当前对象的方法参数（以形式参数形式传入到当前对象方法中的对象）
3. 当前对象的成员对象（属性）
4. 当前集合对象中的元素
5. 当前对象所创建的对象

迪米特法则的实现方法

迪米特法则的核心在于尽量减少对象之间的耦合关系，可以通过使用中介类的对象，以间接关系代替直接关系，从而减少一个对象的更改对另一个对象造成的影响。使用迪米特法则需要强调一下两点：

1. 从依赖者（即中介类）的角度来说，只依赖应该依赖的对象；
2. 从被依赖者（即需要与其他类建立联系的类）的角度来说，只暴露应该暴露的方法（即不需要开放给其它类使用的方法和属性都用private或protected修饰）。

运用迪米特法则还需要注意一下6点：

1. 在类的划分上，应尽量创建弱耦合的类；
2. 在类的结构设计上，应尽量降低类成员的访问权限；
3. 在类的设计，优先考虑将一个类设置成不变类；
4. 在对其他类的引用上，将引用其它对象的次数降到最低；
5. 不暴露类的属性成员，而应该提供相应的访问器（set和get方法）；
6. 谨慎使用序列化（Serializable）功能。

迪米特法则的优点

• 降低了类之间的耦合度，提高了模块的相对独立性。
• 由于亲和度降低，从而提高了类的可复用率以及系统的扩展性。

迪米特法则的缺点

• 若过度使用该法则，会导致系统中产生大量的中介类，这会增加系统的复杂度，使模块之间的通信效率降低。

小结

以上六种设计原则并不是简单的并列关系，而是以开闭原则为核心，原则之间相互依存而各不相同，从编程宗旨的角度，提高了程序的可扩展性和运行效率。其实，这六种设计模式已经在面向对象的程序设计中有了充分的体现，它们只是高级工程师们提炼出来的经验，作为评判程序高效性的标准。以下是按本人的理解画出的设计原则之间的关系图：

2. 设计模式

设计模式是解决问题的方案，学习现有的设计模式可以做到经验复用。拥有设计模式词汇，在沟通时就能用更少的词汇来讨论，并且不需要了解底层细节。
设计模式分为三种类型：创建型、行为型、结构型。

创建型

1. 单例 Singleton

确保一个类只有一个实例，并提供该实例的全局访问点。
使用一个私有构造函数、一个私有静态变量以及一个公有静态函数来实现。

使用场景：

• Logger Classes
• Configuration Classes
• Factories implemented as Singletons（Spring）
• java.lang.Runtime#getRuntime()
• java.awt.Desktop#getDesktop()
• java.lang.System#getSecurityManager()

六种实现方式：

1. 懒汉式-线程不安全
   只有第一次调用公有静态函数获取单例对象时才创建对象，之后均返回这个已经创建的对象。
   缺点：线程不安全，多线程调用时会产生多个对象。

   public class Singleton {
        
   	private static Singleton uniqueInstance;
   	
   	private Singleton() {
        }
   	
   	public static Singleton getUniqueInstance() {
        
   		if (uniqueInstance == null) {
        
   			uniqueInstance = new Singleton();
   		}
   		return uniqueInstance;
   	}
   }
   

2. 饿汉式-线程安全
   声明静态单例对象时就直接创建对象。
   缺点：占用空间，失去延迟实例化带来节约资源的好处。

   public class Singleton {
        
   	private static Singleton uniqueInstance = new Singleton();
   	
   	private Singleton() {
        }
   	
   	public static Singleton getUniqueInstance() {
        
   		return uniqueInstance;
   	}
   }
   

3. 懒汉式-线程安全
   在1.的基础上在公有静态函数上加锁(synchronized)，改善了1.中产生的问题。
   缺点：多个线程获取对象时会产生阻塞的情况，大大降低了效率。

   public class Singleton {