Java设计原则---封装变化和面向接口编程

设计模式概论:封装变化 设计模式概论 1. 设计模式 设计模式(Design pattern)是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问,设计模式于己于他人于系统都是多赢的,设计模式使代码编制真正工程化,设计模式是软件工程的基石,如同大厦的一块块砖石一样。 模式................................. 阅读详情

最近看了Head First 设计模式一书,开篇的故事讲述了设计模式的原则:封装变化与面向接口编程.

基本需求

故事从编写一个模拟鸭子的游戏开始,游戏要求:

游戏里有许多鸭子,一边游泳戏水,一边呱呱叫…

该游戏内部使用面向对象设计,有一个鸭子的超类Duck:

public abstract class Duck{
    public void swim(){
        //游泳的方法
    }

    public void quack(){
        //呱呱叫的方法
    }

    public abstract void display(){
        //子类要实现的显示的方法
    }
}

因为所有的鸭子都会游泳和叫,所以在超类中实现了swim()和qucak()方法,而具体显示出什么样和具体的鸭子有关,所以display()方法为抽象方法.

现在有种鸭子是红头鸭RedHeadDuck和绿头鸭MallardDuck.
红头RedHeadDuck代码:

public class RedHeadDuck extends Duck {
    public void display() {
        System.out.println("我是红头鸭...");
    }
}

绿头鸭MallardDuck代码:

public class MallardDuck extends Duck {
    public void display() {
        System.out.println("我是绿头鸭...");
    }
}

需求变化

现在需求发生了变化,想要鸭子能飞行…那不是很简单嘛,给Duck类加个飞行的方法不就可以了,如下:

public abstract class Duck{
    public void swim(){
        //游泳的方法
    }

    public void quack(){
        //呱呱叫的方法
    }

    public void fly(){
        //飞行的方法
    }

    public abstract void display(){
        //子类要实现的显示的方法
    }
}

这样一来,确实绿头鸭和红头鸭都会飞行了.

出现问题

由于公司业务需要,增加橡皮鸭这一角色RubberDuck,如下:

public class RubberDuck extends Duck {

    public void display() {
        System.out.println("我是橡皮鸭...");
    }
}

等等,上面的橡皮鸭貌似不对啊,橡皮鸭不会飞啊!而且橡皮鸭是吱吱叫不是呱呱叫.这该怎么办呢?

这还不简单,直接覆盖方法不就行了.

public class RubberDuck extends Duck {
    public void qucak(){
        //吱吱叫...
    }

    public void fly(){
        //什么也不做...
    }

    public void display() {
        System.out.println("我是橡皮鸭...");
    }
}

这样貌似是解决了,但是问题又来来,如果后来需要增加诱饵鸭DecoyDuck,诱饵鸭不会叫不会飞.怎么办?难道还要继续覆盖方法么?

解决问题

既然无法确定以后的鸭子是什么类型,干脆抽取公共的部分,不同的写成接口.
比如会飞的实现Flyable接口,会叫的实现Qucakable接口.

//会飞的接口
public interface Flyable{
    void fly();
}

//会叫的接口
public interface Quackable{
    void quack();
}

//新的Duck类
public abstract class Duck{
    public void swim(){
        //游泳的方法
    }

    public abstract class display(){
        //显示的方法
    }
}

//新的绿头鸭
public class MallardDuck extend Duck implements Flyable, Qucakable {

    public void fly(){
        //我会飞...
    }

    public void quack(){
        //我会呱呱叫...
    }

    public void display(){
        //我是绿头鸭
    }
}

//新的红头鸭类
public class RedHeadDuck extend Duck implements Flyable, Qucakable {

    public void fly(){
        //我会飞...
    }

    public void quack(){
        //我会呱呱叫...
    }

    public void display(){
        //我是红头鸭
    }
}

//橡皮鸭
public class RubberDuck extend Duck implements Quackable {
    public void quack(){
        //我会吱吱叫...
    }

    public void display(){
        //我是橡皮鸭
    }
}

//诱饵鸭
public class DecoyDuck extends Duck {
    public void display(){
        //我是诱饵鸭
    }
}

这样一来,问题就解决了.

新问题

上面的问题是解决了,好像代码有重复:
绿头鸭和红头鸭的会飞的方法和会呱呱叫的方法是重复的.

如果以后有更多类型的方法,重复的代码会更多,而且会埋下一个隐患:

如果以后飞行的动作有所改变,难道一个一个类的去修改?
如果需求还有变化,不是更难维护吗?

解决问题

有没有好的方法解决这个问题呢?答案是肯定的.我们需要将代码中的变化的部分与不变的部分拆分出来.这就是封装变化的原则

