设计模式七大原则

已于 2022-03-13 16:53:49 修改
阅读量211 收藏
点赞数
分类专栏： 设计模式 文章标签： java 后端 设计模式
于 2020-08-20 23:31:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43374578/article/details/108137509
版权

一、Single Responsibility Principle

  • 一个类只负责一项职责，提高代码易读性，可维护性

1. 传统模式

  • 一个类中的方法，具备了不同种类的错误的功能，违反了单一职责
package com.design.pattern.day01;

public class Demo01 {
    public static void main(String[] args) {
        Vehicle plane = new Vehicle("飞机");
        plane.run();

        Vehicle boot = new Vehicle("轮船");
        boot.run();

        Vehicle bike = new Vehicle("自行车");
        bike.run();
    }
}

class Vehicle {

    private String name;

    public Vehicle(String name) {
        this.name = name;
    }

    public void run() {
        System.out.println(name + "在天上飞");
    }
}

2. 基于类

  • 每个类都负责该类中所有功能，如果需要在该类中添加对应的功能，不会影响其他类中，符合单一职责原则
  • 当类中的方法较少的时候，创建多个类会增大虚拟机开销
package com.design.pattern.day01;

public class Demo02 {
    public static void main(String[] args) {
        PlaneVehicle planeVehicle = new PlaneVehicle();
        planeVehicle.run();

        BikeVehicle bikeVehicle = new BikeVehicle();
        bikeVehicle.run();

        BootVehicle bootVehicle = new BootVehicle();
        bootVehicle.run();
    }
}

class PlaneVehicle {
    private String name = "飞机";

    public void run() {
        System.out.println(name + "天上飞");
    }
}

class BootVehicle {
    private String name = "船";

    public void run() {
        System.out.println(name + "水里游");
    }
}

class BikeVehicle {
    private String name = "自行车";

    public void run() {
        System.out.println(name + "路上走");
    }
}

3. 基于方法

  • 当逻辑足够简单或者类中方法较少时，可以不在类上，而是在方法上遵循单一职责原则
package com.design.pattern.day01;

public class Demo01 {
    public static void main(String[] args) {
        Vehicle plane = new Vehicle("飞机");
        plane.fly();

        Vehicle boot = new Vehicle("轮船");
        boot.swim();

        Vehicle bike = new Vehicle("自行车");
        bike.walk();
    }
}

class Vehicle {

    private String name;

    public Vehicle(String name) {
        this.name = name;
    }

    public void fly() {
        System.out.println(name + "在天上飞");
    }

    public void swim() {
        System.out.println(name + "在水里游");
    }

    public void walk() {
        System.out.println(name + "在路上走");
    }
}

二、Interface Segregation Principle

  • 一个类对另外一个类的依赖，应该建立在最小接口的原则上

1. 传统模式

package com.design.pattern.day01;

public class Demo03 {
    public static void main(String[] args) {
        /**
         * 1. SportStarManager和SingerStarManager基于接口Star
         *    分别依赖于SingerStar和SportStar
         *    
         * 2.  但是接口的所有功能混杂在一起，就导致了不恰当的方法调用
         *     SportStarManager能调用到 sing()
         *     SingerStarManager能调用到 playBall()
         */
    }
}

class SportStarManager {
    private Star star;

    public SportStarManager(Star star) {
        this.star = star;
    }

    public void dailyWork() {
        star.eat();
        star.sleep();
        star.drink();
        star.playBall();

        star.sing();
    }
}

class SingerStarManager {
    private Star star;

    public SingerStarManager(Star star) {
        this.star = star;
    }

    public void dailyWork() {
        star.drink();
        star.eat();
        star.sleep();
        star.sing();

        star.playBall();
    }
}

class SingerStar implements Star {

    @Override
    public void eat() {
        System.out.println("刘德华吃饭");
    }

    @Override
    public void sleep() {
        System.out.println("刘德华睡觉");
    }

    @Override
    public void drink() {
        System.out.println("刘德华喝水");
    }

    @Override
    public void sing() {
        System.out.println("刘德华唱歌");
    }

    @Override
    public void playBall() {
        System.out.println("刘德华能打球吗？");
    }
}

class SportStar implements Star {

    @Override
    public void eat() {
        System.out.println("李宁吃饭");
    }

    @Override
    public void sleep() {
        System.out.println("李宁睡觉");
    }

