每日设计模式-设计原则

最新推荐文章于 2024-07-18 16:31:10 发布
最新推荐文章于 2024-07-18 16:31:10 发布
阅读量78 收藏
点赞数
分类专栏： 学习 文章标签： java 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_20060031/article/details/103208960
版权

单一职责原则

基本介绍

对于类来说，一个类应该负责单一项职责。如果存在一个类A负责两个不同的职责，职责1和职责2。当职责1需求发生变化而改变A时，职责2执行错误，这个时候需要将A分解为A1和A2

代码实现

基础版本

package single.responsibility;

public class Index {
    public static void main(String[] args) {
        Vehicle vehicle = new Vehicle();
        vehicle.run("飞机");
        vehicle.run("轮船");
        vehicle.run("汽车");
    }
}
class Vehicle{
    public Vehicle(){

    }
    public void run(String name){
        System.out.println(name + " 运行在路上");
    }
}

输出结果

飞机 运行在路上
轮船 运行在路上
汽车 运行在路上

在Vehicle中，很明显的没有遵守单一职责原则。run方法中适配了所有的情况，不方便于修改

修改方式1

public class Index {
    public static void main(String[] args) {
        Vehicle aircraft = new Aircraft();
        aircraft.run("飞机");
        Vehicle car = new Car();
        car.run("汽车");
        Vehicle ship = new Ship();
        ship.run("轮船");
    }
}

class Vehicle {
    public Vehicle() {

    }

    public void run(String name) {

    }
}

class Car extends Vehicle {
    @Override
    public void run(String name) {
        System.out.println(name + "运行在路上");
    }
}

class Ship extends Vehicle {
    @Override
    public void run(String name) {
        System.out.println(name + "运行在海上");
    }
}

class Aircraft extends Vehicle {
    @Override
    public void run(String name) {
        System.out.println(name + "运行在天上");
    }
}

这种修改方式遵循了单一职责原则，但是缺点是代码量暴增，需要程序员维护的类也对应的变多了。

修改方式2

public class Index {
    public static void main(String[] args) {
        Vehicle vehicle = new Vehicle();
        vehicle.runInSea("飞机");
        vehicle.runInAir("轮船");
        vehicle.runInRoad("汽车");
    }
}

class Vehicle {
    public Vehicle() {

    }

    public void runInRoad(String name) {
        System.out.println(name + " 运行在路上");
    }

    public void runInSea(String name) {
        System.out.println(name + " 运行在海上");
    }

    public void runInAir(String name) {
        System.out.println(name + " 运行在天上");
    }
}

严格来说，这一种修改方式没有完全遵循单一职责原则。但是它将可能依赖在一起的代码隔离开。相对第一种方式而言，第二种需要维护的代码减少。

注意事项以及相关细节

  • 降低类的复杂度，一个类只负责一项职责
  • 提高类的可读性，可维护性
  • 降低变更引起的风险
  • 通常情况下，我们应当遵守单一职责原则。以下两种情况例外
    • 当逻辑足够简单时，可以在代码级别违反单一职责原则
    • 当类中方法数量足够少，可以在方法级别保持单一职责原则

接口隔离原则

基本介绍

​ 客户端不应该依赖它不需要的接口，即一个类对另一个依赖应该建立在最小的接口上。

​ 其实通俗来理解就是，不要在一个接口里面放很多的方法，这样会显得这个类很臃肿不堪。接口应该尽量细化，一个接口对应一个功能模块，同时接口里面的方法应该尽可能的少，使接口更加轻便灵活。或许看到接口隔离原则这样的定义很多人会觉得和单一职责原则很像，但是这两个原则还是有着很鲜明的区别。接口隔离原则和单一职责原则的审视角度是不同的，单一职责原则要求类和接口职责单一，注重的是职责，是业务逻辑上的划分，而接口隔离原则要求方法要尽可能的少，是在接口设计上的考虑。例如一个接口的职责包含10个方法，这10个方法都放在一个接口中，并且提供给多个模块访问，各个模块按照规定的权限来访问，并规定了“不使用的方法不能访问”，这样的设计是不符合接口隔离原则的，接口隔离原则要求“尽量使用多个专门的接口”，这里专门的接口就是指提供给每个模块的都应该是单一接口(即每一个模块对应一个接口)，而不是建立一个庞大臃肿的接口来容纳所有的客户端访问。

举个栗子

现有A,B,C,D四个类均实现interface1。其中A只需要方法1，B只需要方法2，C只需要方法3，D只需要方法45。这个时候对于他们而言，interface1中的除却需要的方法，其他的方法均毫无用处。

解决方案是，将接口interface1拆分成几个接口。以上述栗子，需要拆分成四个接口，A,B,C,D分别实现对应接口即可

