设计模式七大原则（哪七个）及代码示例，请看本篇文章

七大原则：

1. 单一职责原则；
2. 接口隔离原则；
3. 依赖倒转原则；
4. 里氏替换原则；
5. 开闭原则ocp；
6. 迪米特法则；
7. 合成复用原则。

设计模式其实包含了面向对象的精髓，封装、继承、多态。

一、单一职责原则

对于类来说，一个类应该只负责一项职责。

假设A负责两个不同的职责1和2，如果1的内容需要改变，影响了2，那可能2会执行错误，所以需要将A分为两个类。

1.1 示例

public class SingleResponsibility1 {
    public static void main(String[] args) {
        Vehicle vehicle = new Vehicle();
        vehicle.run("汽车");
        vehicle.run("摩托车");
        vehicle.run("飞机");
    }
}

class Vehicle{
    public void run(String vehicle){
        System.out.println(vehicle+"在地上跑");
    }
}

对于一个完成交通工具的类Vehicle来说，显然对不同的对象、汽车和飞机，提供的服务不应该都是在地上跑，并且修改之后，肯定会影响到其中一类对象的功能，所以按照单一职责，那就应该拆开，成两个类。

1.2 改进版本 1

public class SingleResponsibility2 {
    public static void main(String[] args) {
        RoadVehicle roadVehicle = new RoadVehicle();
        roadVehicle.run("摩托车");
        roadVehicle.run("汽车");
        AirVehicle airVehicle = new AirVehicle();
        airVehicle.run("飞机");
    }
}

class RoadVehicle{
    public void run(String vehicle){
        System.out.println(vehicle+"在地上跑");
    }
}
class AirVehicle{
    public void run(String vehicle){
        System.out.println(vehicle+"在天上飞");
    }
}

但是这么写又有了新的问题：那就是类分解的时候，客户端代码也要改，调用方式改了。因此可以直接更改本来的Vehicle类，变成我们的第三种写法.

1.3 改进版本 2

public class SingleResponsibility3 {
    public static void main(String[] args) {
        Vehicle2 vehicle2 = new Vehicle2();
        vehicle2.runRoad("汽车");
        vehicle2.runWater("轮船");
        vehicle2.runAir("飞机");
    }
}

class Vehicle2{
    public void runRoad(String vehicle){
        System.out.println(vehicle+"在公路上跑");
    }
    public void runAir(String vehicle){
        System.out.println(vehicle+"在天上飞");
    }
    public void runWater(String vehicle){
        System.out.println(vehicle+"在水里游");
    }
}

这种写法，显然更加方便，相比第一种，没有更改类的声明方式，只是在类内部增加了方法的各司其职，可以看出来，虽然没有在类级别上严格遵循单一职责原则，但是在方法级别上严格遵循了单一职责原则，相比之下比方法2更合适。

1.4 总结单一职责原则

1. 降低类的复杂度，一个类只负责一项职责（上面的例子因为过于简单，所以看起来第三个写法更有效）；
2. 提高类的可读性、可维护性，降低变更带来的风险；
3. 通常情况下，我们应该遵守这个职责，只有在逻辑足够简单的时候，才可以在代码级别违反这个原则，也就是上面的，改为在方法级别保持单一职责原则。

二、接口隔离原则

接口隔离（Interface Segregation Principle）

意思是说，如果某一个类对另一个类的依赖通过的是接口，那么这个类对另一个类的依赖应该建立在最小的接口上，如果不是最小接口，则需要拆。

2.1 示例

例如如下的用例图：

A 和 B 是 Interface1 的实现类，所以必须实现它的 4 个方法，C 和 D 分别依赖于这个接口，使用 A 和 B 里面对应的方法，但不是全部，C 使用前三个方法，D 使用后三个方法，如果按照类图实现，代码会如下所示：

interface Interface1{
    void fuc1();
    void fuc2();
    void fuc3();
    void fuc4();
}

class A implements Interface1{
    public void fuc1() {System.out.println("A实现了fuc1");}
    public void fuc2() {System.out.println("A实现了fuc2");}
    public void fuc3() {System.out.println("A实现了fuc3");}
    public void fuc4() {System.out.println("A实现了fuc4");}
}

class B implements Interface1{
    public void fuc1() {System.out.println("B实现了fuc1");}
    public void fuc2() {System.out.println("B实现了fuc2");}
    public void fuc3() {System.out.println("B实现了fuc3");}
    public void fuc4() {System.out.println("B实现了fuc4");}
}
//C通过接口Interface1依赖，使用A这个实现类，但是只用A的前两个方法
class C {
    public void depend1(Interface1 i){
        i.fuc1();
    }
    public void depend2(Interf