自己最近在学习Java的设计模式，本篇讲的是设计模式常用七大设计原则的单一职责原则和界面隔离原则，自己每记录一些知识笔记就会首发在CSDN博客上，能够确保学习完设计模式之后，能够对其有一定程度上的理解和知识记录，形成一个相对不错的知识点框架，来在寒假记录自己学习的点点滴滴，希望大家喜欢

一、为什么要学习设计模式？

在撰写软件的程序中，设计模式是为了让软件具有更好的以下优点：

代码重用性(相同功能的代码不用多次撰写)
可读性(编程规范性，便于其他程序员的阅读和理解)
可扩展性(当需要增加新的功能时，非常的方便)
可靠性(当增加新的功能后，对原来的功能没有影响)
使程序呈现高内聚、低耦合的特性

二、常用的七大原则

单一职责原则
界面隔离原则
依赖倒转原则
里氏替换原则
开闭原则
迪米特法则
合成复用原则

三、单一职责原则

1、基本介绍

客户端不应该依赖它不需要的界面，一个类对另一个类的依赖应该建立在最小的界面上，

先看看一张图：
在这里插入图片描述
代码一：

public class class01 {
    public static void main(String[] args) {
        A a = new A();
        a.method1(new B());
        C c = new C();
        c.method2(new D());
    }
}

interface Interface1{
    void opertion1();
    void opertion2();
    void opertion3();
    void opertion4();
    void opertion5();
}
class B implements Interface1{
    public void opertion1() {
        System.out.println("B 实作了 operation1");
    }
    public void opertion2() {
        System.out.println("B 实作了 operation2");
    }
    public void opertion3() {
        System.out.println("B 实作了 operation3");
    }

    public void opertion4() {
        System.out.println("B 实作了 operation4");
    }
    public void opertion5() {
        System.out.println("B 实作了 operation5");
    }
}

class D implements Interface1{

    public void opertion1() {
        System.out.println("D 实作了 operation1");
    }
    public void opertion2() {
        System.out.println("D 实作了 operation2");
    }
    public void opertion3() {
        System.out.println("D 实作了 operation3");
    }
    public void opertion4() {
        System.out.println("D 实作了 operation4");
    }
    public void opertion5() {
        System.out.println("D 实作了 operation5");
    }
}
class A { // A 类 通过界面Interface1 依赖 B类，但只使用1、2、3方法
    public void method1(Interface1 interface1){
        interface1.opertion1();
    }
    public void method2(Interface1 interface1){
        interface1.opertion2();
    }
    public void method3(Interface1 interface1){
        interface1.opertion3();
    }
}
class C { // C 类 通过界面Interface1 依赖 D类，但只使用1、4、5方法
    public void method1(Interface1 interface1){
        interface1.opertion1();
    }
    public void method2(Interface1 interface1){
        interface1.opertion4();
    }
    public void method3(Interface1 interface1){
        interface1.opertion5();
    }
}

代码一中，类A通过界面Interface1 依赖类B，类C通过界面Interface1 依赖类D，因为界面Interface1 对于类A 和类C来说不是最小界面，所以要想实作图片的功能，需要实作界面的所有方法，违反了界面隔离原则！ 接下来看看代码二，与其对比一下，

代码二：

public class class02 {
    public static void main(String[] args) {
        AA aa = new AA();
        aa.method1(new BB());
        CC cc = new CC();
        cc.method1(new DD());
    }
}
interface Interface2{
    void opertion1();
}
interface Interface3{
    void opertion2();
    void opertion3();
}
interface Interface4{
    void opertion4();
    void opertion5();
}
class BB implements Interface2,Interface3{
    public void opertion1() {
        System.out.println("BB 实作了operation1");
    }
    public void opertion2() {
        System.out.println("BB 实作了operation2");
    }
    public void opertion3() {
        System.out.println("BB 实作了operation3");
    }
}
class DD implements Interface2,Interface4{
    public void opertion1() {
        System.out.println("DD 实作了operation1");
    }
    public void opertion4() {
        System.out.println("DD 实作了operation4");
    }
    public void opertion5() {
        System.out.println("DD 实作了operation5");
    }
}
class AA {
    public void method1(Interface2 interface2){
        interface2.opertion1();
    }
    public void method2(Interface3 interface3){
        interface3.opertion2();
    }
    public void method3(Interface3 interface3){
        interface3.opertion3();
    }
}
class CC {
    public void method1(Interface2 interface2){
        interface2.opertion1();
    }
    public void method2(Interface4 interface4){
        interface4.opertion4();
    }
    public void method3(Interface4 interface4){
        interface4.opertion5();
    }
}