封装变化

找出应用中可能需要变化之处,把它们独立出来,不要和那些不需要变化的代码混在一起。

下面就建立两组类,变化的和不会变化的.

上面的案例中什么是变化的呢?
飞行和叫声是变化的.那么就将飞行和叫声与Duck类分开.

如何设计鸭子的飞行行为和叫声行为呢?
我们希望一切有弹性,因为你无法确定以后的飞行行为会有什么变化,也无法确定以后的绿头鸭会有什么行为.

这就涉及到第二个原则:面向接口编程

面向接口编程

针对接口编程,而不是针对实现编程

那么现在的需求有两个行为:飞和叫.
接口就为飞行行为接口和叫的行为接口:

//飞行行为接口
public interface FlyBehaviour{
    void fly();
}

//叫的行为接口
public interface QuackBehaviour{
    void quack();
}

现在飞行有种不同的行为:飞和不会飞.

//普通的飞
public class FlyWithWings implements FlyBehaviour {
    public void fly(){
        System.out.println("我会飞...");
    }
}

//不会飞
public class FlyNoWay implements FlyBehaviour {
    public void fly(){
        //我不会飞...
    }
}

现在叫也有三种行为:呱呱叫和吱吱叫和不会叫

//呱呱叫
public class Quack implements QuackBehaviour {
    public void quack(){
        System.out.println("我会呱呱叫...");
    }
}

//吱吱叫
public class Squack implements QuackBehaviour {
    public void quack(){
        System.out.println("我会吱吱叫...");
    }
}

//不会叫
public class MuteQuack implements QuackBehaviour {
    public void quack(){
        //我不会叫...
    }
}

这样写的好处就在于,使用飞行行为时只需指定会飞行,不需绑定具体飞行的动作,弹性空间较大.而且此处的面向接口编程,并不是狭义上指Java中的接口,而是指超类型,可以是接口也可以是抽象类.

那么如何将行为和Duck类组合到一起呢?

将行为转为属性

即将飞行和叫的行转为鸭子的一个变量

public abstract class Duck {
    //鸭子不处理飞的行为,将飞的行为委托给FlyBehaviour接口
    FlyBehaviour flyBehaviour;
    //鸭子不处理叫的行为,将飞的行为委托给QucakBehaviour接口
    QucakBehaviour quackBehaviour;

    public void performFly(){
        flyBehaviour.fly();
    }

    public void performQuack(){
        quackBehaviour.quack();
    }

    public void swim(){
        System.out.println("我会游泳...");
    }

    public abstract void display();
}

再来看看绿头鸭,

public class MallardDuck extends Duck {
    public MallardDuck(){
        flyBehaviour = new FlyWithWings();
        quackBehaviour = new Quack();
    }

    public class void display(){
        System.out.println("我是绿头鸭...");
    }
}

现在测试一下:

public class Client{
    public static void main(String[] args){
        Duck duck = new MallardDuck();
        duck.display();
        duck.performFly();
        duck.performQuack();
        duck.swim();
    }
}

执行后结果如下:

我是绿头鸭...
我会飞...
我会呱呱叫...
我会游泳...

如何实现动态改变鸭子的行为呢?修改Duck类如下:

public abstract class Duck {
    //鸭子不处理飞的行为,将飞的行为委托给FlyBehaviour接口
    FlyBehaviour flyBehaviour;
    //鸭子不处理叫的行为,将飞的行为委托给QucakBehaviour接口
    QucakBehaviour quackBehaviour;

    public void setFlyBehaviour(FlyBehaviour flyBehaviour){
        this.flyBehaviour = flyBehaviour;
    }

    public void setQucakBehaviour(QucakBehaviour quackBehaviour){
        this.quackBehaviour = quackBehaviour;
    }

    public void performFly(){
        flyBehaviour.fly();
    }

    public void performQuack(){
        quackBehaviour.quack();
    }

    public void swim(){
        System.out.println("我会游泳...");
    }

    public abstract void display();
}

现在构建一个模型鸭ModelDuck

public class ModelDuck extends Duck{
    public ModelDuck(){
        flyBehaviour = new FlyNoWay();  //一开始不会飞
        quackBehaviour = new Quack();
    }

    public void display(){
        System.out.println("我是模型鸭...");
    }
}

新建一个新的飞行行为:FlyRocketPowered

public class FlyRocketPowered implements FlyBehaviour{
    public void fly(){
        System.out.println("我能像火箭一样飞...");
    }
}

现在测试一下动态改变飞行行为:

