设计模式的6大原则

软件编程的总原则：高内聚，低耦合。

单一职责原则

就是一个类只负责一项职责，尽量做到类仅有一个引起它变化的原因。

里氏替换原则

所有引用基类的地方必须能透明地使用其子类的对象

里氏替换原则为良好的继承定义了一个规范，一句简单的定义包含了4层含义。

• 子类必须完全实现父类的方法
• 子类可以有自己的个性
• 覆盖或实现父类的方法时输入参数可以被放大
• 复写或实现父类的方法时，输出结果可以被缩小
  实例如下：

/**
 * 枪支的抽象类
 */
public abstract class AbstractGun {

    public abstract void shoot();
}

/**
 * 手枪
 */
public class Handgun extends AbstractGun{
    @Override
    public void shoot() {

        Log.i("射击----","手枪射击....");
    }
}

/**
 * 步枪
 */
public class Rifle extends AbstractGun{
    @Override
    public void shoot() {
        Log.i("射击----","步枪开始射击....");
    }
}

/**
 * 士兵
 */
public class Soldier {

    private AbstractGun gun;

    //给士兵一支枪
    public void setGun(AbstractGun gun){
        this.gun = gun;
    }

    public void killEnemy(){

        Log.i("杀敌---","士兵开始杀敌....");
    }
}

/**
 * 场景
 */
public class Client {

    public static void main(String[] args){

        Soldier sanMao = new Soldier();
        sanMao.setGun(new Handgun());
        sanMao.killEnemy();
    }
}

在这个实例中，士兵可以选择手枪，也可以选择步枪

注意 在类中调用其他类时，务必使用父类或接口，也就是示例中Solider类中，setGun方法，传入的参数是AbstractGun

依赖倒置原则

• 模块间的依赖通过抽象发生，实现类之间不发生直接的依赖关系，其依赖关系是通过接口或抽象类产生的
• 接口或抽象类不依赖于实现
• 实现类依赖接口或抽象类

实例代码如下：

public interface ICar {

    //是汽车就能跑
    public void run();
}

public interface IDriver {

    public void drive(ICar car);
}

/**
 * 司机
 */
public class Driver implements IDriver{
    @Override
    public void drive(ICar car) {
        car.run();
    }
}

public class BMW implements ICar{
    @Override
    public void run() {

        Log.i("汽车----","宝马车开始运行....");
    }
}

public class Client {

    public static void main(String[] args){

        IDriver zhangsan = new Driver();
        ICar benz = new Benz();
        zhangsan.drive(benz);
    }
}

接口隔离原则

• 一个接口只服务于一个子模块或业务逻辑
• 通过业务逻辑压缩接口中的public方法，接口时常去回顾，尽量让接口达到“满身筋骨肉”，而不是肥嘟嘟的一大堆方法
• 已经被污染的接口，尽量去修改，若变更风险大，则采用适配器模式进行转化处理
• 了解环境，拒绝盲从。每个项目或产品都有特定的环境因素。

迪米特法则

也称为最少知识法则：一个对象应该对其他对象有最少的了解。

开闭原则

软件实体应该对扩展开放，对修改关闭。

---

参考资料《设计模式之禅》