java设计模式之七大设计原则（1）

大家好，我是一名在算法之路上不断前进的小小程序猿！体会算法之美，领悟算法的智慧~

希望各位博友走过路过可以给我点个免费的赞，你们的支持是我不断前进的动力！！

加油吧！未来可期！！！

java设计模式之七大设计原则

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

设计模式常用的七大原则有: 1) 单一职责原则 2) 接口隔离原则 3) 依赖倒转原则 4) 里氏替换原则 5) 开闭原则 ocp 6) 迪米特法则 7) 合成复用原则

本文将先介绍前三个原则：单一职责原则、接口隔离原则、依赖倒转原则。

设计模式的重要性：

编写软件过程中，程序员面临着来自耦合性，内聚性以及可维护性，可扩展性，重用性，灵活性 等多方面的挑战，设计模式是为了让程序(软件)，具有更好的

1) 代码重用性 (即：相同功能的代码，不用多次编写）

2) 可读性 (即：编程规范性, 便于其他程序员的阅读和理解）

3) 可扩展性 (即：当需要增加新的功能时，非常的方便，称为可维护)

4) 可靠性 (即：当我们增加新的功能后，对原来的功能没有影响)

5) 使程序呈现高内聚，低耦合的特性

6）设计模式包含了面向对象的精髓，“懂了设计模式，你就懂了面向对象分析和设计 （OOA/D）的精要”

7）Scott Mayers 在其巨著《Effective C++》就曾经说过：C++老手和 C++新手的区别就是 前者手背上有很多伤疤

单一职责原则：

基于类上实现单一职责原则：

package singleresponsibility;/* <---这是包名
-*- coding:utf-8 -*-
作者：bob-coding
日期：2022年09月25日15:28
人生苦短，自学idea！！冲冲冲！！！*/

public class SingleResponsibility {
    public static void main(String[] args) {
        Vehicle1 vehicle1 = new Vehicle1();
        vehicle1.Roadrun("汽车");
        Vehicle2 vehicle2 = new Vehicle2();
        vehicle2.Airrun("飞机");
        Vehicle3 vehicle3 = new Vehicle3();
        vehicle3.Waterrun("轮船");

    }
}

class Vehicle1{
    public void Roadrun(String vehicle){
        System.out.println(vehicle + "在公路上跑...");
    }
    //对于在这个类里操作不会影响到其他类到功能
}

class Vehicle2{
    public void Airrun(String vehicle){
        System.out.println(vehicle + "在天空上跑...");
    }
}

class Vehicle3{
    public void Waterrun(String vehicle){
        System.out.println(vehicle + "在海里上跑...");
    }
}

运行截图：

 

基于方法上实现单一职责原则，原则上说，并没有那么严谨地遵循：

package singleresponsibility;/* <---这是包名
-*- coding:utf-8 -*-
作者：bob-coding
日期：2022年09月25日15:28
人生苦短，自学idea！！冲冲冲！！！*/

public class SingleResponsibility2 {
    public static void main(String[] args) {
        Vehicle vehicle = new Vehicle();
        vehicle.Roadrun("汽车");
        vehicle.Airrun("飞机");
        vehicle.Waterrun("轮船");

    }
}

class Vehicle{
    public void Roadrun(String vehicle){
        System.out.println(vehicle + "在公路上跑...");
    }
    public void Airrun(String vehicle){
        System.out.println(vehicle + "在天空上跑...");
    }
    public void Waterrun(String vehicle){
        System.out.println(vehicle + "在海里上跑...");
    }
}

运行截图

 单一职责原则注意事项和细节 ：1) 降低类的复杂度，一个类只负责一项职责。 2) 提高类的可读性，可维护性 3) 降低变更引起的风险 4) 通常情况下，我们应当遵守单一职责原则，只有逻辑足够简单，才可以在代码级违反单一职责原则；只有类中方法数量足够少，可以在方法级别保持单一职责原则

接口隔离原则

例子：类A通过接口Interface1依赖类B，类C通过接口Interface1依赖类D，如果接口 Interface1对于类A和类C来说不是最小接口， 那么类B和类D必须去实现他们不需要的方法。

分析：按隔离原则应当这样处理： 将接口Interface1拆分为独立的几个接口， 类A和类C分别与他们需要的接口建立依赖 关系。也就是采用接口隔离原则。

 对接口interface1进行拆分

应传统方法的问题和使用接口隔离原则改进： 1) 类A通过接口Interface1依赖类B，类C通过接口Interface1依赖类D，如果接口 Interface1对于类A和类C来说不是最小接口，那么类B和类D必须去实现他们不 需要的方法 2) 将接口Interface1拆分为独立的几个接口，类A和类C分别与他们需要的接口建立 依赖关系。也就是采用接口隔离原则 3) 接口Interface1中出现的方法，根据实际情况拆分为三个接口 

代码实现：

package segregation;/* <---这是包名
-*- coding:utf-8 -*-
作者：bob-coding
日期：2022年09月25日16:21
人生苦短，自学idea！！冲冲冲！！！*/

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

interface Interface1{
    void operation1();
}

interface Interface2{
    void operation2();
    void operation3();
}

interface Interface3{
    void operation4();
    void operation5();
}

//B实现了1，2，3方法
class B implements Interface1,Interface2{

    @Override
    public void operation1() {
        System.out.println("B实现了接口1");
    }

    @Override
    public void operation2() {
        System.out.println("B实现了接口2");
    }

    @Override
    public void operation3() {
        System.out.println("B实现了接口3");
    }
}

//D实现了1，4，5方法
class D implements Interface1,Interface3{

    @Override
    public void operation1() {
        System.out.println("D实现了接口1");
    }

    @Override
    public void operation4() {
        System.out.println("D实现了接口4");
    }

    @Override
    public void operation5() {
        System.out.println("D实现了接口5");
    }
}

class A{
    public void depend1(Interface1 i){
        i.operation1();
    }
    public void depend2(Interface2 i){
        i.operation2();
        i.operation3();
    }
}

class C{
    public void depend3(Interface1 i){
        i.operation1();
    }
    public void depend4(Interface3 i){
        i.operation4();
        i.operation5();
    }
}

依赖倒转原则 

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

依赖倒转原则:依赖关系传递的三种方式 1) 接口传递  2) 构造方法传递  3) setter方式传递 

package dependecyinversion;/* <---这是包名
-*- coding:utf-8 -*-
作者：bob-coding
日期：2022年09月25日17:19
人生苦短，自学idea！！冲冲冲！！！*/

//接口传递
public class DependecyInversion {
    public static void main(String[] args) {
        Person person = new Person();
        person.receive(new Email());
        person.receive(new Weixin());
    }
}

interface IReceiver{
    String getinfo();
}

class Email implements IReceiver{

    @Override
    public String getinfo() {
        return "Email信息：email";
    }
}

class Weixin implements IReceiver{

    @Override
    public String getinfo() {
        return "Weixin信息：Weixin";
    }
}

//person类依赖抽象的接口，不会对person类进行大的修改，提高可扩展性
//基于接口传递
class Person{
    public void receive(IReceiver irceiver) {
        System.out.println(irceiver.getinfo());
    }
}

注意：依赖倒转原则的注意事项和细节

1) 低层模块尽量都要有抽象类或接口，或者两者都有，程序稳定性更好.

2) 变量的声明类型尽量是抽象类或接口, 这样我们的变量引用和实际对象间，就存在 一个缓冲层，利于程序扩展和优化

3) 继承时遵循里氏替换原则