设计模式之七大原则分析与总结

开闭原则是总纲：对扩展开放，对修改关闭.

里氏替换原则：不要破坏继承体系。

依赖倒置原则：要面向接口编程。

单一职责原则：实现类要职责单一。

接口隔离原则：在设计接口的时候要精简单一。

迪米特法则：要降低耦合度。

合成复用原则：要优先使用组合或者聚合关系复用，少用继承关系复用。

1、开闭原则（Open Close Principle）

对扩展开放，对修改关闭。当应用的需求改变时，在不修改软件实体的源代码或者二进制代码的前提下，可以扩展模块的功能，使其满足新的需求。简言之，是为了使程序的扩展性好，易于维护和升级。

实现方法

通过“抽象约束、封装变化”来实现开闭原则，即通过接口或者抽象类为软件实体定义一个相对稳定的抽象层，而将相同的可变因素封装在相同的具体实现类中。
因为抽象灵活性好，适应性广，只要抽象的合理，可以基本保持软件架构的稳定。而软件中易变的细节可以从抽象派生来的实现类来进行扩展，当软件需要发生变化时，只需要根据需求重新派生一个实现类来扩展就可以了。

例如：Windows 的桌面主题
分析：用户可以更换自己的桌面主题，这些主题有共同的特点，为其定义一个接口或者抽象类（Abstract Subject），而每个具体的主题（Specific Subject）是其子类实现其方法。用户窗体可以根据需要选择或者增加新的主题，即直接实现接口或者继承抽象类以达到扩展的目的，而不需要修改原代码，所以它是满足开闭原则的。

作用

使软件实体拥有一定的适应性和灵活性的同时具备稳定性和延续性。
1. 对软件测试的影响
软件遵守开闭原则的话，软件测试时只需要对扩展的代码进行测试就可以了，因为原有的测试代码仍然能够正常运行。
** 2. 可以提高代码的可复用性**
粒度越小，被复用的可能性就越大；在面向对象的程序设计中，根据原子和抽象编程可以提高代码的可复用性。
3. 可以提高软件的可维护性
遵守开闭原则的软件，其稳定性高和延续性强，从而易于扩展和维护。

2、里氏代换原则（Liskov Substitution Principle）

任何基类可以出现的地方，子类一定可以出现（即使用父类的地方一定可以使用其子类）。LSP 是继承复用的基石，只有当派生类可以替换掉基类，且软件单位的功能不受到影响时，基类才能真正被复用，而派生类也能够在基类的基础上增加新的行为。里氏代换原则是对开闭原则的补充。实现开闭原则的关键步骤就是抽象化，而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。

实现方法

子类可以扩展父类的功能，但不能改变父类原有的功能。也就是说：子类继承父类时，除添加新的方法完成新增功能外，尽量不要重写父类的方法。
如果重写父类方法，整个继承体系的可复用性会比较差，特别是运用多态比较频繁时，程序运行出错的概率会非常大。
如果程序违背了里氏替换原则，则继承类的对象在基类出现的地方会出现运行错误。这时其修正方法是：取消原来的继承关系，重新设计它们之间的关系。

例如：几维鸟从生物学的角度来划分，它们属于鸟类；但从类的继承关系来看，由于它们不能继承“鸟”会飞的功能，所以它们不能定义成“鸟”的子类。所以有“几维鸟不是鸟”。
分析：鸟一般都会飞行，如燕子的飞行速度大概是每小时 120 千米。但是几维鸟无法飞行。假如要设计一个实例，计算这两种鸟飞行 300 千米要花费的时间。显然，拿燕子来测试这段代码，结果正确，能计算出所需要的时间；但拿几维鸟来测试，结果会发生“除零异常”或是“无穷大”，明显不符合预期。

代码实现：

public class LSPtest
{
    public static void main(String[] args)
    {
        Bird bird1=new Swallow();
        Bird bird2=new BrownKiwi();
        bird1.setSpeed(120);
        bird2.setSpeed(120);
        System.out.println("如果飞行300公里：");
        try
        {
            System.out.println("燕子将飞行"+bird1.getFlyTime(300)+"小时.");
            System.out.println("几维鸟将飞行"+bird2.getFlyTime(300)+"小时。");
        }
        catch(Exception err)
        {
            System.out.println("发生错误了!");
        }
    }
}
//鸟类
class Bird
{
    double flySpeed;
    public void setSpeed(double speed)
    {
        flySpeed=speed;
    }
    public double getFlyTime(double distance)
    {
        return(distance/flySpeed);
    }
}
//燕子类
class Swallow extends Bird{}
//几维鸟类
class BrownKiwi extends Bird
{
    public void setSpeed(double speed)
    {
           flySpeed=0;
    }
}

结果：

如果飞行300公里：
燕子将飞行2.5小时.
几维鸟将飞行Infinity小时。

