设计模式7大原则——开闭&单一职责&里氏替换

瑞芯微RK3588开发板VSCode远程开发全攻略:从SSH配置到插件优化 本文详细介绍了如何在瑞芯微RK3588开发板上配置VSCode远程开发环境。从Ubuntu系统下的SSH服务设置、VSCode Remote-SSH扩展安装,到连接建立、基础工具链部署,再到针对ARM平台的性能优化与调试配置,提供了一套完整的实战指南,帮助开发者高效利用本地资源进行嵌入式开发。 阅读详情

原则一:开闭原则(总纲和核心)

开闭原则规定软件中的对象(类、模块、函数等)对扩展开放,对修改封闭。也就是说针对需求的修改,我们要用扩展来实现,而不是通过修改已有代码来实现。

为了方便大家理解,我用王者荣耀来举例,王者荣耀中这么多英雄,如果把所有英雄都集中在一个类中来实现那是不现实的。你想想每次增加新英雄或者修改英雄的属性都要修改这一个类,那程序员还不疯了!时间长了,里面的逻辑之复杂,功能之紊乱真会要人命的。因此英雄联盟每次增加新英雄都会扩展增加一个新英雄类,这个新英雄类当然是继承“抽象英雄类”,然后实现里面的方法来定制自己的属性和功能。这就是对扩展开放,而修改关闭。

优点

(1).方便测试。我们只能以新增加的类进行测试,而不需要管其他的类。

(2).提高复用性。我们把功能拆分成一个一个小功能,是方便我们重复使用的。

(3).提高可维护性。想一下:如果有需求增加或者修改,你是希望重新扩展个类重新写呢?还是阅读别人的代码修改逻辑?

(4).符合面向对象的开发要求。

原则二:单一职责原则

“不要让类太累!”。单一职责原则规定一个类只有一个职责。如果有多个职责(功能)被设计在一个类中,这个类就违反了单一职责原则。其实这不难理解,生活中我们也是这样:专门人做专业事,即使放到公司和国家中也是这样。都会分好几个部门来处理不同的事情,不可能一个部门处理公司所有事情。

优点

(1).类的复杂性降低了,各个类都有明确清晰的职责。

(2).类的可读性提高了,我就见过这么一个同事,把好多的逻辑处理都放在一个方法中完成,看着那好几百行的方法,我真想打死他。

(3).可维护性提高了,类的功能简单了,可读性高了,自然可维护性就提高了。

虽然理论说起来简单,但是和业务结合起来这个就不是太容易了,所以要结合业务来权衡,对于这个原则,我建议是接口一定要做到单一职责,类的设计尽量做到只有一个原因引起变化。

原则三:里氏替换原则

这个原则比较难理解,下面我会花费很大篇幅来讲解这个原则。

里氏替换原则是针对继承中出现的问题进行规范,它要求:任何基类可以出现的地方,子类一定可以出现。通俗点讲:子类可以扩展父类的功能,可以实现父类抽象方法,但不能改变父类原有的功能或者非抽象方法。

子类可以扩展父类的功能我们可以理解,就是说子类可以添加父类没有的功能。但是子类不能改变父类原有的功能能或者非抽象方法如何理解呢?

我们先想想加入子类更改的父类原有的功能会出现什么问题。我们举例说明:

假设长方形类:

public class Rectangle{
    setWidth(int width){
        this.width=width;
    }
    setHeight(int height){
        this.height=height
    }
}

我们知道,正方形属于长方形,所以正方形应该继承长方形,注意继承的时候:正方形不能更改父类原有的功能,如果改了,那正方形就不再属于长方形了。因为它违背了:任何基类可以出现的地方,子类一定可以出现。

正方形类:

public class Square extends Rectangle{
  	setWidth(int width){
      this.width=width;
      this. height=width;
    }
  setHeight(int height){
    this.setWidth(height);
  }
}

这个正方形已经将继承来的setWidth方法和setHeight方法更改了,这就坏了,我们来使用一下你就看明白了。

//重新设置尺寸
public void resize(Rectangle r){
    if(r.getHeight()<=r.getWidth){
   				 r.setHeight(r.getWidth+1);
    }
}