    @Override
    public void drink() {
        System.out.println("李宁喝水");
    }

    @Override
    public void sing() {
        System.out.println("李宁能唱歌吗？");
    }

    @Override
    public void playBall() {
        System.out.println("李宁打球");
    }
}

interface Star {
    void eat();

    void sleep();

    void drink();

    void sing();

    void playBall();
}

2. Interface Segregation Principle

  • 不同功能类型的接口，应该将大接口拆开若干个小的接口
  • 通过一个类来继承公共的接口和各自类型的接口
package com.design.pattern.day01;

public class Demo03 {
    public static void main(String[] args) {
        // 不同功能的接口，应该将大的接口拆开若干个小的接口
    }
}

class SportStarManager {
    private SportStar sportStar;

    public SportStarManager(SportStar sportStar) {
        this.sportStar = sportStar;
    }

    public void dailyWork() {
        sportStar.drink();
        sportStar.eat();
        sportStar.sleep();
        sportStar.playBall();
    }
}

class SingerStarManager {
    private SingerStar singerStar;

    public SingerStarManager(SingerStar singerStar) {
        this.singerStar = singerStar;
    }

    public void dailyWork() {
        singerStar.sing();
        singerStar.drink();
        singerStar.sleep();
        singerStar.eat();
    }
}

class SingerStar implements Star, SingerStartInter {

    @Override
    public void eat() {
        System.out.println("刘德华吃饭");
    }

    @Override
    public void sleep() {
        System.out.println("刘德华睡觉");
    }

    @Override
    public void drink() {
        System.out.println("刘德华喝水");
    }

    @Override
    public void sing() {
        System.out.println("刘德华唱歌");
    }

}

class SportStar implements Star, SportStarInter {

    @Override
    public void eat() {
        System.out.println("李宁吃饭");
    }

    @Override
    public void sleep() {
        System.out.println("李宁睡觉");
    }

    @Override
    public void drink() {
        System.out.println("李宁喝水");
    }

    @Override
    public void playBall() {
        System.out.println("李宁打球");
    }
}

interface SportStarInter {
    void playBall();
}

interface SingerStartInter {
    void sing();
}

interface Star {
    void eat();

    void sleep();

    void drink();
}

三、Dependence Inversion Principle

  • 高层模块不应该依赖低层模块，二者都应该依赖抽象类
  • 抽象不应该依赖细节，细节应该依赖抽象
  • 中心思想：面向接口编程
  • 抽象的(抽象类或接口)相比细节(实现类)要稳定
  • 接口或者抽象类：提前指定好规范，不涉及具体操作，具体操作由实现类

1. 传统方式

package com.design.pattern.day01;

public class Demo04 {
    /**
     *  如果要增进新的通讯方式
     *  1. 添加新的通讯类
     *  2. 执行类中添加新的方法
     *  3. 客户端不能定义其他的通讯方式
     */
}

class SendService {
    public void sendEmail(Email email) {
        email.contactCustomer();
    }

    public void sendPush(Push push) {
        push.contactCustomer();
    }

    public void sendSms(Sms sms) {
        sms.contactCustomer();
    }
}

class Email {
    public void contactCustomer() {
        System.out.println("email to contact customer");
    }
}

class Push {
    public void contactCustomer() {
        System.out.println("push to contact customer");
    }
}

class Sms {
    public void contactCustomer() {
        System.out.println("sms to contact customer");
    }
}

2. 改进方式

package com.design.pattern.day01;

public class Demo04 {
    /**
     *  如果要增进新的通讯方式
     *  1. 添加新的通讯类
     *  2. 执行类中添加新的方法
     *  3. 客户端不能定义其他的通讯方式
     */
}

class SendService {
    public void sendEmail(Email email) {
        email.contactCustomer();
    }

    public void sendPush(Push push) {
        push.contactCustomer();
    }

    public void sendSms(Sms sms) {
        sms.contactCustomer();
    }
}

class Email {
    public void contactCustomer() {
        System.out.println("email to contact customer");
    }
}

class Push {
    public void contactCustomer() {
        System.out.println("push to contact customer");
    }
}

class Sms {
    public void contactCustomer() {
        System.out.println("sms to contact customer");
    }
}

3. 依赖注入方式

  • 依赖倒置原则（Dependency Inversion Principle）提供了降低模块间耦合度的一种思路
  • 依赖注入（Dependency Injection）是一种具体的实施方法