依赖倒转原则

基本介绍

  • 中心思想是面向接口编程
  • 相对于细节的多变性，抽象的东西是要稳定的多。以抽象为基础搭建的架构比以细节为基础的架构要稳定的多。
  • 使用接口或者抽象类的目的是为了制定要规范，而不涉及任何具体的操作，把展现细节的任务交给他们的实现类去完成

举个栗子

基础实现

public class Main {

    public static void main(String[] args) {
        Person person = new Person();
        person.receive(new Email());

    }
}

class Email{
    public void getInfo(){
        System.out.print("收到邮件");
    }
}

class Person{
    public void receive(Email email){
        email.getInfo();
    }
}

在这个栗子中，需求是，用户需要接受邮件。上述代码在简单实现的同时，也带了无法拓展的问题。试想一下，如果我们有了新的需求，用户需要接受微信、QQ或者其他的信息呢？我们难道要在Person中定义很多个接受方法吗?

优化代码

public class Main {

    public static void main(String[] args) {
        Person person = new Person();
        IReceive email = new Email();
        person.receive(email);

    }
}
interface IReceive{
    void getInfo();
}

class Email implements IReceive{
    public void getInfo(){
        System.out.print("收到邮件");
    }
}

class Person{
    public void receive(IReceive iReceive){
        iReceive.getInfo();
    }
}

优化的思路很简单。我们定义一个接受接口IReceive,如此一来即便我们有了其他的需求，只要实现IReceive即可。

接口传递方式

  • 方法参数传递
  • 构造方法传递
    • 定义一个接口变量，在构造方法中初始化
  • setter方式传递
    • 定义一个接口变量，使用setter方式初始化

注意事项

  • 底层模块尽量都要有抽象类或者接口
  • 变量声明进行使用抽象类或者接口，这样我们变量引用和实际对象之间存在一层缓冲层，便于程序优化和拓展。换句话说，尽量多的使用多态
  • 继承时应该遵顼里氏替换原则

里氏替换原则

继承性的思考和说明

  • 继承包含一层含义，父类中凡是已经实现好的方法，实际上是在设定规范和契约，所以它不强制所有的子类必须遵循这些契约，但是如果子类对这些已经实现的方法任意修改，就会对整个体系造成破环
  • 继承在给程序设计带来了便利的同时，也带来了弊端。比如继承会给程序带来侵入性，程序的可移植性降低，增加对象间的耦合性。

基本概念

  • 如果对每个类型为T1的对象o1，都有类型为T2的对象o2，使得以T1定义的所有程序P在所有的对象o1都替换成o2时，程序P的行为没有发生变化，那么类型T2是类型T1的子类型。换句话说，所有引用基类的地方必须可以透明的使用其子类对象
  • 在使用继承时，遵顼里氏替换原则，在子类尽量不要重写父类的方法
  • 里氏替换原则高速我们，继承实际上让两个类的耦合性增加了，在适当的情况下，可以通过聚合，组合，依赖来解决问题

开闭原则

基本介绍

  • 编程中最基础，最重要的设计原则
  • 一个软件实体如类，模块和函数应该对扩展开发，对修改关闭。用抽象构建框架，用实现拓展细节
  • 当软件需要发生变化时，尽量通过拓展软件实体的行为来实现变化，而不是通过修改已有的代码
  • 编程中遵循其他原则，以及使用设计模式的目的时为了遵循开闭原则
  • 面向接口编程

迪米特法则

基本介绍

  • 一个对象应该对其他对象保持最小的了解
  • 类与类之间的关系越密切，耦合度越大
  • 迪米特法则又叫最小知道原则，即一个类对自己依赖的类知道的最少越好。
  • 更简单的定义，只是与直接朋友通信
    • 直接朋友：每个对象都会与其他对象存在耦合关系。只要两个对象存在耦合关系，我们称两个对象之间是朋友关系。耦合的方式有很多，依赖，关联，组合，聚合等。其中，我们称成员变量，方法参数，方法返回值中的类为直接朋友，而出现在局部变量中的类不是直接朋友
  • 陌生的类最好不要以局部变量的形式出现在类的内部

举个栗子

基本代码

假设现在有一个需求，需要打印学院员工与普通员工的相关信息。

import java.util.ArrayList;
import java.util.List;

public class Main {

    public static void main(String[] args) {
        CollegeEmployeeMgt collegeEmployeeMgt = new CollegeEmployeeMgt();
        collegeEmployeeMgt.printInfo(new EmployeeMgt());

    }
}

class Employee {
    public Employee(int id) {
        this.id = id;
    }

    int id;
}
class CollegeEmployee {
    public CollegeEmployee(int id) {
        this.id = id;
    }

