设计模式：七大设计原则

设计模式是为了让程序具有更好的

代码重用性（相同功能的代码，不用多次编写）

可读性（编程规范性，便于其他程序员的阅读和理解）

可扩展性（当需要增加新的功能时，非常的方便，称为可维护）

可靠性（当我们增加新的功能后，对原来的功能没有影响）

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

一、单一职责

1、基本介绍

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

2、注意事项和细节

降低类的复杂度，一个类只负责一项职责。

提高类的可读性，可维护性。

降低变更引起的风险。

通常情况下，我们应当遵守单一职责原则（一个类只负责一项职责）。只有在逻辑足够简单，才可以在代码级违反单一职责原则；只有类中方法数量足够少，才可以在方法级别保持单一原则。（可参照代码Demo3）

3、代码实现案例

（1）Demo1（违反了单一职责原则）
  1. package com.dashu.principle.single_responsibility;
  3. public class SinglenessDemo {
  5.     public static void main(String[] args) {
  6.         Vehicle vehicle = new Vehicle();
  7.         vehicle.run("汽车");
  8.         vehicle.run("飞机");
  9.         vehicle.run("轮船");
  10.     }
  13. }
  16. /**
  17.  * 问题：
  18.  * 在该Demo中，类Vehicle违反了单一职责原则。包含了同时在三中场景运行的交通工具（水路空）;同时汽车和轮船不应该在公路上运行
  19.  * <p>
  20.  * 解决：
  21.  * 遵守单一职责原则。根据交通工具运行场景不同，分解成不同的类。
  22.  */
  24. /**
  25.  * 交通工具
  26.  */
  27. class Vehicle {
  29.     public void run(String vehicle) {
  30.         System.out.println(vehicle + "在公路上运行。。。");
  31.     }
  33. }

（2）Demo2（采用单一职责原则）
  1. package com.dashu.principle.single_responsibility;
  3. public class SinglenessDemo {
  5.     public static void main(String[] args) {
  6.         RoadVehicle roadVehicle = new RoadVehicle();
  7.         roadVehicle.run("汽车");
  8.         AirVehicle airVehicle = new AirVehicle();
  9.         airVehicle.run("飞机");
  10.         WaterVehicle waterVehicle = new WaterVehicle();
  11.         waterVehicle.run("轮船");
  12.     }
  15. }
  18. /**
  19.  * 问题：
  20.  * 在该Demo中，遵守了单一职责原则
  21.  * 但是这样做的改动很大（Demo逻辑很简单），即将类分解了，同时修改客户端
  22.  * <p>
  23.  * 解决：
  24.  * 直接修改Vehicle类，在方法层级上实现单一职责原则
  25.  */
  27. /**
  28.  * 道路交通工具
  29.  */
  30. class RoadVehicle {
  32.     public void run(String vehicle) {
  33.         System.out.println(vehicle + "在公路上运行。。。");
  34.     }
  36. }
  38. /**
  39.  * 天空交通工具
  40.  */
  41. class AirVehicle {
  43.     public void run(String vehicle) {
  44.         System.out.println(vehicle + "在天空中运行。。。");
  45.     }
  47. }
  49. /**
  50.  * 水上交通工具
  51.  */
  52. class WaterVehicle {
  54.     public void run(String vehicle) {
  55.         System.out.println(vehicle + "在水上运行。。。");
  56.     }
  58. }

（3）Demo3（方法级别单一原则）
  1. package com.dashu.principle.single_responsibility;
  3. public class SinglenessDemo {
  5.     public static void main(String[] args) {
  6.         AllVehicle vehicle = new AllVehicle();
  7.         vehicle.run("汽车");
  8.         vehicle.runAir("飞机");
  9.         vehicle.runWater("轮船");
  10.     }
  13. }
  16. /**
  17.  * 这种修改方法没有对原来的类做出大的修改，只是增加方法
  18.  * 这里虽然没有在类这个级别上遵守单一职责原则，但是在方法上，任然遵守单一职责
  19.  */
  21. /**
  22.  * 交通工具
  23.  */
  24. class AllVehicle {
  26.     public void run(String vehicle) {
  27.         System.out.println(vehicle + "在公路上运行。。。");
  28.     }
  30.     public void runAir(String vehicle) {
  31.         System.out.println(vehicle + "在天空中运行。。。");
  32.     }
  34.     public void runWater(String vehicle) {
  35.         System.out.println(vehicle + "在水上运行。。。");
  36.     }
  38. }

