设计模式的七个原则

1、单一责任原则

2、开闭原则

3、里氏替换

4、接口隔离

5、依赖倒转

6、迪米特

7、合成复用

一、单一职责原则

1. 降低类的复杂度，一个类只负责一项职责
2. 提高类的可读性，可维护性
3. 降低变更引起的风险
4. 通常情况下，要遵守单一责任原则，当然如果逻辑足够简单，可以不遵守
5. 如果类中方法足够少，可以考虑在方法级别保持单一职责原则

二、开闭原则

1. 对于扩展是开放的，对修改是关闭的
2. 通过继承、实现 或者 合成复用 来实现扩展

三、里氏替换

1. 被另一个类替换后，要保证程序可正常执行

四、接口隔离

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

【例1】学生成绩管理程序。

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

代碼可不看，了解即可

package principle;
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()方法被调用！");
    }
}

五、依赖倒转（就是代理模式）

1. 高层模块不应该依赖底层模块，二者都应该依赖抽象。
2. 抽象不应该依赖细节，细节应该依赖抽象。
3. 依赖倒置的中心思想是面向接口编程。
4. 依赖倒置原则是基于这样的设计理念：相对于细节的多变性，抽象的东西要稳定的多。以抽象为基础搭建的架构比以细节为基础搭建的架构要稳定的多。
5. 使用 接口 或 抽象类 指定好规范，而不涉及任何具体的操作，把展现细节的任务交给他们的实现类来完成。\

六、迪米特

1. 又叫最少知道原则，对于依赖自己的那些类，自己越少知道越好，这样就提升了独立性
2. 对外提供的依赖方法使用public
3. 由于亲和度降低，从而提高了类的可复用率和系统的扩展性。

七、合成复用（想想装饰器模式）

1. 其实就是避免使用继承，能不用就不用吧，毕竟一个类只能继承一次
2. 可通过引用变量(模塊的組合和聚合關係)，方法来实现对 依赖对象方法 的调用