public class Client{
    public static void main(String[] args){
        Duck duck = new ModelDuck();
        duck.display();
        duck.performFly();
        duck.setFlyBehaviour(new FlyRocketPowered());
        duck.performFly();
    }
}

测试结果:

我是模型鸭...

我会向火箭一样飞...

这样就实现了行为与类分开,及变化的部分与不变化的部分分开了.

小总结

变化的部分
飞行的行为和叫的行为

不变的部分
鸭子会有用,拥有飞行和叫的行为.

总结

封装变化和面向接口编程能让代码有很大的弹性,在代码不变或者很小的改变的情况下满足需求的变化,也易于维护.

Java面向接口编程的实践指南 接口是一种引用类型,它定义了一组方法规范,这些方法由实现该接口的类来具体实现。在Java中,接口是使用关键字interface定义的。接口可以包含常量、方法签名、默认方法、静态方法和嵌套类型。但是,它不能包含实例字段。从Java 8开始,接口还可以包含抽象方法,这些方法可以有默认实现。在上述代码中,Drivable接口定义了两个方法:drive()和start()。其中start()方法有一个默认实现,而stop()方法是一个静态方法。 阅读详情

相关推荐

什么是 MDB-RS232,为什么需要 MDB-RS232适配器 ?

在您需要设计一个售货机,首先需要选择适合您机器的主板,比如安卓主板、树莓派、工控机或者PLC等,这些主板都是没有MDB接口的,而支付设备,比如你选择的纸币器,硬币器,都是MDB接口。那您就需要这个 MDB 适配器,来把MDB接口的支付设备连接到这些串口的主板上,进行通信和控制。MDB-RS232旨在将MDB 协议转换为 RS232 协议,并执行必要的电压转换以及数据路由工作。,能够让主板轻松执行其他任务,不需要考虑协议的具体软硬件的兼容和稳定性问题。专业的设计指导和协助协议分析,丰富的开发文档。

waferstar的博客 1382

面向对象设计三大原则(封装变化点,对接口进行编程,多使用组合而不是继承)

该三大原则应该算是OO的基础,很多OO设计原则和设计模式都是在此三大原则上面衍生发展而来。所以对于学习设计模式的人,了解这三大原则显然是非常必要的。 1.面向对象设计的第一原则:封装变化点。隔离变化点的好处在于,将系统中经常变化的部分和稳定的部分隔离,有助于增加复用性,并降低系统耦合度。很多设计模式的意图中都明显地指出了其对问题的解决方案,学习设计模式的要点是发现其解决方案中封装的变化点。

nirvana_li 6992

LangGraph的容错机制:从节点失败到图级回滚

核心概念铺垫:讲解LLM应用容错与事务性的核心概念(幂等性、重试策略、降级策略、快照、回滚、原子性、一致性、隔离性、持久性、最终一致性),对比LangGraph容错机制与传统数据库ACID事务、Apache Airflow/Kubernetes Workflow/Kubeflow Pipelines容错机制的异同;LangGraph容错机制的演进历史:用markdown表格梳理LangGraph从0.0.1到1.5.0(截止202X年X月)的容错机制发展历程;节点级别的容错:重试与降级。

AI Python 编程之道的博客 175

JAVA开发常用API及封装

JAVA开发常用API及封装

今天又是充满希望的一天 4738

红外弱小目标检测:IPI算法解读及MATLAB复现

参考文献:[1]C. Gaoet al., “Infrared Patch-Image Model for Small Target Detection in a Single Image,” vol. 22, no. 12, pp. 4996–5009, 2013. 本文整理????论文笔记,并附MATLAB实现代码。 一、阅读笔记 1. 摘要 IPI算法是单帧检测算法; 利用背景的非局部子相关性(non-local self-correlation ofbackground),将目标检测转..

小草莓的魔法笔记 1万+

智慧工地算法视频分析服务器区域入侵检测AI视频分析技术在煤矿的实战应用

通过实时分析和处理井下视频资料,智慧矿山算法视频分析服务器不仅能够及时发现并预警人员违规行为和设备异常状况,还能够通过智能分析预防潜在的安全风险,从而显著提高煤矿的安全管理水平和生产效率。

EasyDarwin开源社区技术博客 562

如何封装变化