二、接口隔离原则

1、基本介绍

一个类对另外一个类的依赖应该建立在最小接口上。

2、案例

3、改进

4、代码实现案例

（1）Demo1（违反接口隔离原则）
  1. /**
  2.  * 接口F
  3.  */
  4. public interface F {
  5.     public void a();
  6.     public void b();
  7.     public void c();
  8.     public void d();
  9.     public void e();
  10. }
  1. /**
  2.  * 接口F实现类A
  3.  */
  4. public class A implements F {
  5.     @Override
  6.     public void a() {
  8.     }
  10.     @Override
  11.     public void b() {
  13.     }
  15.     @Override
  16.     public void c() {
  18.     }
  20.     @Override
  21.     public void d() {
  23.     }
  25.     @Override
  26.     public void e() {
  28.     }
  29. }
  1. /**
  2.  * 接口F实现类B
  3.  */
  4. public class B implements F {
  5.     @Override
  6.     public void a() {
  8.     }
  10.     @Override
  11.     public void b() {
  13.     }
  15.     @Override
  16.     public void c() {
  18.     }
  20.     @Override
  21.     public void d() {
  23.     }
  25.     @Override
  26.     public void e() {
  28.     }
  29. }
  1. public class C {
  3.     /**
  4.      * 类C依赖接口F，使用了abc三个方法
  5.      */
  6.     public void test() {
  7.         F f = new A();
  8.         f.a();
  9.         f.b();
  10.         f.c();
  11.     }
  13. }
  1. public class D {
  4.     /**
  5.      * 类D依赖接口F，使用了ade三个方法
  6.      */
  7.     public void test() {
  8.         F f = new B();
  9.         f.a();
  10.         f.d();
  11.         f.e();
  12.     }
  15. }

（2）Demo2（采用接口隔离原则）
  1. /**
  2.  * 接口F
  3.  */
  4. public interface F {
  5.     public void a();
  6. }
  1. /**
  2.  * 接口G
  3.  */
  4. public interface G {
  5.     public void b();
  6.     public void c();
  7. }
  1. /**
  2.  * 接口H
  3.  */
  4. public interface H {
  5.     public void d();
  6.     public void e();
  7. }
  1. /**
  2.  * 接口F,G实现类A
  3.  */
  4. public class A implements F, G {
  5.     @Override
  6.     public void a() {
  8.     }
  10.     @Override
  11.     public void b() {
  13.     }
  15.     @Override
  16.     public void c() {
  18.     }
  21. }
  1. /**
  2.  * 接口F,H实现类B
  3.  */
  4. public class B implements F,H {
  5.     @Override
  6.     public void a() {
  8.     }
  10.     @Override
  11.     public void d() {
  13.     }
  15.     @Override
  16.     public void e() {
  18.     }
  19. }
  1. public class C {
  3.     /**
  4.      * 类C依赖接口F,G。使用了abc三个方法
  5.      */
  6.     public void test() {
  7.         F f = new A();
  8.         G g = new A();
  9.         f.a();
  10.         g.b();
  11.         g.c();
  12.     }
  14. }
  1. public class D {
  4.     /**
  5.      * 类C依赖接口F,H。使用了ade三个方法
  6.      */
  7.     public void test() {
  8.         F f = new B();
  9.         H h = new B();
  10.         f.a();
  11.         h.d();
  12.         h.e();
  13.     }
  14. }

三、依赖倒转原则

1、基本介绍