3.1 接口参数传递
public class Demo04 {
    public static void main(String[] args) {
        new SendService().send(new Sms());
        new SendService().send(new Email());
        new SendService().send(new Push());
        new SendService().send(() -> System.out.println("other way to contact customer"));
    }
}

class SendService {

    public void send(CommunicateTools tool) {
        tool.contactCustomer();
    }
}
3.2 构造器
class SendService {

    private CommunicateTools tool;

    // 构造器注入
    public SendService(CommunicateTools tool) {
        this.tool = tool;
    }

    public void send() {
        tool.contactCustomer();
    }

}
3.3 setter方法
public class Demo04 {
    public static void main(String[] args) {
        SendService pushService = new SendService();
        pushService.setTool(new Push());
        pushService.send();

        SendService emailService = new SendService();
        emailService.setTool(new Email());
        pushService.send();

        SendService smsService = new SendService();
        smsService.setTool(new Sms());
        pushService.send();

        SendService other = new SendService();
        other.setTool(() -> System.out.println("其他方式联系客户"));
        other.send();
    }
}

class SendService {

   // 通过set方法注入
    private CommunicateTools tool;

    public void setTool(CommunicateTools tool) {
        this.tool = tool;
    }

    public void send() {
        tool.contactCustomer();
    }
}

四、Liskov Substitution Principle

  • 使用基类的地方，必须能够透明的使用子类
  • 方式：子类中尽量不要重写父类的方法
  • 继承时，子类无意识的重写父类方法，使得继承体系脆弱，一般是将两个类的公共部分抽取成更高层，然后让这两个类通过聚合，组合等实现

1. 子类重写父类

package com.day.dreamer.seven.liskvo;

public class TraditionalLiskvo {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.eat();

        /**
         * 由于子类无意识情况下
         * 重写了父类的方法，因此调用的时候用的是子类的方法
         */
        Cat cat = new Cat();
        cat.eat();
    }
}

class Animal{
    public void eat(){
        System.out.println("动物吃食物");
    }
}

class Cat extends Animal{
    /**
     * 子类中无意识的情况下，将父类的方法进行了重写
     */
    public void eat(){
        System.out.println("猫吃鱼");
    }
}

2. Extract改进

package com.day.dreamer.seven.liskvo;

public class ImprovedLiskvo {
    public static void main(String[] args) {
        Cycle cycle = new Cycle();
        cycle.function();

        Bicycle bicycle = new Bicycle(cycle);
        bicycle.function();
    }
}

/**
 * 将此类提为基类，然后下面两个类脱离继承关系
 */
class Base{
    public void work(){
        System.out.println("测试方法");
    }
}

class Cycle extends Base{
    public void function(){
        System.out.println("交通工具：正常使用");
    }
}

class Bicycle extends Base{
    private Cycle cycle;

    /**通过组合的方式来进行*/
    public Bicycle(Cycle cycle){
        this.cycle = cycle;
    }

    public void function(){
        cycle.function();
        System.out.println("自行车：正常使用");
    }
}

五、Open Close Principle

  • 一个类/方法，对修改关闭(consumer)，对扩展(provider)开放。抽象搭建架构，实现做具体事情
  • 对provider而言，新的功能，最好通过扩展而不是修改的方式实现，这样就不需要测试之前代码
  • 其他所有设计原则，设计模式，最终就是要达到开放扩展模式
  • 说白了：面向接口编程

1. 传统方式

package com.design.pattern.day01;

/**
 * 如果增加新的类型，则
 * 1.  增加新的类
 * 2.  新的画图的方法
 * 3.  修改原来的drawShape代码
 */

public class Demo06 {
    public static void main(String[] args) {
        DrawShape tool = new DrawShape();
        tool.drawShape(new Square());
        tool.drawShape(new Triangle());
    }
}

class DrawShape {

    public void drawShape(Shape shape) {
        if (shape.type == 1) {
            drawSquare();
        } else if (shape.type == 2) {
            drawTriangle();
        }
    }

    public void drawSquare() {
        System.out.println("画正方形");
    }

    public void drawTriangle() {
        System.out.println("画三角形");
    }
}

class Square extends Shape {

    private int squareType = 1;

    public Square() {
        super.type = squareType;
    }
}

class Triangle extends Shape {

    private int triangleType = 2;

    public Triangle() {
        super.type = triangleType;
    }
}

class Shape {
    public int type;
}