几维鸟类重写了鸟类的 setSpeed(double speed) 方法，这违背了里氏替换原则。正确的做法是：取消几维鸟原来的继承关系，定义鸟和几维鸟的更一般的父类，如动物类，它们都有奔跑的能力。几维鸟的飞行速度虽然为 0，但奔跑速度不为 0，可以计算出其奔跑 300 千米所要花费的时间。其类图如下图所示。

作用

1.里氏替换原则是实现开闭原则的重要方式之一。
2.它克服了继承中重写父类造成的可复用性变差的缺点。
3.它是动作正确性的保证。即类的扩展不会给已有的系统引入新的错误，降低了代码出错的可能性。

3、依赖倒转原则（Dependence Inversion Principle）

依赖倒转原则是开闭原则的基础，降低了客户与实现模块之间的耦合。具体内容：针对抽象（接口和抽象类）编程，不针对细节（具体的实现）编程。依赖于抽象而不依赖于具体。

实现方法

1.每个类尽量提供接口或抽象类，或者两者都具备。
2.变量的声明类型尽量是接口或者是抽象类。
3.任何类都不应该从具体类派生。
4.使用继承时尽量遵循里氏替换原则。

例如：背景：现在已经有一个顾客类（含shopping()方法）和两个商店类（含sell()方法），而顾客要到多个不用的商店购物，所以要修改顾客类的shopping()方法（即每去一家店都要修改一次shopping()方法），违背开闭原则。
如下：

class Customer
{
    public void shopping(WuyuanShop shop)//不同的商店
    {
        //购物
        System.out.println(shop.sell());
    }
}
class Customer
{
    public void shopping(ShaoguanShop shop)
    {
        //购物
        System.out.println（shop.sell());
    }
}

导致违背开闭原则的原因是顾客类设计时同具体的商店类绑定了，这违背了依赖倒置原则。解决方法是：定义两个商店的共同接口 Shop，顾客类面向该接口编程。

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(); //卖
}
//商店1
class ShaoguanShop implements Shop
{
    public String sell()
    {
        return "商店1特产：香菇、木耳……"; 
    } 
}
//商店2
class WuyuanShop implements Shop
{
    public String sell()
    {
        return "商店2特产：绿茶、酒糟鱼……"; 
    }
} 
//顾客
class Customer
{
    public void shopping(Shop shop)
    {
        //购物
        System.out.println(shop.sell()); 
    }
}

所以无论顾客类访问什么商店都不需要修改源代码。

作用

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

4、单一职责原则（Single Responsibility Principle)

单一职责原则的核心就是控制类的粒度大小、将对象解耦、提高其内聚性（一个类只承担一个职责）。
如果一个对象承担了太多的职责，一个职责的变化可能会削弱或者抑制这个类实现其他职责的能力；当客户端需要该对象的某一个职责时，不得不将其他不需要的职责全都包含进来，从而造成冗余代码或代码的浪费。

实现方法

发现类的不同职责并将其分离，再封装到不同的类或模块中。

例如：大学学生工作管理程序。
分析：学学生工作主要包括学生生活辅导和学生学业指导两个方面的工作，其中生活辅导主要包括班委建设、出勤统计、心理辅导、费用催缴、班级管理等工作，学业指导主要包括专业引导、学习辅导、科研指导、学习总结等工作。如果将这些工作交给一位老师负责显然不合理，正确的做 法是生活辅导由辅导员负责，学业指导由学业导师负责，其类图如下所示。

作用

1.降低类的复杂度，逻辑清晰。
2.提高类的可读性。
3.提高系统的可维护性。
4.变更引起的风险降低。当修改一个功能时，可以显著降低对其他功能的影响。

5、接口隔离原则（Interface Segregation Principle）

使用多个隔离的接口，比使用单个接口要好（即将臃肿庞大的接口拆分成更小的和更具体的接口，为各个类建立它们需要的专用接口）降低类之间的耦合度。

接口隔离原则和单一职责的区别

共同点：都是为了提高类的内聚性、降低它们之间的耦合性，体现了封装的思想。

不同点：
1.单一职责原则注重的是职责，而接口隔离原则注重的是对接口依赖的隔离。
2.单一职责原则主要是约束类，它针对的是程序中的实现和细节；接口隔离原则主要约束接口，主要针对抽象和程序整体框架的构建。

实现方法

1.接口尽量小，但是要有限度。一个接口只服务于一个子模块或业务逻辑。
2.为依赖接口的类定制服务。只提供调用者需要的方法，屏蔽不需要的方法。
3.了解环境，拒绝盲从。每个项目或产品都有选定的环境因素，环境不同，接口拆分的标准就不同深入了解业务逻辑。
4.提高内聚，减少对外交互。使接口用最少的方法去完成最多的事情。

例如：学生成绩管理程序。
分析：学生成绩管理程序一般包含插入成绩、删除成绩、修改成绩、计算总分、计算均分、打印成绩信息、査询成绩信息等功能，如果将这些功能全部放到一个接口中显然不太合理，正确的做法是将它们分别放在输入模块、统计模块和打印模块等 3 个模块中，其类图如下所示。