依赖倒转原则是指：

  • 高层模块不应该依赖低层模块，二者都应该依赖其抽象
  • 抽象不应该依赖细节，细节应该依赖抽象
  • 依赖倒转的中心思想就是面接接口编程

设计理念：相对于细节的多变性，抽象的东西要稳定得多。以抽象为基础搭建的架构比以细节为基础的架构要稳定得多。在java中，抽象指的就是接口和抽象类，细节就是具体的实现类

使用接口或抽象类的目的就是为了制定好规范，而不涉及任何具体的操作，把展现细节的任务交给他们的实现类去完成。

2、案例

3、改进

4、代码实现案例

（1）Demo1（违反依赖倒转原则）
  1. public class QQ {
  3.     public void message(){
  4.         System.out.println("QQ消息");
  5.     }
  7. }
  1. public class WX {
  3.     public void message(){
  4.         System.out.println("微信消息");
  5.     }
  7. }
  1. public class Email {
  3.     public void message(){
  4.         System.out.println("Email消息");
  5.     }
  7. }
  2. public class User {
  5.     public void receive(QQ qq){
  6.         qq.message();
  7.     }
  9.     public void receive(WX wx){
  10.         wx.message();
  11.     }
  13.     public void receive(Email email){
  14.         email.message();
  15.     }
  17. }
  1. public class Client {
  3.     public static void main(String[] args) {
  5.         User user = new User();
  6.         user.receive(new QQ());
  7.         user.receive(new WX());
  8.         user.receive(new Email());
  10.     }
  12. }

（2）Demo2（遵循依赖倒转原则）
  1. public interface Message {
  2.     void message();
  3. }
  1. public class QQ implements Message{
  3.     @Override
  4.     public void message(){
  5.         System.out.println("QQ消息");
  6.     }
  8. }
  1. public class WX implements Message{
  3.     @Override
  4.     public void message(){
  5.         System.out.println("微信消息");
  6.     }
  8. }
  1. public class Email implements Message{
  3.     @Override
  4.     public void message(){
  5.         System.out.println("Email消息");
  6.     }
  8. }
  1. public class User {
  3.     public void receive(Message message) {
  4.         message.message();
  5.     }
  7. }
  1. public class Client {
  3.     public static void main(String[] args) {
  5.         User user = new User();
  6.         user.receive(new QQ());
  7.         user.receive(new WX());
  8.         user.receive(new Email());
  10.     }
  12. }

5、比对

当我们想要接收短信类型的消息时，Demo1不仅需要添加一个短信类型的消息类（Note），同时也要再在User类中添加一个用于接收短信类型的方法

  1. public void receive(Note note){
  2.     note.message();
  3. }

而Demo2中，我们只需要添加一个短信类型的消息类（Note),并实现接口Message

6、依赖关系传递的三种方式

（1）通过接口传递依赖
  1. public interface OpenAndClose {
  2.     void open(Tv tv);
  3. }
  1. public class OpenAndCloseImpl implements OpenAndClose{
  2.     @Override
  3.     public void open(Tv tv) {
  4.         tv.play();
  5.     }
  6. }
  1. public interface Tv {
  2.     void play();
  3. }
  1. public class ChangHong implements Tv{
  2.     @Override
  3.     public void play() {
  4.         System.out.println("长虹电视机，打开");
  5.     }
  6. }
  1. /**
  2.  * 通过接口传递依赖
  3.  */
  4. public class Client {
  5.     public static void main(String[] args) {
  6.         ChangHong changHong = new ChangHong();
  7.         OpenAndClose openAndClose = new OpenAndCloseImpl();
  8.         openAndClose.open(changHong);
  9.     }
  10. }