    int id;
}

class EmployeeMgt{
    public List<Employee> generateEmployee(){
        List<Employee> result  = new ArrayList<>();
        for (int i = 0 ;i < 10 ; i ++){
            result.add(new Employee(i));
        }
        return result;
    }
}

class CollegeEmployeeMgt{
    public List<CollegeEmployee> generateEmployee(){
        List<CollegeEmployee> result  = new ArrayList<>();
        for (int i = 0 ;i < 5 ; i ++){
            result.add(new CollegeEmployee(i));
        }
        return result;
    }

    public void printInfo(EmployeeMgt employeeMgt){
        List<Employee> employees = employeeMgt.generateEmployee();
        for (Employee employee : employees){
            System.out.println("employee" + employee.id);
        }
        System.out.println("--------------------");
        List<CollegeEmployee> collegeEmployees = generateEmployee();
        for (CollegeEmployee employee : collegeEmployees){
            System.out.println("collegeEmployees" + employee.id);
        }
    }
}

这段代码的坏味道在哪呢？在printInfo这个方法中出现了Employee。这个变量在CollegeEmployeeMgt类中属于局部变量，而它的作用仅仅只是为了打印。

优化代码

public class Main {

    public static void main(String[] args) {
        CollegeEmployeeMgt collegeEmployeeMgt = new CollegeEmployeeMgt();
        collegeEmployeeMgt.printInfo(new EmployeeMgt());

    }
}

class Employee {
    public Employee(int id) {
        this.id = id;
    }

    int id;
}
class CollegeEmployee {
    public CollegeEmployee(int id) {
        this.id = id;
    }

    int id;
}

class EmployeeMgt{
    public List<Employee> generateEmployee(){
        List<Employee> result  = new ArrayList<>();
        for (int i = 0 ;i < 10 ; i ++){
            result.add(new Employee(i));
        }
        return result;
    }

    public void printInfo(){
        List<Employee> employees = generateEmployee();
        for (Employee employee : employees){
            System.out.println("employee" + employee.id);
        }
    }
}

class CollegeEmployeeMgt{
    public List<CollegeEmployee> generateEmployee(){
        List<CollegeEmployee> result  = new ArrayList<>();
        for (int i = 0 ;i < 5 ; i ++){
            result.add(new CollegeEmployee(i));
        }
        return result;
    }

    public void printInfo(EmployeeMgt employeeMgt){
        employeeMgt.printInfo();
        System.out.println("--------------------");
        List<CollegeEmployee> collegeEmployees = generateEmployee();
        for (CollegeEmployee employee : collegeEmployees){
            System.out.println("collegeEmployees" + employee.id);
        }
    }
}

优化思路便是新增EmployeeMgt.printInfo方法用于隐藏相关的打印信息

注意事项

  • 核心是降低类之间的耦合
  • 迪米特法则只是要求降低耦合，并不是要求完全没有耦合

合成复合原则

基本介绍

  • 尽量使用合成/聚合的方式，而不是继承

设计原则核心思想

  • 找出应用中可能变化的代码，将他们独立起来，不要和不需要变化的代码混在一起
  • 针对接口编程而不是针对实现编程
  • 为了交互对象之间的松耦合设计而努力
