java图解设计模式学习笔记

设计模式的应用场景

面向对象（oo）-> 功能模块【设计模式+算法（数据结构）】->框架【使用多种设计模式】->架构【服务器集群】
编写软件过程中，使用设计模式来提高程序的耦合性，内聚性，可维护性，可拓展性，重用性，灵活性。
耦合性：模块之间的冲突和连接关系，耦合性高会导致代码a模块出现问题的时候导致其他多个与a耦合性高的模块产生一定的不稳定，所以要降低程序的耦合性。

设计模式常用的七大原则：

设计模式的原则，是各种设计模式的基础。

单一职责原则

对类来说，一个类应该只负责一项职责（降低耦合性）。但是这样会造成的后果就是代码量会上升，并且调用的时候也比较麻烦。
更好用的是在方法层面来进行单一职责原则，一个方法只负责一个职责，比如下面的代码，如果一个方法既要负责陆地上跑的，还要负责天上飞的输出的话就违背了单一职责原则，所以可以实现多个方法来完成不同的职责需求，这样是在方法层面上遵守了单一职责的原则。
通常情况下，我们一定要遵守单一职责原则，只有在逻辑足够简单，才可以在代码级违反单一职责原则，只有类中方法数量足够少，可以在方法级别保持单一职责原则。

package singleresponsibility;

public class singleres2 {
    public static void main(String[] args){

        Vehicle2 vehicle =new Vehicle2();
        vehicle.run("moto");
        vehicle.runair("car");
        vehicle.runwater("ship");
    }
}
//如果由行驶的空间分类，分为天上地下水中
//这样分类需要写很多的类来完成目标
//改进方法：直接修改vehicle类，改动的代码就会很少
//虽然没有在类的级别上遵守单一职责原则，但是在方法级别上遵守了单一职责原则
class Vehicle2{
    public  void run(String vehicle){
        System.out.println(vehicle+"在跑");
    }
    public  void runair(String vehicle){
        System.out.println(vehicle+"在飞");
    }
    public  void runwater(String vehicle){
        System.out.println(vehicle+"在水中");
    }
}

接口隔离原则

客户端不应该依赖它不需要的接口，即一个类对另一个类对依赖应该建立在最小的接口上。
例子如下图
A通过interface1会依赖B,但是只会使用到接口的1，2，3三个方法
C通过interface1会依赖D,但是只会使用到接口的1，4，5三个方法

public class interface1 {
    public static void main(String[] args){
      A a=new A();
      B b=new B();
      C c=new C();
      D d=new D();
      a.depend1(b);
      a.depend2(b);
      a.depend3(b);
      c.depend1(d);
      c.depend4(d);
      c.depend5(d);
    }
}

interface In{
    void op1();
    void op2();
    void op3();
    void op4();
    void op5();
}

class B implements In{
    public void op1(){
     System.out.println("B实现了1");
    }
    public void op2(){
        System.out.println("B实现了2");
    }
    public void op3(){
        System.out.println("B实现了3");
    }
    public void op4(){
        System.out.println("B实现了4");
    }
    public void op5(){
        System.out.println("B实现了5");
    }
}
class D implements In{
    public void op1(){
        System.out.println("D实现了1");
    }
    public void op2(){
        System.out.println("D实现了2");
    }
    public void op3(){
        System.out.println("D实现了3");
    }
    public void op4(){
        System.out.println("D实现了4");
    }
    public void op5(){
        System.out.println("D实现了5");
    }
}

class A{
    public void depend1(In i){
        i.op1();
    }
    public void depend2(In i){
        i.op2();
    }
    public void depend3(In i){
        i.op3();
    }
}

class C{
    public void depend1(In i){
        i.op1();
    }
    public void depend4(In i){
        i.op4();
    }
    public void depend5(In i){
        i.op5();
    }
}

这种传统的方法会出现的问题在于，类A,C使用接口去依赖其他的类，但是仅仅只使用了接口中的部分方法，换句话说就是interface1对于类A和C来说不是最小接口，但是B和D却必须去实现它们不需要的方法，造成资源代码的浪费。
解决的方法
对interface1拆分为独立的几个接口，类A,C分别与它们的需要的接口建立依赖关系，也就是采用接口隔离原则，具体拆分如下图：

实现类似于上面的代码，这里就不赘述了。

依赖倒转原则

1.高层模块不应该依赖低层模块，二者都应该依赖其抽象。
2.抽象不应该依赖细节，细节应该依赖抽象。
3.依赖倒转的中心思想是面向接口编程。
因为，对于细节的多变性，抽象的东西要稳定的多，以抽象为基础搭建的架构也会更加稳定，抽象，指的是抽象类或接口。
使用接口或抽象类的目的是为了制定好规范，而不设计任何具体的操作，把展现细节的任务交给他们的实现类去完成。

有如下的例子：
person 类实现了一个接受信息的方法，但是如果参数是email的时候只能实现接受email的功能，如果要实现接受微信信息，接受短信信息等等的时候，需要对方法进行重载，这样就会造成代码冗余，违反了依赖倒转原则，高层的对高层的进行了依赖。
解决方法：
引入一个接口receiver，表示接受这，这样person类与receiver发生依赖，只要让email，微信，短信类分别去实现这个接口就可以实现对应的功能了，这样也符合了依赖倒转原则。

class Email{
    public String getinfo(){
        return "电子邮件信息如下";
    }
}
class Person{
    public  void receive(Email e){
      System.out.println(e.getinfo());
    }
}

//修改以后的代码
interface receiver{
    public String getinfo();
}
class Email implements receiver{
    public String getinfo(){
        return "电子邮件信息如下";
    }
}
class weixin implements receiver{
    public String getinfo(){
        return "wechat信息如下";
    }
}
class Person{
    public  void receive(receiver e){
      System.out.println(e.getinfo());
    }
}
/*依赖关系传递的三种方法：
1.接口传递
2.构造方法传递
3.setter方式传递*/

里式替换原则

开闭原则ocp

迪米特法则

合成复用原则