（2）通过构造方法传递依赖
  1. public interface OpenAndClose {
  2.     void open();
  3. }
  1. public class OpenAndCloseImpl implements OpenAndClose {
  3.     private Tv tv;
  5.     public OpenAndCloseImpl(Tv tv){
  6.         this.tv = tv;
  7.     }
  9.     @Override
  10.     public void open() {
  11.         tv.play();
  12.     }
  13. }
  1. public interface Tv {
  2.     void play();
  3. }
  1. public class ChangHong implements Tv {
  2.     @Override
  3.     public void play() {
  4.         System.out.println("长虹电视机，打开");
  5.     }
  6. }
  1. /**
  2.  * 通过构造方法传递依赖
  3.  */
  4. public class Client {
  5.     public static void main(String[] args) {
  6.         ChangHong changHong = new ChangHong();
  7.         OpenAndClose openAndClose = new OpenAndCloseImpl(changHong);
  8.         openAndClose.open();
  9.     }
  10. }

（3）通过setter方法传递依赖
  1. public interface OpenAndClose {
  2.     void open();
  3.     void setTv(Tv tv);
  4. }
  1. public class OpenAndCloseImpl implements OpenAndClose {
  3.     private Tv tv;
  5.     @Override
  6.     public void open() {
  7.         tv.play();
  8.     }
  10.     @Override
  11.     public void setTv(Tv tv) {
  12.         this.tv = tv;
  13.     }
  14. }
  1. public interface Tv {
  2.     void play();
  3. }
  1. public class ChangHong implements Tv {
  2.     @Override
  3.     public void play() {
  4.         System.out.println("长虹电视机，打开");
  5.     }
  6. }
  1. /**
  2.  * 通过setter方法传递依赖
  3.  */
  4. public class Client {
  5.     public static void main(String[] args) {
  6.         ChangHong changHong = new ChangHong();
  7.         OpenAndClose openAndClose = new OpenAndCloseImpl();
  8.         openAndClose.setTv(changHong);
  9.         openAndClose.open();
  10.     }
  11. }

四、里氏替换原则

1、面向对象中继承性得思考和说明

  • 继承包含这样得一层含义：父类中凡是已经实现好的方法，实际上是在设定规范和契约，虽然它不强制要求所有的子类必须遵循这些契约，但是如果子类对这些已经实现的方法任意修改，就会对整个继承体系造成破坏
  • 继承在给程序设计带来便利的同时，也带来了弊端。比如使用继承会给程序带来侵入性，程序的可移植性降低，增加对象间的耦合性，如果一个类被其他类所继承，则当这个类需要修改时，必须考虑到所有的子类，并且父类修改后，所有涉及到子类的功能都有可能产生故障

2、里氏替换原则

  • 里氏替换原则在1988年，由麻省理工学院的一位姓里的女士提出的
  • 如果对每个类型为T1的对象o1，都有类型为T2的对象o2，使得T1定义的所有程序P在所有对象o1都代换成o2时，程序P的行为没有发生变化，那么类型T2是类型T1的子类型。
  • 所有引用基类的地方必须透明地使用其子类的对象
  • 在使用继承时，遵循里氏替换原则，在子类中尽量不要重写父类的方法
  • 里氏替换原则告诉我们，继承实际上让两个类耦合性增强了，在适当的情况下，可以通过聚合、组合、依赖来解决问题

3、代码实现案例

（1）Demo1（违反里氏替换原则）
  1. public class A {
  4.     public int func1(int x,int y){
  5.         return x-y;
  6.     }
  8. }
  1. public class B extends A{
  4.     @Override
  5.     public int func1(int x, int y){
  6.         return x-y;
  7.     }
  9. }
  1. public class Client {
  3.     public static void main(String[] args) {
  4.         A a = new A();
  6.         System.out.println(a.func1(10, 5));
  8.         A b = new B();
  9.            /**
  10.          * 这里本意是调用父类A的func1方法计算x与y的和，但是子类B重写了func1方法，导致结果为计算x与y的差。所以引起程序错误
  11.          */
  12.         System.out.println(b.func1(10, 5));
  14.     }
  16. }