zhiweiHong
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java 接口 this参数_java基础学习笔记二（接口、super、this）
weixin_34471172的博客
02-22 632
一、super 和 this的用法主要解释一下引用构造函数的用法super(参数)：调用父类中的某一个构造函数(应该为构造函数中的第一条语句)this(参数)：调用本类中另一种形式的构造函数(应该为构造函数中的第一条语句)实例class Person {public static void prt(String s) {System.out.println(s);}Person() {prt("父...
设计模式之设计原则
崔成龙 . 勇往直前
11-03 1971
设计模式（Design Pattern）是面向对象技术的最新进展之一，由于面向对象设计的灵活性，增加了其设计的复杂性，设计模式的出现就是为了提高复用的设计方案，让代码更容易被他人理解、保证代码可靠性。设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。        要想用好设计模式，必须先明白设计模式的六大原则：单一职责原则、开
编程之道-IOS设计模式解析[www.xiandoudou.com]
05-21
本书着重讲解了面向对象设计原则，如单一职责原则、开闭原则、里氏替换原则、依赖倒置原则和接口隔离原则。这些原则是设计模式的基础，为构建高质量的iOS应用程序提供了理论支持。 书中详细介绍了多种iOS设计模式，...
c++课程设计-个人收支管理系统.zip
04-23
【标签】中的"源码"表明这个压缩包包含了项目的原始代码文件，学生或开发者可以通过阅读和分析这些源码，学习C++编程技巧，理解面向对象设计原则，以及如何将这些理论应用到实际的项目开发中。"c++ 课程设计"则说明...
《JavaSE》---6.＜基础语法（Java三大程序控制结构）＞
m0_73456341的博客
07-14 819
本篇博客主要讲解Java基础语法中的三大结构，一种顺序结构、两大分支结构i（if-else、swich-case）、四大循环结构（while、do while、fot、foreach）
Spring Security 授权
persistence_PSH的博客
07-14 888
在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。通过 RBAC 获取到用户的具体权限后，再通过 Security 的 用户-权限-资源 来进行权限控制。HttpSecurity 权限配置。
【Go系列】 Sync并发控制
u013379032的博客
07-14 1018
在上一篇文章中，我们介绍了goroutine和channel，理论上，通过channel可以实现并发控制，但是其他语言的开发者可能更习惯一些原子操作的库。当然Go语言也会提供这样的库，所以我们今天了解一下sync库。
day04：Redis和店铺营业状态设置
m0_69266818的博客
07-15 824
介绍了Redis命令和用java操作redis还有营业额状态接口的书写
【JAVA】相关程序组件
qq_44077764的博客
07-15 153
【JAVA】相关程序组件
【Java算法】前缀和 下
2302_79806056的博客
07-18 681
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
maven项目容器化运行之1-基于1Panel软件将docker镜像构建能力分享给局域网
qq_37372909的博客
07-15 511
docker核心功能包括镜像的构建和容器的运行，它可以开放端口将镜像构建的能力暴露。docker daeson就是docker的守护进程，开放能力是通过指定docker守护进程监听端口来实现的。后面开发人员就可以通过maven中docker插件来远程调用docker镜像构建能力了。
深入剖析 Java 中 Spring Bean 的生命周期
weixin_42545951的博客
07-12 702
在 Java 开发中，Spring 框架是广泛使用的企业级应用开发框架。理解 Spring Bean 的生命周期对于开发者来说至关重要，这也是面试中经常会被问到的重要知识点。
从零手写实现 nginx-27-return 指令
07-14 666
大家好，我是老马。很高兴遇到你。我们为 java 开发者实现了 java 版本的 nginx如果你想知道 servlet 如何处理的，可以参考我的另一个项目：手写从零实现简易版 tomcatminicat。
Java实验2
qq_64727229的博客
07-16 513
类的封装、继承、多态和接口（1）有理数四则运算（2）最终得分
Java：ThreadPoolExecutor线程池知识体系
彭世瑜的博客
07-15 409
ThreadPoolExecutor的构造方法。固定大小线程数的线程池。
《简历宝典》15 - 简历中“项目经历”，实战讲解，Java篇
xingyu_qie的专栏
07-18 147
校招和初级Java开发的项目经历重点是突出自己在实战中的学习。比如对数据库的操作，比如前后端联调工作中遇到问题的解决，比如一些Java基础知识点的逐渐深入掌握，这些都是这个阶段的Java开发需要去不断增强的。和初级前端开发类似，例如你作为一名初级Java开发，负责的是校园图书管理系统的图书信息上传，图书信息管理这个模块的服务端开发，项目经历可以这样编写，如图。
码农生涯问题杂记
qq_38189542的博客
07-18 99
Q：工作中需要测试一个JNA程序，想着Windows方便，所以就在Windows进行动态库的编译，然后在编译过程中，对应的代码在Linux系统GCC编译是成功的，但是在Windows下死活报错，而且报的错莫名其妙。A：后面经过测试，Vistual Studio在UTF8编码下，对中文支持很糟糕，导致编译的时候，语法解释出错，从而就出现一大堆乱七八糟让人摸不着头脑的错误。后面删除代码中的中文注释，编译成功。
python--实验14 并发编程（多线程）
最新发布
wumingzei的博客
07-18 580
定义通过声明Thread的派生类，创建一个子类，并重写对象的run方法，然后创建其对象实例，可创建线程。通过对象的start方法，可启动线程，并自动执行对象的run方法。注意子类的构造器一定要先调用基类的构造器直接将线程需要做的事写到run方法中示例。
Spring Boot集成groovy快速入门Demo
HBLOG
07-14 1019
Groovy 是构建在 JVM 上的一个轻量级却强大的动态语言，它结合了 Python、Ruby 和 Smalltalk 的许多强大的特性。Groovy 就是用 Java 写的，Groovy 语法与 Java 语法类似，Groovy 代码能够与 Java 代码很好地结合，也能用于扩展现有代码。相对于 Java，它在编写代码的灵活性上有非常明显的提升，Groovy 可以使用其他 Java 语言编写的库。Groovy 是增强 Java 平台的唯一的脚本语言。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值