实现代码

public class ISPtest
{
    public static void main(String[] args)
    {
        InputModule input =StuScoreList.getInputModule();
        CountModule count =StuScoreList.getCountModule();
        PrintModule print =StuScoreList.getPrintModule();
        input.insert();
        count.countTotalScore();
        print.printStuInfo();
        //print.delete();
    }
}
//输入模块接口
interface InputModule
{
    void insert();
    void delete();
    void modify();
}
//统计模块接口
interface CountModule
{
    void countTotalScore();
    void countAverage();
}
//打印模块接口
interface PrintModule
{
    void printStuInfo();
    void queryStuInfo();
}
//实现类
class StuScoreList implements InputModule,CountModule,PrintModule
{
    private StuScoreList(){}
    public static InputModule getInputModule()
    {
        return (InputModule)new StuScoreList();
    }
    public static CountModule getCountModule()
    {
        return (CountModule)new StuScoreList();
    }
    public static PrintModule getPrintModule()
    {
        return (PrintModule)new StuScoreList();
    }
    public void insert()
    {
        System.out.println("输入模块的insert()方法被调用！");
    }
    public void delete()
    {
        System.out.println("输入模块的delete()方法被调用！");
    }
    public void modify()
    {
        System.out.println("输入模块的modify()方法被调用！");
    }
    public void countTotalScore()
    {
        System.out.println("统计模块的countTotalScore()方法被调用！");
    }
    public void countAverage()
    {
        System.out.println("统计模块的countAverage()方法被调用！");
    }
    public void printStuInfo()
    {
        System.out.println("打印模块的printStuInfo()方法被调用！");
    }
    public void queryStuInfo()
    {
        System.out.println("打印模块的queryStuInfo()方法被调用！");
    }
}

结果：

输入模块的insert()方法被调用！
统计模块的countTotalScore()方法被调用！
打印模块的printStuInfo()方法被调用！

作用

1.将臃肿庞大的接口分解为多个粒度小的接口，可以预防外来变更的扩散，提高系统的灵活性和可维护性。
2.接口隔离提高了系统的内聚性，减少了对外交互，降低了系统的耦合性。
3.如果接口的粒度大小定义合理，能够保证系统的稳定性；但是，如果定义过小，则会造成接口数量过多，使设计复杂化；如果定义太大，灵活性降低，无法提供定制服务，给整体项目带来无法预料的风险。
4.使用多个专门的接口还能够体现对象的层次，因为可以通过接口的继承，实现对总接口的定义。
5.能减少项目工程中的代码冗余。过大的大接口里面通常放置许多不用的方法，当实现这个接口的时候，被迫设计冗余的代码。

6、迪米特法则，又称最少知道原则（Demeter Principle）

最少知道原则是指：一个实体应当尽量少地与其他实体之间发生相互作用，使得系统功能模块相对独立。只和朋友直接交谈，不跟“陌生人”说话。如果想和陌生人说话则需要通过第三方转发。
朋友指：当前对象本身、当前对象的成员对象、当前对象所创建的对象、当前对象的方法参数等，这些对象同当前对象存在关联、聚合或组合关系，可以直接访问这些对象的方法。

实现方法

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

例如： 明星与经纪人的关系实例。
分析：明星的许多日常事务由经纪人负责处理，如与粉丝的见面会，与媒体公司的业务洽淡等。这里的经纪人是明星的朋友，而粉丝和媒体公司是陌生人，所以适合使用迪米特法则，其类图如下所示。

实现代码;

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;
    }
}

作用

1.低了类之间的耦合度，提高了模块的相对独立性。
2.由于亲合度降低，从而提高了类的可复用率和系统的扩展性。
注意：过度使用迪米特法则会使系统产生大量的中介类，从而增加系统的复杂性，使模块之间的通信效率降低。

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

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

实现方法

将已有的对象纳入新对象中，作为新对象的成员对象来实现的，新对象可以调用已有对象的功能，从而达到复用。

例如： 汽车分类管理程序。
分析：汽车按“动力源”划分可分为汽油汽车、电动汽车等；按“颜色”划分可分为白色汽车、黑色汽车和红色汽车等。如果同时考虑这两种分类，其组合就很多。下图所示是用继承关系实现的汽车分类的类图。

可以看出用继承关系实现会产生很多子类，而且增加新的“动力源”或者增加新的“颜色”都要修改源代码，这违背了开闭原则，显然不可取。但如果改用组合关系实现就能很好地解决以上问题，其类图如下所示。

作用

1.维持了类的封装性。因为成分对象的内部细节是新对象看不见的，所以这种复用又称为“黑箱”复用。
2.新旧类之间的耦合度低。这种复用所需的依赖较少，新对象存取成分对象的唯一方法是通过成分对象的接口。
3.复用的灵活性高。这种复用可以在运行时动态进行，新对象可以动态地引用与成分对象类型相同的对象。

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