（2）Demo2（遵循里氏替换原则）
  1. public class Base {
  2. }
  1. public class A extends Base {
  3.     public int func1(int x, int y) {
  4.         return x + y;
  5.     }
  7. }
  1. public class B extends Base {
  3.     A a = new A();
  5.     public int func1(int x, int y) {
  6.         return x - y;
  7.     }
  10.     public int func2(int x, int y) {
  11.         return a.func1(x, y);
  12.     }
  14. }
  1. /**
  2.  * 类A和类B继承一个更加基础的类，如果类B想要使用类A的func1方法，则通过依赖A来使用func1方法。
  3.  */、
  4. public class Client {
  5.     public static void main(String[] args) {
  6.         A a = new A();
  7.         B b = new B();
  8.         System.out.println(a.func1(10, 5));
  9.         System.out.println(b.func1(10, 5));
  10.         System.out.println(b.func2(10, 5));
  11.     }
  12. }

五、开闭原则

1、基本介绍

  • 开闭原则是编程中最基础、最重要得设计原则
  • 一个软件实体（类，接口、模块、函数）应该对扩展能力开发（对提供方），对修改关闭（对使用方）,用抽象构建框架，用实现扩展细节
  • 当软件需要变化时，尽量通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码来实现变化
  • 编程中遵循其他原则，以及使用设计模式的目的就是遵循开闭原则

2、代码实现案列

（1）Demo1（违反开闭原则）
  1. /**
  2.  * 形状
  3.  */
  4. public class Shape {
  5.     int type;
  6. }
  1. /**
  2.  * 圆形
  3.  */
  4. public class Circle extends Shape{
  6.     Circle() {
  7.         super.type=2;
  8.     }
  10. }
  1. /**
  2.  * 三角形
  3.  */
  4. public class Triangle extends Shape{
  6.     Triangle() {
  7.         super.type=3;
  8.     }
  10. }
  1. /**
  2.  * 矩形
  3.  */
  4. public class Rectangle extends Shape{
  6.     Rectangle() {
  7.         super.type=1;
  8.     }
  10. }
  1. /**
  2.  * 绘图
  3.  */
  4. public class GraphicEditor {
  6.     public void drawShape(Shape shape) {
  7.         if (shape.type == 1) {
  8.             drawRectangle(shape);
  9.         } else if (shape.type == 2) {
  10.             drawCircle(shape);
  11.         } else if (shape.type == 3) {
  12.             drawTriangle(shape);
  13.         }
  14.     }
  16.     private void drawTriangle(Shape shape) {
  17.         System.out.println("绘制三角形");
  18.     }
  20.     private void drawCircle(Shape shape) {
  21.         System.out.println("绘制圆形");
  22.     }
  24.     private void drawRectangle(Shape shape) {
  25.         System.out.println("绘制矩形");
  26.     }
  28. }
  1. /**
  2.  * 该方式唯一的有点就是简单，容易理解。但是严重违反了开闭原则
  3.  *
  4.  * 当我们添加一个五角形
  5.  * 1、添加一个五角星类
  6.  * 2、在“GraphicEditor”添加一个绘画五角星的方法，
  7.  * 3、在方法“drawShape”中添加一个条件判断
  8.  *
  9.  */
  10. public class Client {
  12.     public static void main(String[] args) {
  13.         GraphicEditor graphicEditor = new GraphicEditor();
  14.         graphicEditor.drawShape(new Rectangle());
  15.         graphicEditor.drawShape(new Circle());
  16.         graphicEditor.drawShape(new Triangle());
  17.     }
  19. }

