# 七大原则是设计模式的依据 #

单一职责原则SRP

就一个类而言，应该仅有一个引起它变换的原因· ``

软件设计真正要做的许多内容，就是发现职责并把哪些职责相互分离

如果一个类承担的职责过多，就等于把这些职责耦合在一起，一个职责的变化可能会削弱或者抑制这个类完成其他职责的能力。这种耦合会导致脆弱的设计，当变化发生时，设计会遭到意想不到的破坏

接口隔离原则

客户端不应该依赖于它不需要的接口，即一个类对另一个类的依赖应该建立在最小接口上。解决措施为：将接口拆分为几个独立的接口。

具体案例：先由b实现接口，再由a依赖接口
`package day6;

        import day3.LinkedList;

        public class test1 {
            /*这里用c d 来用接口的方法*/
            public static void main(String[] args) {
                C c = new C();
                c.depend2(new B());
            }

        }

        interface say1{
            public void sayEnglish();
        }
        interface say2{
            public void sayChinese();
            public void sayJapenese();
        }
        interface say3{
            public void sayFrench();
        }
        class B implements say1,say2{

            @Override
            public void sayEnglish() {
                System.out.println("wo shi yanglei");
            }

            @Override
            public void sayChinese() {
                System.out.println("我是杨磊");
            }

            @Override
            public void sayJapenese() {
                System.out.println("ri yu");
            }
        }/*让AB 实现接口*/
        class A implements say1,say3{

            @Override
            public void sayEnglish() {
                System.out.println("wo shi yang lei");
            }

            @Override
            public void sayFrench() {
                System.out.println( "jiliguala");
            }
        }
        class C{
            public void depend1(say1 say1){
                say1.sayEnglish();

            }
            public void depend2(say2 say2){
                say2.sayChinese();
                say2.sayJapenese();

            }
        }

依赖倒置原则

强内聚，松耦合

高层模块不应该依赖于低层模块。两个都应该依赖抽象。

抽象不应该依赖细节。细节应该依赖抽象

针对接口编程，不是对实现编程

不管是高层模块还是底层模块，他们都应该依赖于抽象，具体一点就是接口和抽象类，只要接口是稳定的，那么任何一个的更改都不需要其他受到影响，因为无论高低层模块都可以复用。

依赖传递的三种形式：接口传递构造方法传递 setter方式传递
`
package day6;
/依赖倒置原则的讲解/

        /*最开始的代码没用接口，所以每次更改就会变动很大*/
        public class test2 {
            /*主程序区域为客户端不需要做很大的改变*/
            public static void main(String[] args) {
                Person person = new Person();
                person.receive(new Email());
                person.receive(new QQ());
            }
        }
        interface IReceiver{
            public String getInfo();
        }
        /*定义一个接口，写上获取方法*/

        /*具体是什么方法，就有具体的实现类取实现就可以了，客户端需要用哪一个就直接调用
        * */
        class Email implements IReceiver{

            @Override
            public String getInfo() {
                return "电子邮件信息:hello world";
            }
        }
        class QQ implements IReceiver{

            @Override
            public String getInfo() {
                return "qq信息:hello world";
            }
        }
        /*客户端使用者写上一个接受方法。方法参数为接口，输出接口的函数，这样就和实现类产生了
        * 依赖关系*/
        class Person{
            public void receive(IReceiver receiver){
                System.out.println(receiver.getInfo());
            }
        }