看的出当我们重新设置尺寸的时候,把Rectangle 的对象传进去 和 Square 传进去,运行的效果是不一致的,这也就违背了“任何基类可以出现的地方,子类一定可以出现”的原则。

相信说到这里大家能明白了吧。

具体在使用这个原则的时候有以下几点要求:

  • 子类必须实现父类的抽象方法,但不得重写(覆盖)父类的非抽象(已实现)方法。

  • 子类中可以增加自己特有的方法。

  • 当子类覆盖或实现父类的方法时,方法形参要比父类方法的形参更宽松。

  • 当子类的方法实现父类的抽象方法时,方法的返回值要比父类更严格。

下面我着重来讲解一下第三条:当子类覆盖或实现父类的方法时,方法形参要比父类方法的形参更宽松。

父类一个方法func(HashMap map); 子类方法func(Map map);

父类实例fu,子类实例zi,里氏替换原则要求fu.func(HashMap或子类) 必须和zi.func(HashMap或子类) 调用的是同一方法,试想如果子类方法func参数范围比父类的窄的话,zi.func就会优先调用子类的方法,这样就违背了里氏替换原则的基本定义了。

第四条也是同样的道理,如果子类方法的返回值要比父类更宽松的话,那么会优先调用子类的方法,这样也就违背了里氏替换原则的基本定义了。

好了,就先分享到这里,关注我,java学习不头秃,还为每位粉丝准备了一份全面的资料福利,从面试简历模板到大厂面经汇总,从大厂内部技术资料到互联网高薪必读书单,以及Java面试核心知识点(283页)和Java面试题合集2022年最新版(485页)等等,有需要的可以点下方名片领取

ENVI5.6 Seamless Mosaic多景影像镶嵌色差问题 多景影像无缝镶嵌色差问题拟解决方法 阅读详情

相关推荐

python123题目——个税计算器

类型:简单分支。

m0_62488776的博客 5806

软件设计原则之单一职责原则、开闭原则

面向对象设计原则是评价每个设计模式应用效果的重要依据。几乎每个设计模式都符合一个或多个面向对象设计原则(个别模式除外),这些原则都是从无数项目中提取出来的经验性原则,它们为消除软件设计和实现中的“臭味(Bad Smell)”而诞生,力图为当前系统提供最好的设计方案。简单来说,设计原则是描述“面向对象开发”需要注意的代码原则。

Miss Yasiky 的专栏 1102

什么是深度展开网络?如何将迭代算法的每一次迭代展开成深度网络对应的一层?深度展开网络进行端对端训练,其中端对端是什么意思?

在深度学习和机器学习的背景下,“端到端”(End-to-end)训练指的是将输入数据直接映射到最终输出的过程,而不需要任何中间的手动数据预处理或特征工程。- **自然语言处理**:端到端自然语言处理系统可以将自然语言输入直接转化为计算机可理解的语言输出,而不需要对语言进行分解和转化。- **推荐系统**:通过使用深度神经网络,端到端推荐系统可以直接根据用户历史行为预测其未来的兴趣爱好,并推荐相应的产品或服务。4. **直接映射**:从输入到输出的直接映射,中间没有任何拆分或分解的过程。

m0_67897882的博客 5439

Java设计原则之单一职责原则、开闭原则、里氏代换原则

Java面向对象的设计原则

人生处处是围城,一切都是最好的安排! 1481

【AI生成】市面上主流自组网厂家的技术及市场研究

经过对全球自组网产业技术特征与市场格局的系统分析,本文得出以下核心结论:技术演进呈现智能化与融合化双轨路径 当前自组网技术创新已突破传统组网架构局限,形成"协议优化-架构创新-场景适配"的递进式发展路径。国际厂商聚焦智能算法应用,如Silvus采用深度学习实现动态拓扑优化,传输时延较传统方案降低37%;国内企业则侧重异构网络融合,中国移动设计院提出的5G LAN架构使工业场景通信可靠性提升至99.99%。

qq_31310977的博客 1698

【Proteus仿真】用24C04与1602LCD设计的简易加密电子密码锁

【Proteus仿真】用24C04与1602LCD设计的简易加密电子密码锁

perseverance51博客 1122

开闭原则与里氏代换原则