（2）Demo2（遵循开闭原则）
  1. /**
  2.  * 图形接口
  3.  */
  4. public interface Shape {
  5.     void draw();
  6. }
  1. /**
  2.  * 圆形
  3.  */
  4. public class Circle implements Shape {
  8.     @Override
  9.     public void draw() {
  10.         System.out.println("绘画圆形");
  11.     }
  12. }
  1. /**
  2.  * 矩形
  3.  */
  4. public class Rectangle implements Shape {
  8.     @Override
  9.     public void draw() {
  10.         System.out.println("绘画矩形");
  11.     }
  12. }
  1. /**
  2.  * 三角形
  3.  */
  4. public class Triangle implements Shape {
  8.     @Override
  9.     public void draw() {
  10.         System.out.println("绘画三角形");
  11.     }
  12. }
  1. /**
  2.  * 绘图
  3.  */
  4. public class GraphicEditor {
  6.     public void drawShape(Shape shape) {
  7.         shape.draw();
  8.     }
  11. }
  2. /**
  3.  * 该方式遵循了开闭原则
  4.  *
  5.  * 当我们添加一个五角形，只需要添加一个五角星类就可以了
  6.  *
  7.  *
  8.  */
  9. public class Client {
  11.     public static void main(String[] args) {
  12.         GraphicEditor graphicEditor = new GraphicEditor();
  13.         graphicEditor.drawShape(new Rectangle());
  14.         graphicEditor.drawShape(new Circle());
  15.         graphicEditor.drawShape(new Triangle());
  16.     }
  18. }

六、迪米特法则

1、基本介绍

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

2、代码实现案列

（1）Demo1（违反迪米特法则）
  1. /**
  2.  * 学校员工类
  3.  */
  4. public class CollegeEmployee {
  5.     private String id;
  7.     public String getId() {
  8.         return id;
  9.     }
  11.     public void setId(String id) {
  12.         this.id = id;
  13.     }
  14. }
  1. import java.util.ArrayList;
  2. import java.util.List;
  4. /**
  5.  * 学校员工的管理类
  6.  */
  7. public class CollegeManager {
  9.     public List<CollegeEmployee> getEmployeeList() {
  10.         ArrayList<CollegeEmployee> list = new ArrayList<CollegeEmployee>();
  11.         for (int i = 0; i < 10;i++) {
  12.             CollegeEmployee collegeEmployee = new CollegeEmployee();
  13.             collegeEmployee.setId("学院员工id="+i);
  14.             list.add(collegeEmployee);
  15.         }
  16.         return list;
  17.     }
  22. }
  1. /**
  2.  * 学校总部员工类
  3.  */
  4. public class Employee {
  6.     private String id;
  8.     public String getId() {
  9.         return id;
  10.     }
  12.     public void setId(String id) {
  13.         this.id = id;
  14.     }
  15. }
  1. /**
  2.  * 学校管理类
  3.  */
  4. public class SchoolManager {
  7.     public List<Employee> getEmployeeList() {
  8.         ArrayList<Employee> list = new ArrayList<Employee>();
  9.         for (int i = 0; i < 5; i++) {
  10.             Employee employee = new Employee();
  11.             employee.setId("学校总部员工id=" + i);
  12.             list.add(employee);
  13.         }
  14.         return list;
  15.     }
  19.     void printEmployee(CollegeManager c) {
  21.         List<CollegeEmployee> employeeList = c.getEmployeeList();
  22.         System.out.println("学院员工");
  23.         for (CollegeEmployee employee : employeeList) {
  24.             System.out.println(employee.getId());
  25.         }
  27.         System.out.println("-----------------------");
  29.         List<Employee> employeeList1 = getEmployeeList();
  30.         System.out.println("学院总部员工");
  31.         for (Employee employee : employeeList1) {
  32.             System.out.println(employee.getId());
  33.         }
  35.     }
  38. }
  1. /**
  2.  * CollegeEmployee不是SchoolManager的直接朋友
  3.  * <p>
  4.  * 类SchoolManager的方法printEmployee使用了一个陌生类CollegeEmployee，违反了迪米特法则。
  5.  */
  6. public class Client {
  8.     public static void main(String[] args) {
  9.         SchoolManager schoolManager = new SchoolManager();
  10.         schoolManager.printEmployee(new CollegeManager());
  11.     }
  13. }

