程序设计的原则

一、开闭原则（OCP）

1、相关概念：开闭原则的原文：Software entities should be open for extension,but closed for modification.翻译过来就是：“软件实体应当对扩展开放，对修改关闭”。也就是说软件系统中包含的各种组件，例如模块（Modules）、类（Classes）以及功能（Fuctions）等等，应该在不修改现有代码的基础上，引入新的功能。开闭原则中的“开”是指对于组件功能的扩展是开放的，是允许对其进行功能扩展的；开闭原则中的“闭”，是指对于现有代码的修改是封闭的，即不应该修改现有的代码。

2、关键点：实现开闭原则的关键是“抽象”，把系统给的所哟可能的行为抽象成一个抽象底层，这个抽象底层规定出所有的具体实现必须提供的方法的特征。

3、例子：

interface VidioCard{//定义显卡的功能，有显示功能和获取显卡名称的功能

    void display();
    String getName();
}
class HaoLongVidio implements VidioCard{
    String name="HaoLongVidio";
    void setName(String name) {
        this.name = name;
    }
    public void display(){
        System.out.println("The HaoLong vidiocard is running!");
    }
    public String getName(){
        return name;
    }
}
class MainBorad{
    String cpuName;
    VidioCard vc;
    void setCpuname(String cpuName){
        this.cpuName=cpuName;
    }
    void setVidioCard(VidioCard vc){
        this.vc=vc;
    }
    void run(){
        System.out.println("Wudi-mainbord!");
        System.out.println(vc.getName());
        vc.display();
        System.out.println("mianborad is running successful!");
    }

}
public class pratice2 {
    public static void main(String[] args){
        HaoLongVidio hv=new HaoLongVidio();//买了一块HanglongVidio显卡
        MainBorad mb=new MainBorad();

        mb.setCpuname("intel");
        mb.setVidioCard(hv);

        mb.run();
        System.out.println("Okay!");
    }
}

二、里氏替换原则（LSP，Liskov  Substitution Principle）

1、相关概念：主张使用抽象（Abstraction）和多态（Polymorphism）将涉及中的静态结构改为动态结构，维持设计的封闭性。“抽象”是语言提供的功能。“多态”由继承予以实现。

2、关键点：Subtypes must be substututable for their base types 即子类必须能够替换成它们的基类。“面向接口编程”基本上抓住了这个原则的核心。

3、例子：正方形不是长方形

4、备注：（1）实现开闭原则的关键步骤是抽象化，基类与子类之间的继承关系就是抽象化的体现，因此，里氏替换原则是实现抽象化的一种规范。违反里氏替换原则意味着违反了开闭原则，反之未必。里氏替换原则是使代码符合开闭原则的一个重要保证。（2）启示是如果一个继承类的对象可能会出现的地方出现运行错误，则该子类不应该从该基类继承，或者说，应该重现设计它们之间的关系。

三、依赖倒置原则（DIP：Dependence inversion principle）

1、相关概念：High level modules should not depend upon low level modules. Both should depend upon abstractions. Abstractions should not depend upon details. Details should depend upon abstractions。

A:高层次的模块不应该依赖于低层次的模块，它们都应该以来于抽象、B:抽象不应该依赖于具体，具体应该依赖于抽象。

2、关键点：要依赖于抽象，不要依赖于具体。简单的说就是要求对抽象进行编程，不要对实现进行编程，这样就降低了客户与实现模块间的耦合，提高系统的稳定性。

3、例子：

public class Driver{
    public void drive(Benz benz){
        benz.run();
    }
}
public class Benz{
    public  void run(){
        System.out.println("奔驰轿车开始运行。。。");
    }
}
public class Bmw{
    public void main(){
        System.out.println("宝马轿车开始运行。。。");
    }
}
public class Client{
    public static void main(String[] args){
        Driver zhangsan=new Driver();
        Benz benz=new Benz();

        zhangsan.drive(benz);
    }
}

例子说明：是设计出现了问题：司机类和奔驰轿车类之间是一个紧耦合的关系，其导致的结果就是系统的可维护性大大降低，可读性降低，两个个相似的类需要阅读两个文件。。。

解决方法：

