精华内容
下载资源
问答
  • 【100个】计算机理论论文大纲,每一个论文提纲都是精选出来的,看了后定能知晓计算机理论论文提纲怎么写等相关写作技巧,让计算机理论论文写作轻松起来!五、多元智能理论在中等职业学校《计算机文化基础》教学中的应用...

    【100个】计算机理论论文大纲,每一个论文提纲都是精选出来的,看了后定能知晓计算机理论论文提纲怎么写等相关写作技巧,让计算机理论论文写作轻松起来!

    五、多元智能理论在中等职业学校《计算机文化基础》教学中的应用研究论文提纲

    摘要

    ABSTRACT

    第一章 绪论

    1-1 多元智能理论的基本概念

    1-2 课题研究的背景

    1-3 课题研究的意义

    1-4 课题研究的主要内容和创新点

    第二章 多元智能理论指导下中职学校《计算文化机基础》课程的教学设计

    2-1 创设有利学生智能发展的教学环境

    2-2 针对学生不同的起点进行分层教学模式

    2-3 针对学生的智能结构不同,激发学生自主学习

    2-4 促进学生全面发展而实施多元评价

    2-5 设计和开发教学案例

    第三章 基于多元智能理论的中职学校《计算机文化基础》的教学实践

    3-1 实验过程中的问题和相关控制

    3-2 实验对象

    3-3 实验方法

    3-4 实验的目的

    3-5 实验的过程

    第四章 基于多元智能理论指导下的教学研究的分析

    4-1 实践前研究调查的结果与分析

    4-2 应用多元智能教学理论教学研究后调查的结果与分析

    4-3 实践结果的反思

    第五章 研究总结和展望

    注释

    参考文献

    附录

    在学期间发表的学术论文

    致谢

    四、多元智能理论在高校《计算机文化基础》教学中的应用研究论文提纲范文

    摘要

    abstract

    1 绪论

    1-1 问题的提出

    1-2 研究的背景

    1-2-1 多元智能理论在国外的研究现状

    1-2-2 多元智能理论在国内的研究现状

    1-2-3 高校《计算机文化基础》课程的教学现状

    1-3 研究的意义

    1-4 研究的主要内容和成果

    2 多元智能理论指导下高校《计算机文化基础》课程的教学设计

    2-1 相关概念的界定

    2-2 研究对象和研究方法、手段

    2-2-1 研究对象

    2-2-2 研究方法、手段

    2-3 设计教学情境和教学计划

    2-4 设计和开发教学案例

    2-5 借助电子绩效支持系统理念设计和开发教学支持系统

    3 多元智能理论指导下高校《计算机文化基础》教学的实施

    3-1 实施概述

    3-2 实践方案

    3-2-1 实践的目标

    3-2-2 组织形式

    3-2-3 实施步骤

    3-2-4 评价方式

    3-3 实践过程中的问题和相关控制

    3-4 实践结果的分析

    3-4-1 教学前研究调查的结果与分析

    3-4-2 应用多元智能教学理论教学后研究调查的结果与分析

    3-4-3 研究过程中访谈内容的分析

    3-5 实践结果的反思

    4 多元智能理论指导下高校《计算机文化基础》教学的简单评价

    4-1 评价学生

    4-2 评价教学系统

    5 研究总结和展望

    参考文献

    附录1 成人多元智能自测量表

    附录2 教学前测问卷

    附录3 教学后测问卷

    附录4 研究过程中访谈的部分内容

    附录5《计算机文化基础》学习支持系统部分界面

    致谢

    在校期间科研成果

    三、基于项目反应理论的计算机自适应考试系统的研究论文提纲格式范文模板

    摘要

    Abstract

    第1章 引言

    1-1 研究的背景和意义

    1-2 研究现状

    1-2-1 项目反应理论的研究现状

    1-2-2 计算机测试现状分析

    1-2-3 自适应测试系统现状

    1-3 本课题的主要工作

    1-4 论文结构

    第2章 项目反应理论(IRT)

    2-1 经典测试理论的不足和项目反应理论的优点

    2-2 项目反应理论的基本概念

    2-3 项目反应模型

    2-4 能力参数和项目参数估计

    2-5 信息函数

    2-6 测验信息函数

    2-7 小结

    第3章 IRT 在计算机自适应考试中的应用

    3-1 CAT 的施测过程

    3-1-1 初始能力参数

    3-1-2 参数估计

    3-1-3 选题策略

    3-1-4 终止规则

    3-2 题库建设

    3-2-1 题库建设的步骤

    3-2-2 试题参数确定

    3-3 小结

    第4章 自适应考试系统设计

    4-1 自适应考试系统的需求分析

    4-1-1 用户基本信息管理的需求分析

    4-1-2 题库管理的需求分析

    4-1-3 考试管理的需求分析

    4-2 自适应考试系统的功能分析

    4-2-1 考试中心子系统

    4-2-2 考点子系统

    4-3 基于三层模型的自适应考试系统设计

    4-4 小结

    第5章 自适应考试系统关键技术的实现

    5-1 蒙特卡罗模拟方法介绍

    5-2 建立题库

    5-2-1 题库建立的方法

    5-2-2 题库容量的仿真研究

    5-3 试题难度确定方法

    5-3-1 试题难度确定

    5-3-2 应用分析

    5-4 能力参数估计方法实现

    5-5 选题方法实现

    5-6 模拟与分析

    5-7 认知诊断方法

    5-7-1 认知诊断功能的设计

    5-7-2 实验及结论

    5-8 小结

    总结

    参考文献

    致谢

    附录 A 攻读硕士期间发表的论文和参与研究项目

    计算机理论论文提纲相关参考属性

    有关论文范文主题研究:

    关于计算机理论论文提纲范文

    大学生适用:

    8000字学院学士论文、2000字高校大学论文

    相关参考文献下载数量:

    277

    写作解决问题:

    论文框架如何写

    毕业论文开题报告:

    标准论文格式、论文结论

    职称论文适用:

    期刊发表、中级职称

    所属大学生专业类别:

    计算机理论课题

    论文提纲推荐度:

    最新大纲

    二、计算机支持下的协作学习的理论基础研究论文提纲范文

    Ⅰ 引 言

    Ⅱ 正 文

    一- CSCL的概述

    (一) CSCL概念辨析

    (二) CSCL的基本原则

    (三) CSCL的特征

    (四) CSCL的分类体系

    (五) CSCL的应用模式

    二- CSCL的理论基础

    (一) 学习理论

    (二) 学习环境设计理论

    (三) 学习交互理论

    (四) 知识生成理论

    (五) 抽象结构模式理论

    Ⅲ 结 语

    Ⅳ 参考文献

    Ⅴ 后 记

    一、中等职业学校计算机课程合作学习实验研究论文提纲范文

    摘要

    Abstract

    一、关于合作学习

    (一) 合作学习的内涵

    (二) 合作学习的理论基础

    二、计算机教学及中职计算机教学的特点和现状

    (一) 计算机学科教学的特点

    (二) 当前中等职业学校计算机学科教学中的常用方法和存在的问题

    三、本研究地目的和意义

    (一) 与本研究有关的问题

    (二) 本研究的目的

    四、中职计算机课堂合作学习实验的实施

    (一) 实验假设

    (二) 实验设计

    (三) 实验实施

    五、实验结果与分析

    (一) 实验结果

    (二) 结果分析及讨论

    六、实验结论与合作学习中应注意的问题

    (一) 实验结论

    (二) 在合作学习中应注意的几个问题

    后记

    注释

    参考文献

    附录

    以下是计算机理论论文大纲,看了后定能知晓计算机理论论文提纲怎么写等相关写作技巧.

    计算机理论范文

    展开全文
  • 《计算机专业理论期末考试试题》由会员分享,可在线阅读,更多相关《计算机专业理论期末考试试题(7页珍藏版)》请在人人文库网上搜索。1、计算机专业理论期末考试试题第一部分(共100分 )一、选择题 (共100分,每小题2...

    《计算机专业理论期末考试试题》由会员分享,可在线阅读,更多相关《计算机专业理论期末考试试题(7页珍藏版)》请在人人文库网上搜索。

    1、计算机专业理论期末考试试题第一部分(共100分 )一、选择题 (共100分,每小题2分)1. 在计算机的组成部分中,负责对指令进行译码的是( )A运算器 B 存储器 C 控制器 D 输入设备2. 实现声波与数字信号相互转换的一种硬件设备是( )A. 显卡 B 声卡 C 音箱 D 麦克风3. 使用word处理完文档后,选择保存时,其中的数据被保存在( )A. 内存 B 外存 C 缓存 D 控制器4关于PCT-E 16X插槽,以下说法错误的是( )A 主要用来连接显卡 B. PCI-E是由英特尔提出的 C 采用点对点的串行连接 D.数据传输速率高,目前最高可达10GBps5. 关于SATA接口的硬。

    2、盘,以下说法错误的是指( )A 采用7芯线缆与主板连接 B 支持热插拔C 具有很强的纠错能力 D 使用SATA硬盘,必须正确设置主从条线6.主板上的HDMI接口,所连接的设备是指( )A 激光打印机 B 网线 C 高清电视机 D 数码相机7.平时我们所说的Pentium4 2.4GHZ是指CPU的( )A 前端总线频率 B 外频 C 主频 D运算速度8.DDR2 DIMM内存条的线数是( )A 72 B 168 C 184 D 2409.用户购买硬盘时最关心的参数,也是衡量硬盘最重要的技术指标( ) A 硬盘转速 B 硬盘容量 C 硬盘接口类型 D 硬盘缓存大小10.下列接口中不是显卡输出接口。

    3、的是( )A DVI接口 B VGA接口 C S-Video D Video- in接口11.LCD显示器容易造成“拖尾”现象的原因是( )A 显示器的刷新率低 B 显示器的响应时间长C 可视角度的大小 D 显示器有坏点12.目前微机上最常用的网卡接口是( )ABNC接口 BTP接口 CRJ-45接口 DComo接口13.激光打印机的耗材是( )A 色带 B 墨盒 C 碳粉 D墨水14.关于U盘,以下说法不正确的是( )A 存储容量大 B 读取数据的速度快 C 体积小巧,便于携带D U盘的内部半导体存储芯片和内存条的相同15.以下说法错误的是( )A 计算机运行速度是完全由CPU决定的B 选购。

    4、计算机配件时,一定要按需选购C 不要盲目的追求CPU的主频 D先选购CPU,再根据CPU选购主板16.选购电脑配件时,不合理的做法是( )A 根据内存选购CPU和主板 B 主板要和CPU匹配C 尽量选择知名品牌的产品 D 坚持按需选购的原则17.安装光驱时,若光驱和硬盘使用同一根数据线,则应设置光驱为( )A 主盘 B 从盘 C 电缆选择 D 无所谓18.LGA775接口的英特尔处理器全部采用的设计是( )A 插针式 B 触点式 C 插孔式 D 金手指19.通常我们设置的开机密码保存在( )A CMOS B BIOS C 内存 D 硬盘20.在Advanced BIOS Featurs界面中,。

    5、当First Boot Device项设置为USB HDD时,表示启动系统的启动盘为( )A 硬盘 B 光驱 C U盘 D 软盘21.一般对硬盘的处理顺序是( )A .低级格式化 分区 高级格式化B. 分区 低级格式化 高级格式化 C. 高级格式化 分区 低级格式化 D. 低级格式化 高级格式化 分区22. 以下情况下,无需重新安装驱动程序才能更好地发挥其功能的是是( )A 新购买了一块独立显卡 B 重新安装了操作系统C 新安装一块IDE接口的硬盘 D 网卡无法连接,找不到“本地连接”图标23.命令Ping127.0.0.1的作用是( )A 查看本机TCP/IP安装是否完整 B 查看本地的网卡。

    6、工作是否正常C 判断本机到网关的线路是否出现故障D 判断本机到DNS的线路是否出现故障24.利用Ghost将某分区备份到映像文件 ,以下菜单选择正确的是( )A Local disk to image B local partition from imageC local disk to diskD local partition to image25.为避免突然停电对计算机造成的伤害,机房可以配备( )A UPS B 稳压器 C 保护器 D 变压器26.开机检测不到硬盘,其原因不包括 ( )A 硬盘本身损坏 B BIOS中没有设置硬盘参数C 没有连接硬盘数据线 D 硬盘没有分区或格式化27.。

    7、小明的计算机新换了一个USB接口的键盘,却发现不能使用,其原因可能是( ) A 鼠标损坏 B 该接口不支持热插拔C 电脑不支持USB接口的键盘 D CMOS设置中屏蔽了USB接口28.计算机前面板上的复位开关按下后不能弹起,会导致( )A 机箱喇叭报警 B 电脑不能启动C 计算机反复启动 D 没有任何影响,计算机正常启动29.关于虚拟内存的说法正确的是( )A 是高速缓存中的一部分空间 B 虚拟内存设置的越大越好 C 虚拟内存可以解决内存和CPU的速度不匹配的问题 D Windows XP默认将C盘的剩余空间做虚拟内存30.关于硬盘优化,以下做法错误的是( )A 定期整理磁盘碎片 B 定期清理。

    8、磁盘C 定期对硬盘进行分区处理 D 更改临时文件的存储路径31.计算机运行速度慢,经常死机的原因不可能是( )A 系统资源不足 B 删除了某个应用程序 C 感染了病毒 D 删除了某个注册表32.使用Partition Magic合并分区时,必须具备的条件不包括( )A 物理位置相邻 B 在同一块硬盘上C 被合并分区为空 D 具有相同的文件系统格式33.分区被删除后,删除后的分区将( )A 变成一个未分配的空间 B 自动合并到前一个分区中C 自动合并到下一个分区中 D 变成一个隐藏分区34. 在DOS中Ghost的功能不包括( )A 制作整个硬盘或分区的映像文件 B 硬盘对拷 C分区对拷 D 软。

    9、盘对拷35. 在以下CPU测试项中,能够反映出CPU的真实性能的是( )A CPU Queen B CPU AES C FPU Julia D CPU Hash36. 在AIDA64中要进行系统稳定的测试,需选择的菜单项是( )A 文件 B 查看 C 报告 D 工具37.要想取消开机自启动程序的运行,可使用Windows优化大师系统中的( )A 文件系统优化 B 开机速度优化 C 桌面菜单优化 D 系统安全优化38. 要检测和修复非正常关机、硬盘坏道等问题,可使用Windows优化大师提供的( ) A 内存整理 B 系统磁盘医生 C 进程管理大师 D 磁盘缓存优化39.使用WINRAR压缩软件。

    10、时,要设置密码,在打开的“压缩文件名和参数”对话框中使用的选项卡是( ) A 常规 B 高级 C 文件 D 注释40.要将从网上下载的MTV刻录到光盘,可以在DVD机上播放,可在Nero Express的主界面选择的项目( ) A数据光盘 B 音乐C 视频D 以上三者均可41.ACDSee可以浏览的文件包括 ( )A 音频文件 B 图片文件 C 视频文件 D 以上全是42. 小张下午用数码相机拍摄的一张图片因天气不好而发暗,要调整该照片的光线,在ACDSee图像编辑窗口中,可单击编辑面板中的选项是( )A曝光 B颜色 C效果 D.杂点43.Snagit默认的输入设置是()A 范围 B 窗口 C。

    11、 多合一 D 全屏幕44.使用Snagit进行动态捕获时,最后保存文件格式是( )A BMP格式 B JPEG格式 C AVI格式 D RM格式45.下列软件最方便制作演示文件的是( )A.ACDsee B Flash C Flash Cam D Goldwave46.使用暴风影音播放视频完毕后,不能设置的操作是( )A 定时播放 B 关机 C 退出播放器 D 定时关机47格式工厂是一款( )A视频编辑软件 B 音频编辑软件 C多媒体格式转换软件 D映像文件制作软件48.在影音工具酷中,以下不是“视频工具”提供功能的是( )A 制作影视光盘 B 擦除盘片 C 视频分割 D 提取DVD视频49.。

    12、在Goldwave中播放音频,窗口中会看到一条白色的指示线,它表示的是( )A 表示音频播放的开始位置 B 表示正在播放的位置C 表示音频播放的结束位置 D 没有任何意义50.在Goldwave中,要去掉录音文件中的噪声,可选择的命令项是( )A 效果 滤波器 均衡器B 效果 滤波器 降噪C 效果 重新采样D 效果 音量 最佳化音量第二部分(共100分)二、简答题(共6小题,每小题5分)1.按照硬盘的引导原理可将硬盘分为哪几部分?2.简述LCD显示器和CRT显示器相比较有何优点?3.简述BIOS与CMOS有何区别?4.简述卸载软件的方法有哪些?5.流媒体技术的实现原理是什么?6暴风影音的“左眼。

    13、”技术,能显著提升影片观看画质,其实现的原理是什么三、操作题(共40分,每小题5分)1.白色红色下列所示的主板中有2对不同颜色的内存插槽,请回答下列问题:(1)这是什么插槽?(2)该主板双色插槽支持什么技术?如何使用该技术?(3)写出在此插槽上安装部件的步骤。2.如何将计算机的开机及SETUP密码设置为123456?3. 小王在电脑上添加了一块新硬盘(未使用),他想用WindowsXP下的磁盘管理工具对硬盘创建新分区,请写出操作步骤。4. 使用局域网上网时,如何进行设置?5.一台电脑安装了Windows98和XP两个系统,但在Windows98中找不到F盘,而在WindowsXP中能正常使用,。

    14、请分析原因并写出解决方案 6. 小张电脑上安装了Nero Express,他想把下载到硬盘上的音乐文件集中刻录到一张光盘上,这张光盘可以在车载CD机上播放。请写出制作音频光盘的步骤。 7.小明在浏览网页时发现有一段精彩的文字,他想将这些文字复制下来,但网页不允许复制,请使用snagit帮她完成操作。8.使用GoldWave将“音乐.wav”文件中从2分钟开始处,截取2分钟长度的音乐片段,并保存为“铃声.mp3”,请写出操作步骤。四、综合题(共3个小题,每题10分)1、 请写出下列文件类型的名称:学习工具.iso: 文章.rar: 电影.avi:动画.swf: 图片.gif:2. 以下是使用AIDA64进行CPU测试的界面,看图回答问题(1)如何打开该对话框?(2)写出该CPU的扩展指令集有哪些?(3)该CPU是何种类型的CPU,主频是多少?3. 请写出下列常见故障的原因(不写解决方案)(1)某计算机处于满负荷状态运行一段时间后,经常自动重启。 (2)开机后机箱内“滴滴”叫个不停,屏幕无显示。(3)开机检测不到硬盘。(4)已经安装了Windows自带的驱动程序,声卡无声。7 / 7。

    展开全文
  • 软件架构-设计原则篇(七大设计原则) 1、软件架构设计原则概述 1.1、软件的可维护性 1、软件的维护 一个好的软件设计可维护性较好的系统,必须能够允许新的设计要求很容易地加入到已有的系统中。 2、具有可维护性的...

    软件架构(软件体系结构)-设计原则篇(七大设计原则)

    1、软件架构设计原则概述

    1.1、软件的可维护性

    1、软件的维护

    一个好的软件设计可维护性较好的系统,必须能够允许新的设计要求很容易地加入到已有的系统中。

    2、具有可维护性的设计目标

    一个好的系统设计应该有如下所示的性质:

    • 可扩展性:新的性能可以很容易的加入系统中。
    • 灵活性:代码修改不会波及很多其他的模块。
    • 可插入性:可以很容易地将一个类用另一个有同样接口的类代替。

    1.2、系统的可复用性

    1、传统的复用:

    • 代码的剪贴复用:容易产生错误
    • 算法的复用:将已经得到很好的研究的算法拿来复用
    • 数据结构的复用:将研究透的数据结构拿来复用。

    2、面向对象向设计的复用

    面向对象的语言中(Java),数据的抽象化、继承、封装和多态性等语言特性使得一个系统可在更高层次上提供可复用性。

    1.3、可维护性复用、设计原则和设计模式

    在面向对象的设计中,可维护性复用是以设计原则和设计模式为基础的。

    设计原则是在提高一个系统可维护性的同时,提高这个系统的可复用性的指导原则,依照这些设计原则进行系统设计,可以实现可维护性复用。

    设计原则包含以下七种:

    • 开-闭原则
    • 里氏代换原则
    • 依赖倒转原则
    • 接口隔离原则
    • 组合聚合复用原则
    • 迪米特法则
    • 接口隔离原则
    • 单一职责原则

    设计模式又分为以三大类别:

    • 创建模式
    • 结构模式
    • 行为模式

    考虑篇幅问题,本篇终点讲解设计原则,三大类别设计模式另外写博客进行讲解。

    下面开始七大设计原则的讲解。

    2、开- 闭原则

    概念:对扩展开放,对修改关闭(精髓)。

    在设计一个模块中,应当使这个模块在不被修改源代码的前提下被扩展——改变这个模块的行为。

    所谓的开始,是用抽象构建框架,用实现扩展细节。可以提高软件系统的可维护性和可复用性。开闭原则是面向对象中最基础的原则,实现开闭原则的基本思想就是面向抽象编程。

    与其它原则之间的关系

    (不了解其它原则也别急,继续往下看,看完后再回过来看关系,说不定另有收获!)

    1. 里氏代换原则:任何父类可以出现的地方,子类一定可以出现。是对开-闭原则的补充,是实现抽象化的具体步骤的规范。
    2. 依赖倒转原则:要依赖于抽象,不要依赖于实现。依赖倒转原则与开-闭原则之间是目标和手段之间的关系:要想实现“开-闭原则”,就必须坚持依赖倒转原则,否则不可能达到开-闭原则的要求。
    3. 合成/聚合复用原则:要尽量使用合成/聚合实现复用,而不是继承。遵守合成/聚合复用原则是实现开-闭原则的必要条件。
    4. 接口隔离原则:应当为客户端提供尽可能小的单独的接口,而不要提供大的总接口。这是对一个软件实体与其它软件实体的通信的限制。
    5. 迪米特法则:一个软件实体应当与尽可能少的其它实体发生相互作用。当一个系统功能扩展时,模块如果是孤立的,就不会影响到其他的对象。遵守迪米特法则的系统在功能需要扩展时,会相对容易地做到对修改的关闭。

    实例

    下面看一个开-闭原则的java例子:

    /**
     * @name: Single_design_principle
     * @date: 2020/12/30 20:19
     * @author: nick_jackson
     * @describtion: 单一设计原则
     **/
    /**
     * 买商品接口
     */
    interface SoldSth{
    
        /**
         * 获取卖出商品的杰哥
         * @return
         */
        double getSoldM();
    
        /**
         * 获取商品名称
         * @return
         */
        String getSoldSthName();
    
        /**
         * 获取商品编号
         */
        String getSoldCode();
    }
    
    /**
     * 卖冰箱实现类
     */
    class SellingRefrigerators implements SoldSth{
        //物品价格
        private double soldM;
        //物品名称
        private String soldSthName;
        //物品编码
        private String soldCode;
    
        public SellingRefrigerators(double soldM, String soldSthName, String soldCode) {
            this.soldM = soldM;
            this.soldSthName = soldSthName;
            this.soldCode = soldCode;
        }
    
        @Override
        public double getSoldM() {
            return soldM;
        }
    
        @Override
        public String getSoldSthName() {
            return soldSthName;
        }
    
        @Override
        public String getSoldCode() {
            return soldCode;
        }
    }
    
    //开-闭原则体现,再不修改源代码的前提下新增行为。
    class SellingRefrigeratorsDiscount extends SellingRefrigerators{
    
        public SellingRefrigeratorsDiscount(double soldM, String soldSthName, String soldCode) {
            super(soldM, soldSthName, soldCode);
        }
    
        //获取打折后的价格
        public double getDiscountSoldOutM(){
            return getSoldM()*0.8;
        }
    }
    
    
    //测试类
    public class Single_design_principle {
    
        public static void main(String[] args) {
            SellingRefrigeratorsDiscount seller = new SellingRefrigeratorsDiscount(800, "冰箱", "GNS4321424");
            System.out.println("打折前:"+seller.getSoldM());
            System.out.println("打折后:"+seller.getDiscountSoldOutM());
        }
    }
    

    3、里氏代换原则

    概念

    里氏代换原则是指所有引用基类(父类)的地方必须能透明的使用其子类的对象。即子类型必须能够替换掉它们的父类型。也就是说把父类都替换成它的子类,程序的行为没有发生变化。

    里氏代换原则是继承复用的基础。只有当子类可以替换掉父类,软件单位的功能不受影响,父类才能真正被复用,而子类也能够在父类的基础上添加新的行为。

    由于该原则子类型的可替换性使得父类类型的模块在无须修改的情况下就可扩展,所以满足里氏代换原则,餐恩公过满足开-闭原则。而依赖倒转原则中指出,依赖了抽象接口或抽象类,就不怕更改,原因也在于里氏代换原则。(这里可能听起来有点绕,但是多想想就能理顺了,或者看看下面的通俗说法)

    里氏替换原则通俗的来讲就是:子类可以扩展父类的功能,但不能改变父类原有的功能。它包含以下4层含义:

    • 子类可以实现父类的抽象方法,但不能覆盖父类的非抽象方法。
    • 子类中可以增加自己特有的方法。
    • 当子类的方法重载父类的方法时,方法的前置条件(即方法的形参)要比父类方法的输入参数更宽松。
    • 当子类的方法实现父类的抽象方法时,方法的后置条件(即方法的返回值)要比父类更严格。

    你可以直接这样想,凡是父类型存在的地方,子类替换掉父类,不会改变程序的行为。

    例子

    下面给出一个java例子。

    	
    /**
     * @name: Richter_principle_of_substitution
     * @date: 2020/12/30 21:41
     * @author: nick_jackson
     * @describtion: 里氏代换原则例子详解
     **/
    //测试类
    public class Richter_principle_of_substitution {
        //1、当子类型对父类型的方法进行了修改,就不满足里氏代换原则了。
        // 因为里氏代换原则要求父类型存在的地方可以被子类型替换,而重载或重写父类方法都将不满足该条件。
        public static void main(String[] args) {
            Father father = new Father();
            int sub = father.sub(100, 20);
            System.out.println("输出:"+sub);
            int sub1 = new Son1().sub(100,20);
            System.out.println("输出1:"+sub1);
            int sub2=new Son2().sub(100,20);
            System.out.println("输出2:"+sub2);
        }
    
    }
    //父类减法运算
    class Father{
        //减法方法
        public int sub(int a, int b){
            return a-b;
        }
    }
    
    //子类1实现功能,减法,两数相加,此类已经重写了父类方法,可以加上@Override,不加也不太影响。重写了方法,导致使用该子类替换父类时会导致程序行为发生改变,因此不满足里氏代换原则。
    class Son1 extends Father{
        public int sub(int a, int b){
            return a+b;
        }
    }
    
    //子类2实现功能,减法,两数相加
    class Son2 extends Father{
        public int add(int a, int b){
            return a+b;
        }
    }
    

    4、依赖倒转原则

    概念

    要依赖于抽象,不要依赖于具体;高层模块不应该依赖于底层模块,两个都应该依赖抽象。

    每一个逻辑实现都是由原子逻辑组成的,不可分割的原子逻辑即为底层模块,原子逻辑的再组装就是高层模块。

    依赖倒转还可以表示为要针对接口编程,而非针对实现编程。

    实例

    下面给个例子理解一下。(结合例子理解更加印象深刻)

    先看传统的例子:

    /**
     * @name: Dependence_Inversion_Principle
     * @date: 2020/12/31 10:43
     * @author: nick_jackson
     * @describtion: 依赖倒转原则实例
     **/
    //测试类
    public class Dependence_Inversion_Principle {
        public static void main(String[] args) {
            Phone phone = new Phone();
            phone.openQQ();
            phone.openWeixin();
        }
    }
    
    //手机类
    class Phone{
        //打开QQ
        public void openQQ(){
            new QQ().openQQ();
        }
        //打开微信
        public void openWeixin(){
            new Weixin().openWeixin();
        }
    }
    
    //QQ类
    class QQ{
        public void openQQ(){
            System.out.println("打开QQ");
        }
    }
    //微信类
    class Weixin{
        public void openWeixin(){
            System.out.println("打开微信");
        }
    }
    

    此时,如果想要新增一个打开淘宝app的行为,则必须要在高层模块Phone类中添加openTaobao()方法,在底层模块新增一个Taobao类,并写出openTaobao方法,这样做在软件系统中有很大的风险,因此就要使用依赖倒转原则进行优化,且看下面优化后的例子:

    //抽象APP接口
    interface App{
        public void openApp();
    }
    //高层模块依赖于抽象,因为传入参数是一个抽象参数。
    class Phone{
        public void openApp(App app){
            app.openApp();
        }
    }
    //微信类实现APP接口,底层模块依赖于抽象
    class Weixin implements App{
    
        @Override
        public void openApp() {
            System.out.println("打开微信");
        }
    }
    //QQ类实现APP接口,底层模块依赖于抽象
    class QQ implements App{
    
        @Override
        public void openApp() {
            System.out.println("打开QQ");
        }
    }
    
    //测试类
    public class Dependence_Inversion_Principle {
        public static void main(String[] args) {
            Phone phone = new Phone();
            phone.openApp(new QQ());
            phone.openApp(new Weixin());
        }
    }
    

    此时,我们可以看到,如果再想增加一个TaobaoAPP,则只需要另写一个Taobao类实现抽象接口,然后就可以直接调用。这就是依赖倒转原则(好好体会一下)。

    当然依赖倒转原则也有它的缺点,实现依赖倒转原则,对象的创建一般要使用对象工厂,不容易实现,且会导致产生大量的类。

    5、合成聚合复用原则

    理解合成聚合复用原则首先要理解合成、聚合的概念。

    聚合

    聚合用来表示“拥有”关系或者整体与部分的关系。代表部分的对象有可能会被多个代表整体的对象所共享,而且不一定会随着某个代表整体的对象被销毁或破坏而被销毁或破坏,部分的生命周期可以超越整体。

    下面给个例子:

    class Student {
        public Student(){
            System.out.println("Student has been created");
        }
    
    }
    
    class Classes{
        
        private Student student;
        
        //在这里使用了聚合关联关系,当创建Classes的时候Student已经存在,不随着Classes的生命周期结束而结束。
        public Classes(Student student){
            System.out.println("classes has been created!");
            this.student=student;
        }
    }
    

    合成

    //合成
    class Room{
    
        public Room createRoom(){
            System.out.println("合成房间");
            return new Room();
        }
    }
    
    class House{
    
        private Room room;
    
        //这里采用合成关联关系,当House生命周期结束时,Room的生命周期同样结束。
        public House(){
            room=new Room();
        }
    
        public void createHouse(){
            room.createRoom();
        }
    }
    

    由于合成或聚合可以将已有对象纳入到新对象中,使之成为新对象的一部分,因此新对象可以调用已有对象的功能。这样做的好处有如下所示:

    • 新对象存取成分对象的唯一方法是通过成分对象的接口。
    • 这种复用是黑箱复用,因为成分对象的内部细节是新对象看不见的。
    • 这种复用支持包装。
    • 这种复用所需的依赖较少。
    • 每一个新的类可以将焦点集中到一个任务上。
    • 这种复用可以再运行时间内动态进行,新对象可以动态地引用与成分对象类型相同的对象。

    当然,有优点同样有缺点,这中复用原则的主要缺点就是系统有较多的对象需要管理。

    理解完合成聚合再来整体理解:

    合成聚合复用原则

    **概念:**在一个新的对象中使用已有的对象,使之成为新对象的一部分;新的对象可以调用已有对象的功能,从而达到复用已有功能的目的。

    通俗讲:就是尽量使用合成/聚合,尽量不要使用继承。

    继承复用

    讲了合成聚合复用,再来说说继承复用,对比着理解会更加清楚明了。

    概念:继承复用通过扩展一个已有对象的实现来得到新的功能,基类(父类)明显的捕获共同的属性和方法,而子类通过增加新的属性和方法来扩展超类的实现。继承是类型的复用。

    优点

    • 新的实现较为容易,因为超类的大部分功能可以通过继承关系自动进入子类。
    • 修改或扩展继承而来的实现较为容易。

    缺点

    • 继承复用破坏封装,因为继承将超类的实现细节暴露给了子类。因为超类的内部细节常常对子类是透明的,因此这种复用是透明的复用,又叫“白箱”复用。
    • 如果超类的实现改变了,那么子类的实现也不得不发生改变。因此,当一个基类发生了改变时,这种改变会传导到一级又一级的子类,使得设计师不得不相应的改变这些子类,以适应超类的变化。
    • 从超类继承而来的实现是静态的,不可能在运行时间内发生变化,因此没有足够的灵活性。

    6、耦合、解耦

    在讲后面的设计原则之前需要普及一下基础知识(面向小白的知识博文,大佬可参考!)

    想必之前讲了那么多原则,有人似乎或多或少都发现了一些特点,为什么要使用这些设计原则,就是为了满足系统的可维护性复用等等目标,而前面我们发现根据设计原则进行设计系统时,对象之间的依赖性相对较低,我们也称之为低耦合。什么是低耦合?耦合是什么?别急,往下看。

    耦合

    表示系统中对象之间的依赖关系。对象之间的耦合越高,维护成本越高。因此对象的设计应使类和构件之间的耦合最小。

    耦合又可以分为一下几种,我将他们按耦合度又高到低从上往下进行排列:

    1. 内容耦合。当一个模块直接修改或操作另一个模块的数据时,或一个模块不通过正常入口而转入另一个模块时,这样的耦合被称为内容耦合。内容耦合是最高程度的耦合,应该避免使用之。
    2. 公共耦合。两个或两个以上的模块共同引用一个全局数据项,这种耦合被称为公共耦合。在具有大量公共耦合的结构中,确定究竟是哪个模块给全局变量赋了一个特定的值是十分困难的。
    3. 外部耦合。一组模块都访问同一全局简单变量而不是同一全局数据结构,而且不是通过参数表传递该全局变量的信息,则称之为外部耦合。
    4. 控制耦合。一个模块通过接口向另一个模块传递一个控制信号,接受信号的模块根据信号值而进行适当的动作,这种耦合被称为控制耦合。
    5. 标记耦合。若一个模块A通过接口向两个模块B和C传递一个公共参数,那么称模块B和C之间存在一个标记耦合。
    6. 数据耦合。模块之间通过参数来传递数据,那么被称为数据耦合。数据耦合是最低的一种耦合形式,系统中一般都存在这种类型的耦合,因为为了完成一些有意义的功能,往往需要将某些模块的输出数据作为另一些模块的输入数据。
    7. 非直接耦合。两个模块之间没有直接关系,它们之间的联系完全是通过主模块的控制和调用来实现的。

    解耦

    字面意思就是解除耦合关系。

    在软件工程中,降低耦合度即可以理解为解耦,模块间有依赖关系必然存在耦合,理论上的绝对零耦合是做不到的,但可以通过一些现有的方法将耦合度降至最低。

    设计的核心思想:尽可能减少代码耦合,如果发现代码耦合,就要采取解耦技术。让数据模型,业务逻辑和视图显示三层之间彼此降低耦合,把关联依赖降到最低,而不至于牵一发而动全身。原则就是A功能的代码不要写在B的功能代码中,如果两者之间需要交互,可以通过接口,通过消息,甚至可以引入框架,但总之就是不要直接交叉写。

    7、迪米特法则(又称最少知识原则)

    概念:

    一个对象应该对其他对象保持最少的了解。

    目的就是降低对象之间、类与类之间的耦合度。

    实例

    明星与经纪人的关系实例

    明星由于全身心投入艺术,所以许多日常事务由经纪人负责处理,如与粉丝的见面会,与媒体公司的业务洽淡等。这里的经纪人是明星的朋友,而粉丝和媒体公司是陌生人,所以适合使用迪米特法则,其类图如图

    在这里插入图片描述

    下面照样给个例子:

    :一个中介,客户只要找中介要满足的楼盘 ,而不必跟每个楼盘发生联系。这个例子用C++写的。

    #define _CRT_SCURE_NO_WARNINGS
    #include<iostream>
    using namespace std;
    #include<string>
    #include<vector>
    class AbstractBuild
    {
    public:
        AbstractBuild(){}
        virtual void sale() = 0;
        virtual string getqulity() = 0;
    
    };
    
    class BuildA :public AbstractBuild{
    
    public:
        BuildA(){
            mqulity = "高品质";
        }
        virtual void sale(){
    
            cout << mqulity << endl;
        }
        virtual string getqulity(){
            return mqulity;
        }
    public:
        string mqulity;
    
    };
    class BuildC :public AbstractBuild{
    
    public:
        BuildC(){
            mqulity = "低品质";
        }
        virtual void sale(){
    
            cout << mqulity << endl;
        }
        virtual string getqulity(){
            return mqulity;
        }
    public:
        string mqulity;
    
    };
    
    //中介类
    class Mediator{
    public:
        Mediator(){
            AbstractBuild *d1 = new BuildA;
            Vbuild.push_back(d1);
            AbstractBuild *d2 = new BuildC;
            Vbuild.push_back(d2);
        }
        //对外提供接口
        AbstractBuild * findmybuild(string p){
            for (vector<AbstractBuild*>::iterator it1 = Vbuild.begin(); it1 != Vbuild.end(); it1++)
            {
                if ((*it1)->getqulity()==p)
                {
                    return *it1;
                }
    
            }
            return NULL;
        }
        ~Mediator(){
            for (vector<AbstractBuild*>::iterator it = Vbuild.begin(); it != Vbuild.end(); it++)
            {
                if (*it != NULL)
                {
                    delete *it;
                }
    
            }
        }
    public:
        vector<AbstractBuild*> Vbuild;
    };
    //客户端测试
    void test(void)
    {
        Mediator *mediator = new Mediator;//实例化中介类
        AbstractBuild *D = mediator->findmybuild("中高品质");//通过中介类查找房子
        if (D != NULL)
        {
            D->sale();
        }
        else
        {
            cout << "楼盘没有找到" << endl;
        }
    }
    //主函数
    int main(void){
        //迪米特原则 最小知识原则
        test();
        int m;
        cout<<"回车退出"<<endl;
        cin>>m;
        // system("pause");
        return 0;
    }
    

    8、单一职责原则

    概念

    功能要单一,一个对象应该只包含单一的职责,并且该职责被完整地封装在一个类中。

    通俗的说,即一个类只负责一项职责。

    个人观点:只有逻辑足够简单,才可以在代码级别上违反单一职责原则;只有类中方法数量足够少,才可以在方法级别上违反单一职责原则;

    优点

    • 可以降低类的复杂度,一个类只负责一项职责,其逻辑肯定要比负责多项职责简单的多;
    • 提高类的可读性,提高系统的可维护性;
    • 变更引起的风险降低,变更是必然的,如果单一职责原则遵守的好,当修改一个功能时,可以显著降低对其他功能的影响。
    • 只要是模块化的程序设计,都适用单一职责原则。

    实例

    把动物行走拆分成陆生动物走路,水生动物游泳两个接口,并每个接口对应一个实现类.

    public interface Animal{}
    public interface  WaterAnimal{}
    
     public class load implements Animal{
     System.out.println("动物走路");
     }
      public class water implements WaterAnimal{
     System.out.println("水生动物动物游泳");
     }
    

    9、接口隔离原则

    概念

    简称ISP。客户端不应该依赖它不需要的接口;一个类对另一个类的依赖应该建立在最小的接口上。

    一旦一个接口太大,则需要将它分割成一些更细小的接口,使用该接口的客户端仅需要知道与之相关联的方法即可。

    理解

    1. 一个类对另一个类的依赖应该建立在最小的接口上;
    2. 一个接口代表一个角色,不应该将不同的角色都交给一个接口,因为这样可能会形成一个臃肿的大接口;
    3. 不应该强迫客户依赖它们从来不用的方法。

    实例

    先来看看不适用接口隔离原则:

    public class MadeFood {
        interface MadeFoodInter{
            void madeHot();
            void madeCold();
        }
        //西红柿
        class Tomatoes implements MadeFoodInter{
    
            @Override
            public void madeHot() {
                Log.w("打印","热菜->打鸡蛋->翻炒->西红柿炒鸡蛋");
            }
    
            @Override
            public void madeCold() {
                Log.w("打印","冷菜->切片->加糖->搅拌->糖拌柿子");
            }
        }
    
        //黄瓜
        class Cucumber implements MadeFoodInter{
    
            @Override
            public void madeHot() {
                Log.w("打印","热菜->切肉->翻炒->黄瓜炒肉");
            }
    
            @Override
            public void madeCold() {
                Log.w("打印","冷菜->拍碎->加调料->搅拌->拍黄瓜");
            }
        }
        //芹菜
        class Celery implements MadeFoodInter{
    
            @Override
            public void madeHot() {
                Log.w("打印","热菜->切段->炒肉->加芹菜->芹菜炒肉");
            }
    
            @Override
            public void madeCold() {
                Log.w("打印","冷菜->切段->焯水->加调料->凉拌芹菜");
            }
        }
      
        public MadeFoodInter getMade(String name){
            MadeFoodInter madeFoodInter = null;
            if(name.equals("西红柿")){
                madeFoodInter = new Tomatoes();
            }else if(name.equals("黄瓜")){
                madeFoodInter = new Cucumber();
            }else if(name.equals("芹菜")){
                madeFoodInter = new Celery();
            }
            return madeFoodInter;
        }
    }
    
    

    从上面的例子能看出来,把冷热菜需要的功能放到一个接口里之后,当热菜师傅调用接口之后,冷菜的制作方法也强制摆在热菜师傅面前,这显然是我们不应该设计出来的。

    下面使用接口隔离原则进行调整:

    public class MadeFood {
        interface MadeFoodInter{
            void madeHot();
            void madeCold();
        }
        class Tomatoes implements MadeFoodInter{
    
            @Override
            public void madeHot() {
                Log.w("打印","热菜->打鸡蛋->翻炒->西红柿炒鸡蛋");
            }
    
            @Override
            public void madeCold() {
                Log.w("打印","冷菜->切片->加糖->搅拌->糖拌柿子");
            }
        }
    
        class Cucumber implements MadeFoodInter{
    
            @Override
            public void madeHot() {
                Log.w("打印","热菜->切肉->翻炒->黄瓜炒肉");
            }
    
            @Override
            public void madeCold() {
                Log.w("打印","冷菜->拍碎->加调料->搅拌->拍黄瓜");
            }
        }
        class Celery implements MadeFoodInter{
    
            @Override
            public void madeHot() {
                Log.w("打印","热菜->切段->炒肉->加芹菜->芹菜炒肉");
            }
    
            @Override
            public void madeCold() {
                Log.w("打印","冷菜->切段->焯水->加调料->凉拌芹菜");
            }
        }
        
        public MadeFoodInter getMade(String name){
            MadeFoodInter madeFoodInter = null;
            if(name.equals("西红柿")){
                madeFoodInter = new Tomatoes();
            }else if(name.equals("黄瓜")){
                madeFoodInter = new Cucumber();
            }else if(name.equals("芹菜")){
                madeFoodInter = new Celery();
            }
            return madeFoodInter;
        }
    }
    

    将冷热菜分为两个接口分别实现,就达到预期效果了。

    优点

    使用接口隔离原则,意在设计一个短而小的接口和类,符合我们常说的高内聚低耦合的设计思想,从而使得类具有很好的可读性、可扩展性和可维护性。

    接口隔离原则就是尽量让接口内的方法都是调用时必用的,原则上宁可接口多,也不要功能杂,当然具体业务实现要根据具体场景需求进行变动。

    总结

    本次博文主要讲解了七大设计原则,引用了许多例子,也感谢从上面看到这里的朋友们,加油!

    通过本次学习,可以理解透彻软件体系架构的七大设计原则,那么你就对于软件编程也就更上一层楼了,加油!

    展开全文
  • Java方法是语句的集合,它们在一起执行一个功能方法是解决一类问题的步骤的有序组合方法包含于类或对象中方法在程序中被创建,在其他地方被引用2、设计方法的原则方法的本意是功能块,就是实现某个功能的语句块的...

    一、方法

    ​1、方法的概念

    ​将一个功能抽取出来,放在类中的大括号中,形参一个独立的功能,当需要使用它时,直接调用它,这样可以增强代码的复用性(重复利用),并解决代码冗余现象。

    Java方法是语句的集合,它们在一起执行一个功能

    方法是解决一类问题的步骤的有序组合

    方法包含于类或对象中

    方法在程序中被创建,在其他地方被引用

    2、设计方法的原则

    方法的本意是功能块,就是实现某个功能的语句块的集合。我们设计方法的时候,最好保持方法的原子性,就是一个方法只完成一个功能,这样利于我们后期的扩展

    3、方法的语法

    ​【访问修饰符】返回值类型 方法名(【参数类型 参数名1,参数类型 参数名2.....】){

    ​方法体

    ​}

    详解:

    ​访问修饰符:用于修饰这个方法的调用范文 目前默认public static

    ​返回值类型:无返回值就写void 或者 方法执行后返回的结果的数据类型,方法执行完之后会将结果返回

    ​方法名:给方法起名,遵循标识符的规则

    ​参数类型、参数名:它们是同时定义,方法在执行时未知的数据,需要在调用方法时进行传递值,参数类型表示这个参数的数据类型,参数名就是这个参数的名称,这个参数名称可以在方法体中使用

    ​方法体:这个方法具有的功能(代码块)

    定义一个方法

    public static int add(int num1,int num2){

    return num1+num2;

    }

    4、方法的分类

    ​根据方法的参数不同,返回值不同,可以将方法分为四类:

    1、无参无返回值方法

    语法

    public static void 方法名(){

    方法体

    }

    2、无参有返回值方法

    语法

    public static void 返回值类型 方法名(){

    方法体

    }

    /**

    * 定义无参有返回值,需要先指定 这个返回值的数据类型

    * 生成一个100以内的随机整数

    */

    public static int getRandomNum(){

    System.out.println("生成随机数");

    int num = (int)(Math.random()*100);

    return num; //注意 返回值类型 必须与定义的数据类型一致

    }

    public static void main(String[] args) {

    //调用有返回值类型

    //(返回值可以接受,也可以不接受,一般建议接受)

    int n=getRandomNum();

    System.out.println(n);

    }

    //结果在n中

    5d5c3b84a46cb9c0503765cdbfef34fa.png

    fc2d013d3cf30cabb492b45da586472b.png

    3、有参无返回值方法

    语法:

    public static void 方法名(参数列表){

    方法体

    }

    情况一:当参数中是基本数据类型,将实参的值赋值给形参

    db49191562b5fc80ea1dc0d630208445.png

    public static void add(itn num){

    num++;

    System.out.println("方法中num的值:"+num);

    }

    调用方法:num的改变不会改变n的值,因为是两个独立的内存

    int n = 10;

    System.out.println(n);

    add(n);

    System.out.println("方法外面 实参的值:"+n);

    结果输出:

    ​方法中num的值:11

    ​方法外面实参的值:10

    情况二:当参数的数据类型是引用数据类型

    例如:数组

    //方法的比对 参数的数组

    public static void add(int [] arr){

    arr[0]++;

    System.out.println("方法中aar[0]="+aar[0]);

    }

    调用:

    int [] array = {10,20};

    add(array);//会调用 参数是数组的add方法

    System.out.println("方法外面的arr【0】"+array[0]);

    结果:

    ​方法中arr[0]=11

    ​方法外面的arr[0]=11

    38368fa2c4a8e8eb034f5219a40e1dd3.png

    例如:类的调用

    714ace54a2202ba2f2141d0a40b9caf8.png

    public static void addAge(Stdent studen){

    //将学生的年龄 获取 自加

    int age = student.age;

    age++;

    // 在重新赋值

    student.age=age;

    }

    295751350f14e38af7f0119d41b255c3.png

    调用:

    Student student = new Student(); //age默认为 18

    System.out.println("方法调用之前:"+student.age);//18

    addAge(student);// 传送的地址

    System.out.println("方法外面 学生的年龄:"+student.age);

    2e66e0e60923b50a995875ce3ae2bcbb.png

    结果输出:方法调用之前: 18

    ​方法外面 学生的年龄:19

    /**

    * 以上方法调用 的结论: 对于参数为引用数据类型,方法外面和方法内部公用同一块内存,

    * 也就是说 参数再传递时,将引用类型的地址赋值给 方法的形参

    * 对于基本数据类型 ,方法的参数将 值的副本赋值给形参,这样形参的改变

    * 不会影响实参的值

    * 原因: 引用数据类型在参数传递时 是地址 (JVM对于堆内存的大小不可控)

    * 基本数据类型在参数传递时 是值

    *

    */

    情况三:当参数是String类型时,String是引用数据类型,但是在参数传递时,与基本类型一样

    public static void main(String[] args){

    //参数是字符串

    String uname = “李四”;

    sayHello(uname);

    System.out.println("我最后对:"+uname+"sayHello");

    }

    public static void sayHello(String name){

    name= "张三";

    System.out.println("我对"+name+"sayHello");

    }

    结果:我对张三sayHello

    ​我最后对李四sayHello

    4、有参有返回值方法

    语法:

    public static 返回值类型 方法名(参数列表){

    方法体

    }

    例如:

    public static String sayHello(String name){

    name="张三";

    System.out.println("我对"+name+"sayHello");

    return name ;

    }

    调用:

    public static void main(String[] args) {

    // 参数是字符串

    String uname ="李四";

    // 将返回值接收 ,这是 uname 才被改变 ,如果不接受,则不改变

    uname = sayHello(uname);

    System.out.println("我最后对"+uname+"sayHello");

    }

    结果:

    我对张三sayHello

    我最后对张三sayHello

    5、方法的调用

    ​如果方法体中需要一些位置的数据作为执行条件,那么这些数据可以作为参数

    ​如果方法需要返回数据,在定义有返回值的方法,且需要明确返回值类型

    ​方法调用两种方式:

    对象名 方法名(参数)

    直接写方法名调用,但必须是static修饰的

    //获取这个字符串的第一个字符

    public void method1(String str){

    //返回字符串的第一个字符

    return str。charAt(0);

    }

    //调用方法

    对象名.method1()

    //调用静态方法 (static修饰的)

    String s = "abc";

    char c = method1(s) //s将赋值给方法的形参 str 那么方法执行时str有值

    //c就是方法调用后的返回值0

    6、方法参数传递

    1、方法的参数是基本数据类型,它传递的是值

    //计算一个属的平方

    public int pow(int a){

    a = a + 2;

    return a * a;

    }

    main:

    int num = 4;

    int sum = pow(num);//赋值给a

    System.out.println(num);//4

    System.out.println(sum);//36

    2、方法的参数是引用数据类型,它传递的是地址(除了String类型除外)

    //参数 是数组类型

    public static int pow(int [] arr){

    arr[0]=arr[0]+2; //根据地址 改变数组的第一个元素值 arr[0]=4;

    return arr[0]*arr[0]; // 4*4

    }

    调用

    // 调用另一个pow

    int [] array = {2,3};

    int sum2 = pow(array) ; // array中存放数组的地址 ,将地址赋值给 arr形参

    System.out.println(array[0]);// 4

    System.out.println(sum2 ); // 16

    7、方法的重载

    ​在一个类中,存在相同的方法名的两个级以上的方法,且它们的参数列表不同(参数类型不通风,参数个数不同,参数顺序不同),不考虑参数名,不考虑返回值类型

    ​一个类中不能存在完全相同的方法,它们是重复的方法。JVM编译不通过

    例如:

    public int add(int a,int b){

    return a+b;

    }

    //重载

    public int add(long a,long b){

    return (int)(a+b);

    }

    //与前两个 不重载

    public void add(int c,int d){

    }

    // 能与 方法1 ,2 构成重载

    public void add(int a){

    }

    // 能与 方法1 ,2 构成重载

    public void add(int a ,long b){

    }

    // 能与 方法1 ,2 构成重载

    public void add(long a ,int b){

    }

    注意:方法名是否相同,参数列表是否相同(数据类型,参数个数,参数顺序)

    方法重载的规则

    方法名称必须相同

    参数列表不同(类型,个数,顺序等)

    方法的返回类型可以相同也可以不相同

    仅仅返回类型不同不足以成为方法的重载

    实现理论:

    方法名称相同时,编译器会根据调用方法的参数个数,参数类型等逐个匹配,以选择对应的方法,如果匹配失败,则编译器报错

    在一个方法中可以调用另外一个方法

    9b697d236a9754dcda341b7ab13ed140.png

    //在一个方法中可以调用另外一个方法,它们的执行顺序是这样的

    public static void main(String[] args) {

    System.out.println("这是main方法 的开始语句块");

    method1();

    System.out.println("这是main方法 的结束语句块");

    }

    public static void method1(){

    System.out.println("这是method1 的开始语句块");

    //在一个方法中可以调用另外一个方法,它们的执行顺序是这样的

    method2();

    System.out.println("这是method1 的结束语句块");

    }

    public static void method2(){

    System.out.println("这是method2 的开始语句块");

    method3();

    System.out.println("这是method2 的结束语句块");

    }

    public static void method3(){

    System.out.println("这是method3 的开始语句块");

    System.out.println("这是method3 的结束语句块");

    }

    8、方法的递归调用

    1、定义

    ​在一个方法中,运行方法自身调用,这样的调用称为方法的递归调用,为了避免出现方法调用时出现死循环,递归调用中必须定义 方法结束调用的条件。

    ​方法递归调用执行流程

    2d2dadbec6f9367a8d0546f9728edaf3.png

    public static void m3(int i){

    if(i==5){

    return ;

    }

    System.out.println("这是m3方法开始i :"+ i);

    i++;

    m3(i);

    System.out.println("m3方法的结束 i:"+ i );

    }

    public static void main(String[] args) {

    m3(0); //

    }

    例题:用户输入一个数字使用递归计算出这个数的阶乘

    //使用递归输入一个数计算它的阶乘

    public static void main(String[] args) {

    Scanner sc = new Scanner(System.in);

    System.out.println("请输入一个数");

    int num=sc.nextInt();

    int sum=f(num);

    System.out.println(sum);

    }

    public static int f(int n){

    if (n==1)

    return 1;

    return n*f(n-1);

    }

    以下是递归的练习题,有兴趣的可以做做

    练习1 : 一组序列 1 ,1, 2,3, 8...13,21,34,55,89,144 n, 第12个数 为多少?

    练习2: 1, 3, 5, 7, 9, 11 . 问前10个数的和

    练习3 :前5个阶乘之和 例如 5!+4!+3!+...1!

    练习4:定义一个函数,函数有一个整型参数n,

    如果参数n为偶数时,调用函数求1/2+1/4+...+1/n,

    如果参数n为奇数时,调用函数1/1+1/3+...+1/n

    练习5、 1/1+1/2+2/3+3/5+5/8.。。。前8个数之和。

    展开全文
  • 怎么做 在编写代码的时候,同类的东西要用相同的形式表现,具体如下: 如果有“添加”方法,就创建与之相对的“删除”方法 同组的函数用相同的参数 让同一个模块里的数据拥有相同的生存周期 函数内所有调用函数的...
  • C语言中有一种长度不确定的参数,形如:"…",它主要用在参数个数不确定的函数中,我们最容易想到的例子是printf函数。(注意:在C++中有函数重载(overload)可以用来区别不同函数参数的调用,但它还是不能表示任意...
  • 计算复杂性理论

    2021-06-18 02:54:07
    计算复杂性理论(理论计算机科学分支学科)语音编辑锁定...一个可计算问题被认为是一个原则上可以用计算机解决的问题,亦即这个问题可以用一系列机械的数学步骤解决,例如算法。中文名计算复杂性理论外文名Computat...
  • 摘 要:函数是C语言的基本单位,函数的参数传递采用单向的值传递方式。当指针作为函数参数时,进行的是地址传递,地址传递依然是单向的值传递方式,并不是双向的传递方式。使用局部变量的有关知识,用图示法分析探讨...
  • “三少”原则是少而精的原则,它要求有较高的数据库设计技巧与艺术,不是任何人都能做到的,因为该原则是杜绝用“打补丁方法”设计数据库的理论依据。 14. 提高数据库运行效率的办法 在给定的系统硬件和系统软件条件...
  • 综合分析参数的匹配原则、数据的传递规律、数组名的约定和下标运算符,从理论上探讨数组参数与指针参数的关系。结合程序验证表明,数组参数本质上为指针参数,即数组参数和指针参数是完全等价的两种形式,参数的数据...
  • 理论所不能解决的那些疑难,实践会给你解决”。—— 费尔巴哈 一、开闭原则 对扩展开放,对修改关闭。最基础,最重要的一个原则。顾名思义,对一个类允许扩展其功能,但是不能影响到现有的功能模块。对提供方开放...
  • 内容简介:毕业论文 利用MATLAB实现PID参数整定及仿真,正文共55页,20762字。摘 要PID控制器由于结构简单、稳定性好、可靠性高,在工业过程控制中得到广泛应用。然而传统PID控制器在系统快速性和准确性方面的固有...
  • 前面介绍了参数寻优的传统方法,梯度下降,牛顿下降等,传统的参数寻优方法,都是提供了下降的方向和大小参考。如果参数非常多,成千上万个参数,很多峰谷时,有没有较好的方法去估计最优解呢。本文介绍的方法就是在...
  • 计算机控制理论与应用(第2版)语音编辑锁定讨论上传视频同义词计算机控制理论与应用一般指计算机控制理论与应用(第2版)《计算机控制理论与应用(第2版)》是2008年6月清华大学出版社出版的图书,作者是孙增圻。...
  • 编程理论:三个思想、六个原则是什么指导编程的思想。在编程的过程中,人们最重视的莫过于编写出高质量的代码。高质量的代码是指拥有多种扩种的方法、不存在多余的要素、可读性高,易于理解的代码。编程...
  • 三菱伺服驱动器参数设置CM100TJ-24F

    千次阅读 2021-01-14 16:20:45
    一是所配驱动电机额定输出扭矩乘上速比,得到的数值原则上要小于减速机产品样本提供的相应额定输出扭矩;二是同时还要考虑其驱动电机的过载能力及实际应用中所需*大工作扭矩。理论上,用户所需*大工作扭矩一定要小于...
  • 布林线参数13好还是20好

    千次阅读 2020-12-20 00:36:37
    布林线为什么参数是26而不是20?这个你去验证下不就OK了,对几个票子,分别用2种参数去观察,看哪个就贴近不就OK了嘛我反正用的是26boll线参数设为多少有效性更强啊?20、26还是更低?有效性最强的还是设为20,我试过...
  • call函数调用含参数api

    2021-05-02 02:26:48
    文章 华章计算机 2017-05-02 8876浏览量 Jedis常见异常汇总 Jedis虽然使用起来比较简单,但是如果不能根据使用场景设置合理的参数(例如连接池参数),不合理的使用一些功能(例如Lua和事务)也会产生很多问题,本文对...
  • 单一职责原则 高内聚低耦合 参考文献 http://www.360doc.com/content/17/1122/15/16915_706158716.shtml
  • 原则19:知道CAP理论。可扩展的事务(分布式事务)是很难的。如果可能的的话,尽可能的使用补偿机制。RDBMS事务是无法扩展的。 原则20:分布式一致性无法扩展,也无法进行组通信,也无法进行集群范围内的可靠通信。...
  • 理论性知识定义里氏替换原则,Liskov Substitution principle(LSP)。抽象定义是下面这样的如果对每一个类型为T1的对象O1,都有类型为T2的对象O2,使得以T1定义的所有程序P在所有的对象O1都替换成O2时,程序P的行为...
  • Oracle内存参数调优技术详解以下文字资料是由(历史新知网www.lishixinzhi.com)小编为大家搜集整理后发布的内容,让我们赶快一起来看一下吧!目的希望通过整理此文档 使大家对 oracle 内存结构有一个全面的了解 并在...
  • 在这里想和大家说说设计中的一些原则,我认为这些东西属于长期经验总结出来的知识。这些原则,每一个程序员都应该了解。但是请不要教条主义,在使用的时候还是要多多考虑实际情况。其实,下面这些原则,不单单只是...
  • 对于伺服参数更改步骤,一般遵循如下原则: 速度控制增益调整步骤 设定负载转动惯量比。 设定速度环积分时间常数为较大值。 速度环增益在不产生振动和异常声音的范围内调大,如果发生振动稍许调小。 速度环积分时间...
  • 依赖倒置原则(Dependence Inversion Principle,DIP)的原始定义:高层模块不应该依赖底层模块,两者都应该依赖其抽象;抽象不应该依赖细节;细节应该依赖抽象。抽象:即抽象类或接口,两者是不能够实例化的。细节:...
  • 一,设置SGA的原则:有时候会碰到在配置SGA中出现了问题,由于分配的内存过多,数据库启不起来了。而且还要注意,在WINDOWS平台下,32位的操作系统,SGA分配不能超过1.8G,64位的扛得住一些,所以我的数据库服务器换...
  • 【多选题】企业采购管理的基本目标包括 【单选题】牙源性钙化上皮瘤中的钙化物质来源于 【多选题】权利制约原则可以概括为以下哪几个方面的要求( ) 【多选题】运输成本包括( )。 【多选题】销售人员想要对客户使用...
  • JVM参数详解及Arthas使用

    千次阅读 2021-12-14 17:14:33
    介绍JVM垃圾回收制度、垃圾回收算法、垃圾收集器、JVM参数、arthas使用及相关问题实战。
  • int 4个字节 long 8个字节 long int 8个字节 double 8个字节 long double 也可以变长了, 16个字节 内存对齐 内存对齐的背景 因为计算机中内存空间都是按照byte划分的,从理论上讲似乎对任何类型的变量的访问可以从...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 87,583
精华内容 35,033
关键字:

原则参数理论