（2）Demo2（遵循迪米特法则）
  1. /**
  2.  * 学校员工类
  3.  */
  4. public class CollegeEmployee {
  5.     private String id;
  7.     public String getId() {
  8.         return id;
  9.     }
  11.     public void setId(String id) {
  12.         this.id = id;
  13.     }
  14. }
  1. import java.util.ArrayList;
  2. import java.util.List;
  4. /**
  5.  * 学校员工的管理类
  6.  */
  7. public class CollegeManager {
  9.     public List<CollegeEmployee> getEmployeeList() {
  10.         ArrayList<CollegeEmployee> list = new ArrayList<CollegeEmployee>();
  11.         for (int i = 0; i < 10; i++) {
  12.             CollegeEmployee collegeEmployee = new CollegeEmployee();
  13.             collegeEmployee.setId("学院员工id=" + i);
  14.             list.add(collegeEmployee);
  15.         }
  16.         return list;
  17.     }
  20.     void printEmployee() {
  21.         List<CollegeEmployee> employeeList = getEmployeeList();
  22.         System.out.println("学院员工");
  23.         for (CollegeEmployee employee : employeeList) {
  24.             System.out.println(employee.getId());
  25.         }
  27.     }
  30. }
  1. /**
  2.  * 学校总部员工类
  3.  */
  4. public class Employee {
  6.     private String id;
  8.     public String getId() {
  9.         return id;
  10.     }
  12.     public void setId(String id) {
  13.         this.id = id;
  14.     }
  15. }
  1. import java.util.ArrayList;
  2. import java.util.List;
  4. /**
  5.  * 学校管理类
  6.  */
  7. public class SchoolManager {
  10.     public List<Employee> getEmployeeList() {
  11.         ArrayList<Employee> list = new ArrayList<Employee>();
  12.         for (int i = 0; i < 5; i++) {
  13.             Employee employee = new Employee();
  14.             employee.setId("学校总部员工id=" + i);
  15.             list.add(employee);
  16.         }
  17.         return list;
  18.     }
  21.     void printEmployee(CollegeManager c) {
  23.         c.printEmployee();
  24.         System.out.println("-----------------------");
  27.         List<Employee> employeeList1 = getEmployeeList();
  28.         System.out.println("学院总部员工");
  29.         for (Employee employee : employeeList1) {
  30.             System.out.println(employee.getId());
  31.         }
  33.     }
  36. }
  1. /**
  2.  * 遵循迪米特法则，只与直接朋友通信
  3.  */
  4. public class Client {
  5.     public static void main(String[] args) {
  6.         SchoolManager schoolManager = new SchoolManager();
  7.         schoolManager.printEmployee(new CollegeManager());
  8.     }
  9. }

七、合成复用原则

1、基本介绍

合成复用原则（Composite Reuse Principle，CRP）又叫组合/聚合复用原则（Composition/Aggregate Reuse Principle，CARP）。它要求在软件复用时，要尽量先使用组合或者聚合等关联关系来实现，其次才考虑使用继承关系来实现。

如果要使用继承关系，则必须严格遵循里氏替换原则。合成复用原则同里氏替换原则相辅相成的，两者都是开闭原则的具体实现规范。

合成复用原则的重要性

通常类的复用分为继承复用和合成复用两种，

继承复用虽然有简单和易实现的优点，但它也存在以下缺点。
  继承复用破坏了类的封装性。因为继承会将父类的实现细节暴露给子类，父类对子类是透明的，所以这种复用又称为“白箱”复用。
  子类与父类的耦合度高。父类的实现的任何改变都会导致子类的实现发生变化，这不利于类的扩展与维护。
  它限制了复用的灵活性。从父类继承而来的实现是静态的，在编译时已经定义，所以在运行时不可能发生变化。

采用组合或聚合复用时，可以将已有对象纳入新对象中，使之成为新对象的一部分，新对象可以调用已有对象的功能，它有以下优点。
  它维持了类的封装性。因为成分对象的内部细节是新对象看不见的，所以这种复用又称为“黑箱”复用。
  新旧类之间的耦合度低。这种复用所需的依赖较少，新对象存取成分对象的唯一方法是通过成分对象的接口。
  3复用的灵活性高。这种复用可以在运行时动态进行，新对象可以动态地引用与成分对象类型相同的对象。