2. 改进-基于接口

package com.design.pattern.day01;

public class Demo06 {
    public static void main(String[] args) {
        DrawShape tool = new DrawShape();
        tool.drawShape(new Triangle());
        tool.drawShape(new Square());

        // 自定义新的
        tool.drawShape(new Shape() {
            @Override
            public void draw() {
                System.out.println("画其他图形");
            }
        });
    }
}

class DrawShape {

    public void drawShape(Shape shape) {
        shape.draw();
    }


}

class Square implements Shape {


    @Override
    public void draw() {
        System.out.println("画正方形");
    }
}

class Triangle implements Shape {

    @Override
    public void draw() {
        System.out.println("画三角形");
    }
}

interface Shape {
    void draw();
}

六、Demeter Principle

  • 一个对象应该对其他对象保持最少的了解
  • 一个类应该尽可能对外少暴露信息
  • 陌生的类，应该通过成员变量，方法参数，方法返回值，而不是局部变量出现在当前类中

七、Composite Reuse Principle

  • 尽量使用合成/聚合的方式，而不是继承
飞翔荷兰号
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
yoyiyi#SoleilNotes#001.设计模式七大原则1
07-25
2.1 单一职责原则 2.2 接口隔离原则 2.3 依赖倒置原则 2.4 里式替换原则 2.5 开闭原则 2.6 迪米特原则 2.7 合成复用原则
第一章设计模式与七大原则.doc
02-28
设计模式是软件工程中的一种重要思想，它是经验丰富的软件开发者在实践中提炼出来的一套解决方案模板。...在实际开发中，选择合适的设计模式和遵循设计原则，可以帮助我们构建出更加优雅、可扩展的系统。
设计模式学习笔记（二十五）：模板方法模式
氷泠
08-05 271
1 概述 1.1 引言 1.2 定义 1.3 结构图 1.4 角色 1.5 模板方法与基本方法 1.5.1 模板方法 1.5.2 基本方法 2 典型实现 2.1 步骤 2.2 抽象类 2.3 具体子类 3 实例 4 使用钩子方法 5 主要优点 6 主要缺点 7 适用场景 8 总结 ...
抽取公共类思想
qq_36654606的博客
01-29 959
问题出现场景 项目进行时，随着代码量的不断增加，会出现很多重复写的代码，代码完全一致，但是重复写了很多遍，因此考虑提取大家都需要用到的部分，抽取出来作为单独的一个部分，其他部分需要用到这部分代码时候，调用即可。 不同的模块抽取的格式不尽相同，但是核心思想都一样，抽取重复率高的部分，从而达到减少写代码的目的 抽取公共类案例 Servlet抽取公共类 首先是与之前做的简单的Javaweb管理系...
093-_抽取方法到公共的类中，解决多个类要使用相同的方法的问题.-【视频讲解】
火娃的专栏
04-20 738
点击查看视频讲解 问题：一个类中不能直接使用其他类的函数；如何解决这个问题？ 解决办法：Java中通过类名.函数名(实参)的方式，可以调用其他类中的函数； 本类中： 方法放在了Tools.java这个类中； 在其他类中要想调用，应该这么写： Tools.arrayMax(具体的数组); 像最后这种方式，就使用了面向对象的思想； ...
详细介绍设计模式七大原则
m0_54187478的博客
02-19 2244
单一职责原则：一个类应该只有一个引起它变化的原因。开闭原则：软件实体应对扩展开放，对修改封闭。里氏替换原则：子类型必须能够替换掉它们的基类型。依赖倒置原则：高层模块不应依赖于低层模块，两者都应依赖于抽象；抽象不应依赖于细节，细节应依赖于抽象。接口隔离原则：使用多个专门的接口比使用单一的总接口更好。合成/聚合复用原则：尽量使用对象的组合/聚合，而不是继承关系达到复用的目的。迪米特法则（最少知道原则）：一个对象应对其他对象有尽可能少的了解。
设计模式七大原则（案例解析）
Android系统优化
11-25 3760
一、 设计模式的目的 编写软件过程中，程序员面临着来自 耦合性，内聚性以及可维护性，可扩展性，重用性，灵活性 等多方面的挑战，设计模式是为了让程序(软件)，具有更好 1) 代码重用性 (即：相同功能的代码，不用多次编写) 2) 可读性 (即：编程规范性, 便于其他程序员的阅读和理解) 3) 可扩展性 (即：当需要增加新的功能时，非常的方便，称为可维护) 4) 可靠性 (即：当我们增加新的功能后，对原来的功能没有影响) 5) 使程序呈现高内聚，低耦合的特性 二. 设计模式七大原则 ...
Java23种设计模式6大原则总结.doc
11-24
设计模式可以分为三大类：创建型模式、结构型模式、行为型模式。 创建型模式的主要功能是封装创建逻辑，使得客户代码尽量不修改或少修改。常见的创建型模式有单例模式、工厂方法模式、抽象工厂模式、建造者模式、...
12-附录 1 设计模式的七大原则(1).html
04-01
在书中，作者们将这二十三种设计模式分成了三类，分别是创建型模式、结构型模式和行为型模式。 创建型模式包含了： 工厂方法模式（ Factory Method ） 抽象工厂模式（ Abstract Factory ） 单例模式（ Singleton ...
24种设计模式与6大设计原则
最新发布
04-19
#### 七大设计原则 1. **单一职责原则**：一个类只负责一个功能领域中的相应职责。 2. **里氏替换原则**：所有引用基类的地方必须能透明地使用其子类的对象。 3. **依赖倒置原则**：高层模块不应该依赖低层模块，...
设计模式——依赖注入
weixin_49547540的博客
03-01 523
面向对象OOP的一种思想，控制反转（Spring框架IOC容器）：借助第三方来解耦。 控制反转的一种设计模式：依赖注入 依赖注入：非自己主动初始化依赖，而通过外部来传入依赖的方式 // 在types.d.ts定义接口 export interface IUserData { id: number title: string timestamp: string | number platforms: string[] disableComment: boolean } // 使用 imp
职责链模式-Chain of Responsibility Pattern
weixin_43374578的博客
03-11 5403
一、状态模式 二、策略模式 1. JDBC案列查询 接口 接口负责数据的转换，具体怎么转换，需要开发者自己实现； package com.day.dreamer.thread.day01; import java.sql.ResultSet; /** * @author EShu */ public interface IHandleResult<T> { /** * 1. 使用范形，保证返回的值为任意类型 * 具体是什么样子，自己去手动实现
中介者模式-Mediator Pattern
weixin_43374578的博客
03-13 705
提供一个中介类，中介类和具体的子系统类进行交互，避免了子系统之间的直接交互 比如MVC中的controller层，可以来调用不同的service来完成业务 package com.nike.erick.meditor; import java.util.Date; import java.util.HashMap; import java.util.Map; public class Test { public static void main(String[] args) { .
装饰器模式-Decorator Pattern
weixin_43374578的博客
03-13 254
允许向一个现有的对象添加新的功能，同时又不改变其结构 创建一个装饰类，包装原有的类，并在保持类方法签名完整性的前提下，提供额外功能 动态地给一个对象添加一些额外的职责。就增加功能来说，装饰器模式相比生成子类更为灵活 装饰模式是继承的一个替代模式，装饰模式可以动态扩展一个实现类的功能 继承加组合 - 静态代理和装饰者模式的实现过程本质上没什么区别 - 装饰者模式只是为了增强原对象的方法；而代理模式主要是为了控制对象的访问 package com.nike.erick.decorator; public.
观察者模式-Observer Pattern
weixin_43374578的博客
03-12 249
一、迭代器 二、观察者 当对象间存在一对多关系时，则使用观察者模式 当一个对象被修改时，则会自动通知依赖它的对象 三、中介者 提供一个中介类，中介类和具体的子系统类进行交互，避免了子系统之间的直接交互 比如MVC中的controller层，可以来调用不同的service来完成业务 package com.nike.erick.meditor; import java.util.Date; import java.util.HashMap; import java.util.Map; public
组合模式-Composite Pattern
weixin_43374578的博客
03-13 215
如树形菜单，文件、文件夹的管理 package com.nike.erick.combine; import lombok.ToString; import java.util.ArrayList; import java.util.List; public class Test { public static void main(String[] args) { Employee ceo = new Employee("lucy", "A", 10000); .
java 设计模式 七大原则
09-14
Java设计模式的七大原则包括： 1) 单一职责原则：一个类应该只有一个引起变化的原因，即一个类应该只有一个职责。 2) 接口隔离原则：客户端不应该依赖它不需要的接口。应该将接口细分为更小的接口，以便于客户端只...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值