1.开闭原则 是面向对象设计的基本原则之一,是“可复用设计”的基础,它的主要原则是:对扩展开放,对修改关闭;意思就是我们改变一个软件时。应该通过扩展方式来改变软件,而不是修改原有的代码。就是通过修改子类而不通过修改父类来修改数据。 2.里氏替换原则 里氏替换原则是说,任何基类可以出现的地方,子类一定可以出现(只有当衍生类可以替换基类,软件单位的功能不受到影响,基类才能真正被复用,衍生类也能够在基类的基础上增加新的行为)。 就是父类自己引入一个类,用来代替后面的类,以免子类总是重写函数体。 继承自NSObje

qq_46418241的博客 969

通俗讲解传统语音识别过程(MFCC-GMM-HMM-LM范式)

有个这个图,正着算,反着回溯,也就都可以了。对于机器来说,开始并不知道这两句话对应的具体文本是什么,于是我们使用GMM进行聚类,分成ABCD四类(当然我们从上帝视角知道,ABCD依次对应我,爱,恨,你)。提取以后就变成下面这些类似扑克牌的方块,让我们跟着发音顺序来想象,这两段音频前面一部分的特征序列,代表的是“我”,中间是“爱/恨”,末尾是“你”。语言模型的本质,是一种约束。像HMM和GMM都是隐变量模型,这种模型麻烦在哪里呢,一般都会有很多的变量,而且隐变量和模型参数互相影响,扯不清,缠缠绵绵到天涯牵。

u013250861的博客 304

开闭原则、里氏替换与单一职责:软件设计的核心原则

一个软件实体,类,函数,模块;对扩展。

do better. 920

Cesium 实战 26 - 自定义纹理材质 - 箭头流动线(图片纹理)

Cesium 实战 - 自定义纹理材质 - 箭头流动线(图片纹理)。

非科班Java出身GISer的博客 1405

cuMotion 入门教程(一)面向机器人学的GPU加速运动生成技术

NVIDIA cuMotion是一款高性能机器人运动生成库,专注于机械操作任务,利用GPU加速技术提升性能。开发者预览版支持运动学/逆运动学、碰撞感知路径规划、轨迹优化等功能,兼容任意自由度机器人。该库提供C++和Python接口,支持从URDF/XRDF文件加载机器人模型,包含世界建模、碰撞检测等工具。教程详细介绍了安装配置、机器人描述加载、运动学计算、世界建模、逆运动学求解以及轨迹优化等核心功能。cuMotion整合了Lula和cuRobo库的技术优势,将成为Isaac ROS的核心组件,适用于工业机器

2506_90492529的博客 2205

单一职责、接口隔离、依赖倒转、里氏替换、开闭原则、迪米特、合成复用

一、单一职责原则 1、目的 降低代码复杂度、降低系统耦合度、提高可读性 2、定义 对于一个类,只有一个引起该类变化的原因;该类的职责是唯一的,且这个职责是唯一引起其他类变化的原因。 3、解决 将不同的职责封装到不同的类或者模块中,当有新的需求将现有的职责分为颗粒度更小的职责的时候,应该及时对现有代码进行重构。 4、注意事项和细节 (1)降低类的复杂度,一个类只负责一项职责; (2)提高类的可读性,可维护性; (3)降低变更引起的风险; (4)通常情况下,我们应当遵守单一职责原则,只有逻

学Java,找哪吒 8270

LLM的MCP协议:初识MCP,搭建第一个MCP Server

MCP(Model Context Protocol),是一个开发的协议,标准化了应用程序如何为大模型提供上下文。MCP提供了一个标准的为LLM提供数据、工具的方式,使用MCP会更容易的构建Agent或者是基于LLM的复杂工作流。

Criss@陈磊 2万+

设计模式之设计模式七大原则(详解)单一职责原则、开闭原则、接口隔离原则、依赖倒置原则、迪米特法则、里氏替换原则、组合优于继承原则

设计模式 七大设计原则 什么是设计模式? 设计模式(Design pattern)代表了最佳的实践,通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。 23中设计模式背后是7大设计原则,也就是说,每个设计模式都属于一个或多个设计原则 7大原则的背后是一个字 分 七大设计原则: 开闭原则、单一职责原则、里氏替换原则、依赖倒置原则、迪米特法则(最少知道原则)、接口隔离原则、