1.封装用户请求的变化 考虑一个日志记录工具。目前需要提供一个方便的日志API,使得客户可以轻松地完成日志的记录。该日志要求被记录到指定的文本文件中,记录的内容属于字符串类型,其值由客户提供。我们可以非常容易地定义一个日志对象: public class Log { public void Write(string target, string log) { ...

weixin_30390075的博客 195

卫星载荷应用方案

本文将从技术和应用层面探讨卫星载荷的应用方案,分析各个领域的特点和挑战,以期为卫星载荷的应用提供一定的指导和参考。卫星载荷应用方案涵盖了通信、地球观测、气象预报、导航定位等诸多领域在每一个领域中,都存在着不同的技术挑战和应用需求。随着技术的进步和需求的变化,卫星载荷应用方案将不断发展和完善,为人类社会的进步和发展做出更大的贡献。用户可以通过接收多颗卫星的信号,计算自身的位置和速度信息。在覆盖扩展方面,可以采用多星座、MEO、GEO 等不同轨道高度的卫星布局,结合卫星的特点和应用需求,实现覆盖范围的扩展。

muyangjun的专栏 906

1-封装变化

将变化的部分和不变化的部分分开

q563717212的专栏 296

Arch Linux双系统安装避坑指南:从Windows分区到桌面环境全流程

本文提供了一份详尽的Arch Linux与Windows双系统安装避坑指南。内容涵盖从安装前的UEFI环境确认、BitLocker处理、分区规划,到Live环境进入、基础系统安装、GRUB引导配置,再到显卡驱动安装、KDE/GNOME桌面环境部署及中文化设置的全流程。重点解决了双系统安装中的核心痛点,帮助用户在不破坏现有Windows系统的前提下,顺利完成Arch Linux的安装。

nice1的博客 536

银河麒麟高级服务器操作系统V10SP2(X86)PXE无人值守批量部署实战指南

本文详细介绍了银河麒麟高级服务器操作系统V10SP2(X86)PXE无人值守批量部署的实战指南。通过PXE网络引导技术,实现全自动化、高效率的系统部署,特别适用于企业级数据中心和国产化替代项目。文章涵盖基础环境准备、关键服务配置、Kickstart高级定制及部署测试等核心内容,帮助用户快速掌握批量部署技巧。

weixin_42525637的博客 384

java oo原则_OO设计原则

什么是设计原则?设计原则是基本的工具,应用这些规则可以使你的代码更加灵活、更容易维护,更容易扩展。基本原则封装变化Encapsulate what varies.面向接口编程而非实现Code to an interface rather than to an implementation.优先使用组合而非继承Favor Composition Over InheritanceSRP: The si...

weixin_34837388的博客 121

Python爬虫实战 | 拼多多商品评论采集与深度分析

本文从 API 调用、网页渲染到情感分析与关键词提取,全流程剖析了“拼多多商品评论采集与分析”项目。Scrapy + API 可快速抓取评论;Playwright 可突破 API 限制,抓取完整页面内容;数据清洗 + 分析揭示用户真实反馈;可持续部署、扩展至更多商品 & 时间段;

2201_76125261的博客 1696

Java开发人员需知的十大面向对象设计原则

2019独角兽企业重金招聘Python工程师标准>>> ...

weixin_34405354的博客 155

深度学习工具包 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'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 = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```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('DeepLearnToolbox'));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('state',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'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',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 = 'sigm';%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 < 0.10, 'Too big error');```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('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';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)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';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 < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% 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'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 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<0.12, 'Too big error');```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('state',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 < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',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 < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',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 < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % 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 < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % 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 < 0.1, 'Too big error');%% 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('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % 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 < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

Java程序员应该了解的10个面向对象设计原则

面向对象设计原则是OOPS(Object-Oriented Programming System,面向对象的程序设计系统)编程的核心,但大多数Java程序员追逐像Singleton、Decorator、Observer这样的设计模式,而不重视面向对象的分析和设计。甚至还有经验丰富的Java程序员没有听说过OOPS和SOLID设计原则,他们根本不知道设计原则的好处,也不知道如何依照这些原则来进行编程

529

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

Java 设计模式之策略模式(Strategy)

一、策略模式 策略模式(Strategy Pattern):定义了算法族,分别封装起来,让它们之间可以相互替换,此模式让算法的变化独立于使用算法的客户。此模式属于行为型模式的一种。 二、模式详解 游戏项目开始伊始,有各种鸭子,可以呱呱叫(quack),可以游泳(swim)。这里设计了超类,每个鸭子类型都继承超类 过段时间后,发现玩家们想要这个鸭子可以飞,这好办,我就在超类Duck中添加...

大魔王的博客 1082

模板设计模式_设计模式之模板方法模式(三)

模板方法模式是一个很常见的模式,但是也需要我们拥有一双锐利的眼睛,因为模板方法有许多实现,而他们看起来并不一定和书上所讲的设计一致。这个模式很常见是因为对创建框架来说,这个模式简直棒极了。由框架控制如何做事情,而由你(使用这个框架的人)指定框架算法中每个步骤的细节。用模板方法排序我们经常需要数组做什么事情?对了!排序。Java数组类的设计者提供给我们一个方便的模板方法用来排序。让我们看看这个方法如...

weixin_39986466的博客 73

Java程序员应当知道的10个面向对象设计原则 接口 封装 设计 方法 编程

我经常看到不同经验水平的java程序员,他们有的不知道这些OOPS 和SOLID设计原则,有的只是不知道一个特定的设计原则会带来怎样的益处,甚至不知道在编码中如何使用这些设计原则。不要问框架的依赖注入功能将会给你带来什么益处,依赖注入功能在spring框架里已经很好的得到了实现,这一设计原则的优雅之处在于:DI框架注入的任何一个类都易于用模拟对象进行测试,并且更易于维护,因为创建对象的代码在框架里是集中的而且和客户端代码是隔离的。这是另外一个优雅的SOLID 设计原则,以防止有人修改通过测试的代码。

IT_1024_的博客 299

Java面向对象编程:从封装、继承、多态到设计原则

面向对象编程是一种以对象为核心的编程范式,它将数据和操作数据的方法封装在一起,形成高内聚、低耦合的模块。其核心原理在于通过类与对象来模拟现实世界,利用封装隐藏内部细节,通过继承建立层次关系实现代码复用,并借助多态实现同一接口的不同行为表现。这种范式的技术价值在于有效管理软件复杂度,显著提升代码的复用性、扩展性和可维护性,尤其适用于构建大型、复杂的业务系统。在实际应用场景中,例如学生选课管理系统或图形绘制程序,通过定义Student、Shape等类,并运用封装、继承和多态特性,可以构建出结构清晰、易于演化的代

weixin_34204722的博客 293

Java面向对象编程

Java面向对象编程(Object-Oriented Programming,OOP)是一种以对象为核心,通过封装、继承、多态等机制来构建复杂软件系统的编程范式。它强调将现实世界的事物抽象为程序中的对象,每个对象包含数据(属性)和行为(方法),使得代码更易于维护、扩展和复用。Java语言在设计之初就全面支持OOP特性,成为企业级应用和移动开发的主流选择。通过类与对象的基础结构,开发者能够以更直观的方式模拟业务逻辑,提升开发效率并降低系统耦合度。

junehn的博客 1362

OOP | 面向对象的十大设计原则

面向对象的十大设计原则

分享技术类相关知识点、技巧,和大家一起成长。 406

Java程序员应当知道的10个面向对象设计原则

Java程序员应当知道的10个面向对象设计原则 面向对象设计原则是OOPS编程的核心, 但我见过的大多数Java程序员热心于像Singleton (单例) 、 Decorator(装饰器)、Observer(观察者) 等设计模式,而没有把足够多的注意力放在学习面向对象的分析和设计上面。学习面向对象编程像“抽象”、“封装”、“多态”、“继承” 等基础知识是重要的,但同时为了创建简洁、模块化的设计,了...

Tyloo_wdnmd的博客 642

【建模】面向对象设计原则分析

一、面向对象三大设计原则        1、针对接口编程,而不是针对实现编程            可以通过派生接口的类实现(Java中常见)来完成,这样无需知道具体的实现。可自顶而上的进行设计,也可以自下而上的进行抽取公共部分。 public interface A//接口 { public: void Move(); void Fly(); } //分

此博客不更新很多年了,博客作废............ 1756

10个经典的面向对象设计原则

面向对象设计原则是OOPS(Object-Oriented Programming System,面向对象的程序设计系统)编程的核心,但大多数Java程序员追逐像Singleton、Decorator、Observer这样的设计模式,而不重视面向对象的分析和设计。甚至还有经验丰富的Java程序员没有听说过OOPS和SOLID设计原则,他们根本不知道设计原则的好处,也不知道如何依照这些原则来进行编程

Ryan's zone 2964

Java 程序员应该了解的 10 个面向对象设计原则(译文)

我的公众号「码农之屋」(id: Spider1818),分享的内容包括但不限于 Linux、网络、云计算虚拟化、容器Docker、OpenStack、Kubernetes、SDN、OVS、DPDK、Go、Python、C/C++编程技术等内容,欢迎大家关注。 ​面向对象设计原则是OOPS(Object-Oriented Programming System,面向对象的程序设计系统)...

lsz137105的专栏 191
上一篇: AndroidStudio中aar文件引用
下一篇: Android自定义组合控件---简单导航栏
DevWiki
博客等级 码龄12年 23粉丝 59原创
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

DevWiki

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值