4、说明：依赖倒置原则的本质就是通过抽象（接口或者抽象类）使各个类或者模块的实现彼此独立，不相互影响，实现模块间的松耦合。（1）每一个类尽量都有接口或者抽象类，或者两者都有。这是依赖倒置的基本要求，接口和抽象都是属于抽象的，有了抽象才可能依赖倒置。（2）变量的显示类型尽量使接口或者抽象类。（3）任何类都不应该从具体类派生。（4）尽量不要覆写基类的方法。因为类之间依赖的是抽象，覆写了抽象方法，对依赖的稳定性会产生一定的影响。（5）结合里氏替换原则适用。

四、接口隔离原则（ISP:Interface segregation principle）

1、相关概念：使用多个专门的接口比使用单一的接口要好。换言之，从一个客户类的角度来讲：一个类对另外一个类的依赖性应该是建立在最小的接口上的。

2、关键点：

3、例子：

//interface segregation principle -bad exaple
interface iWorker{
    public void work();
    public void eat();
}
class Worker implements iWorker{
    public void work(){
        //。。。working
    }
    public void eat(){
        //。。。eating in launch break
    }
}
class superWoker implements iWorker{
    public void work(){
        //。。。working much more
    }
    public void eat(){
        //。。。eating in 。。。
    }
}
class Manger{
    iWorker worker;
    public void setWorker(iWorker w){
        worker=w;
    }
    public void manage(){
        worker.work();
    }
}
//interface segregation principle-good example
interface iworkable{
    public void work();
}
interface ifeedable{
    public void eat();
}

class worker implements ifeedable,ifeedable{
    public void work(){
        //。。。working。。。
    }
    public void eat(){
        //。。。eatiung in launch break。。。
    }
}

class superWorker implements iworkable,ifeedable{
    public void work(){
        //。。。working much more
    }
    public void eat{
        //。。。eating in launch break
    }
}

class Robot implements iworkable{
    public void work(){
        //。。。。working
    }
}
class Manager{
    iworkable worker;
    public void setWorker(iworkable w){
        worker=w;
    }
    public void manage(){
        worker.work();
    }
}

备注：在使用接口隔离原则可以防止庞大、臃肿的接口，这也就是接口隔离原则的目的所在。

4、与单一职责原则的比较：接口原则尽量使用多个专门的接口，这和单一职责原则很类似，其实不然。（1）单一原则注重的是职责；而接口原则注重对接口依赖的隔离。（2）单一职责原则主要是约束类，其次才是接口和方法。它针对的是程序中的实现和细节；而接口隔离原则主要约束接口，主要针对抽象，针对程序整体框架的构建。

5、使用接口隔离原则的注意点：首先必须满足单一职责原则，其次是在使用接口隔离原则时：接口要小，但是要有限度；为依赖接口的类定制服务，只暴露给调用的类它需要的方法，不需要的方法则要隐藏起来。只有专注低位一个模块提供定制服务，才能建立最小的依赖关系；提高内聚，减少对外交互。

五、合成/聚合原则（CARP：Composition/Aggreagation Principle）

1、相关概念：尽量使用合成/聚合，不要使用类继承。在一个新的对象里面使用一些已有的对象，使之成为新对象的一部分，新对象通过多向这些对象的委派达到服用已有功能的目的，就是说要进行的使用合成和聚合。

2、关键点：两者都是关联的特殊种类。聚合表示一种弱的”拥有“关系，体现的是A对象可以包含B对象，但B对象不是A对象的一部分。合成（组合）是一种强的”拥有“关系，体现了严格的部分与整体的关系，部分与整体的生命周期是一样的。

3、例子：

六、迪米特原则（Low 偶发Demeter，又称为最少知识原则，least knowledge principle简写LKP）

1、相关概念：Talk only to your immediate friends，其初衷在于降低类之间的耦合。

2、关键点：如果两个类不必彼此直接通信，那么这两个类就不应当发生直接的相互作用，如果其中的一个类需要条用另一个类的某一个方法的话，可以通过第三者转发这个调用。

3、例子：

4、备注：在类设计上的体现：（2）优先考虑将一个类设置成不变类（孩子与父母的关系，父母就可以理解为不变类）。（2）尽量降低一个类的访问权限。（3）谨慎使用serializable 。（4）尽量降低成员的访问权限。

七、单一职责原则

1、相关概念：不要存在多余一个导致类变更的原因。简单的理解就是一个类只负责一项职责。

2、关键点：存在职责扩散的情况。

3、例子：

4、备注：