codinglover5的博客 1812

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料,已经经过了本人的筛选和整理,希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助!

设计原则(单一职能原则,开闭原则,里氏替换原则,依赖倒置原则,接口分离原则,迪米特原则)

面向对象思想设计原则 在实际的开发中,我们要想更深入的了解面向对象思想,就必须熟悉前人总结过的面向对象的思想的设计原则 单一职能原则 开闭原则 里氏替换原则 依赖倒置原则 接口分离原则 迪米特原则 1.单一职能原则 单一职责原则 其实就是开发人员经常说的”高内聚,低耦合” 也就是说,每个类或每个方法都只负责一件事情。 在设计模式中,所有的设计模式都遵循这一原则 public class postive { public static StringBuilde.

weixin_62520626的博客 613

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain&#39;s apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = &quot;R. B. Palm&quot;, title = &quot;Prediction as a candidate for learning deep hierarchical models of data&quot;, year = &quot;2012&quot;,}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath(&#39;DeepLearnToolbox&#39;));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand(&#39;state&#39;,0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W&#39;); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand(&#39;state&#39;,0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = &#39;sigm&#39;;%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er &lt; 0.10, &#39;Too big error&#39;);```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand(&#39;state&#39;,0)sae = saesetup([784 100]);sae.ae{1}.activation_function = &#39;sigm&#39;;sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)&#39;)% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = &#39;sigm&#39;;nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er &lt; 0.16, &#39;Too big error&#39;);```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x&#39;,28,28,60000))/255;test_x = double(reshape(test_x&#39;,28,28,10000))/255;train_y = double(train_y&#39;);test_y = double(test_y&#39;);%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you&#39;ll get around 1.2% errorrand(&#39;state&#39;,0)cnn.layers = { struct(&#39;type&#39;, &#39;i&#39;) %input layer struct(&#39;type&#39;, &#39;c&#39;, &#39;outputmaps&#39;, 6, &#39;kernelsize&#39;, 5) %convolution layer struct(&#39;type&#39;, &#39;s&#39;, &#39;scale&#39;, 2) %sub sampling layer struct(&#39;type&#39;, &#39;c&#39;, &#39;outputmaps&#39;, 12, &#39;kernelsize&#39;, 5) %convolution layer struct(&#39;type&#39;, &#39;s&#39;, &#39;scale&#39;, 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er&lt;0.12, &#39;Too big error&#39;);```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand(&#39;state&#39;,0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er &lt; 0.08, &#39;Too big error&#39;);%% ex2 neural net with L2 weight decayrand(&#39;state&#39;,0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er &lt; 0.1, &#39;Too big error&#39;);%% ex3 neural net with dropoutrand(&#39;state&#39;,0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er &lt; 0.1, &#39;Too big error&#39;);%% ex4 neural net with sigmoid activation functionrand(&#39;state&#39;,0)nn = nnsetup([784 100 10]);nn.activation_function = &#39;sigm&#39;; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er &lt; 0.1, &#39;Too big error&#39;);%% ex5 plotting functionalityrand(&#39;state&#39;,0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = &#39;softmax&#39;; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er &lt; 0.1, &#39;Too big error&#39;);%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand(&#39;state&#39;,0)nn = nnsetup([784 20 10]); nn.output = &#39;softmax&#39;; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er &lt; 0.1, &#39;Too big error&#39;);```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free &quot;Bitdeli Badge&quot;)

7大设计原则

7大设计原则 单一职责原则 单个类,单个方法或者单个框架只完成某一特定功能。 /** * 统计文本文件中有多少个单词 */ public class AppTest { public static StringBuilder loadFile(String fileLocation) throws IOException { //读取文件的内容 Reader in = new FileReader("E:\\IdeaProjects\\1.txt");

Richard_lc的博客 238

蓝牙模块HM-10手册

蓝牙模块HM-10手册,该手册对蓝牙模块HM-10进行了详细的介绍和使用方法以及一些AT指令。

设计模式七大设计原则

设计模式七大设计原则,通俗易懂

King Gigi的博客 1178

设计模式之设计原则

设计模式七大设计原则单一职责里氏替换原则开闭原则接口隔离原则依赖倒置原则迪米特法则组合优于继承单例模式 七大设计原则 单一职责 单一职责就是每个方法负责一件事。降低耦合性,对方法进行封装。 public class Test2 { public static String loadFile(String fileName) throws IOException { // FileReader reader = new FileReader("D:\\Bilysen Java\\ide

weixin_46064091的博客 375

设计模式 #1(7大设计原则)

简述:单个类,单个方法或者单个框架只完成某一特定功能。 需求:统计文本文件中有多少个单词。 反例: Copy public class nagtive { public static void main(String[] args) { try{ //读取文件的内容 Reader in = new FileReader(“E:\1.txt”); BufferedReader bufferedReader = new BufferedReader(in); String line = null

weixin_45032957的博客 202

七大设计原则Java实战之个人理解和图解

我们知道23个开发设计模式对应七大设计原则(单一职责原则、里氏替换原则、依赖倒置原则、开闭原则、迪米特法则(最少知道原则)、接口隔离原则、组合优于继承原则)。是前人总结下来的,以下是我个人Java实战学习,包含自己的个人理解和图解。

Da_zhenzai的博客 918

Java基础——设计原则

1.概述 设计模式,不是一种新的语言,也不是什么新的API,也不是什么新的语法 设计模式,是前辈们,不断总结,不断打磨出的一种经验的总结,不同的设计模式适用不同的场景。 设计模式,公认的有23种设计模式,分别对应不同的场景,这些设计模式是经过长期实践总结而留存下来的。 千万不要认为有任何一种设计模式,能够解决任何问题。每一种设计模式只能用于使用的场景。而不是万能的。 设计模式有优点也有缺点。我们不要为了适用设计模式而使用设计模式,切记设计模式的滥用, 23中设计模式的背后,其实是7大设计原则,也就是说每个设

威威的博客 509

设计模式-设计原则

1、单一职责原则 每个方法、类、框架都只负责一件事情。 /** * 反例: * 统计一个文本文件中,有多少字符,所有功能在一个方法里 */ public class Test { public static void main(String[] args) throws Exception { Reader in = new FileReader("d:\\a.txt"); BufferedReader br = new BufferedReader(

yongmingyongye的博客 131

设计模式六大原则之我见

设计模式很符合中庸之道,适量的话可以大幅提高可维护性,过量的话不但加大工作量,而且会影响可读性。  单一职责原则(Single Responsibility Principle) 定义:不要存在多于一个导致类变更的原因。通俗的说,即一个模块(类、函数等)只负责一项职责。有人在美食城当了三十年厨师,却不会做钣,原因是他只负责切葱花。单一职责完括两层意思,一:一个模块只完成一个功能,二,一个功能只

闻缺陷则喜何志丹 2054

设计模式的原则

设计模式的六大原则是为了需要进行拓展的时候,为了使程序的扩展性好,易于维护和升级。但是这样做也会有不好的地方,会让代码结构更加复杂(不易读懂),建设初期比较耗时,所以要识别出一个业务哪里是需要扩展的,哪里可以复用,选择合适的设计模式,这样才能事半功倍。............

weixin_43177753的博客 153

Java设计模式:设计原则

七大设计原则 a、单一职责原则 b、里式替换原则 c、依赖倒置原则 d、开闭原则 e、迪米特原则(最少知道原则) f、接口隔离原则 g、组合优于继承原则 ...

怪咖的博客 161

Java学习打卡

或许我们乍一看会有点懵,怎么和我们原来学习的接口不一样呢,其实我们这样想,我们都知道,在 Java 中有一个 Class 类,表示正在运行的类和接口,换句话说每一个正在运行时的类或接口都是 Class 类的对象,这是一种向上的抽象。类接口(Class Interface)这就是我们经常使用的用 interface 定义的接口\n这里插一句,接口隔离原则中所说的接口并不是狭意的在 Java 中用 interface 定义的接口,而是一种更为宽泛的概念,可以是接口,抽象类或者实体类。

qq_66009426的博客 91
上一篇: Spring Boot 灵活实现自动配置背后的故事~用起来更香了
下一篇: 设计模式7大原则——迪米特法则解析(含源码示例)
架构文摘JGWZ
博客等级 码龄5年 8808粉丝 345原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值