精华内容
下载资源
问答
  • 计算机组成原理期末复习【超实用】

    万次阅读 多人点赞 2019-08-14 00:07:42
    计算机组成原理(第二版)唐朔飞 编著(课本有些地方还不错,可以下载电子版看看) 五道解答题30‘=9’(9知识点)+6’+6’+4’+5’ 我依据老师的考题范围手动整理,有什么问题or想添加的知识点请在评论下方留言...

    计算机组成原理(第二版)唐朔飞  编著(课本有些地方还不错,可以下载电子版看看)

    b站2小时讲解链接 https://www.bilibili.com/video/BV1x4411q7Fz/初次录讲解视频,各种差错和画音不同步请各位谅解,我录到后面都想放弃了,只当是做做博文的推广,想着知识点都写得挺明白了,我个人看博文比看视频效率高,实在没想到挺多人宁愿看视频。我后台还看到有些人说听不懂,如果全都听不懂的话,我建议你们另寻高人指点。我和你们一样是学生,我也有很多没搞明白为什么的,只知道大概怎么算、怎么画。还有,大家别再问我要word文档了,我发到CSDN上的底稿全都删了,可能在你们看来是混课设和考试的救命稻草,在我看来只是一堆再无用处的垃圾。

    五道解答题30‘=9’(9个知识点)+6’+6’+4’+5’ 橙色题号的是当年我遇到的考试题,后面计算题记不清楚确切考了哪些,但掌握了做题技巧就问题不大了。

    我依据老师的考题范围手动整理,有什么问题or想添加的知识点请在评论下方留言!实时更新,助诸位共进步!

    一、解答题

    1. 影响流水线性能的因素主要有哪几种?请简要加以说明。P348

        结构相关:是当多条指令进入流水线后,硬件资源满足不了指令重叠执行的要求时产生的。不同指令争用同一功能部件产生资源冲突。

        数据相关:是指令在流水线中重叠执行时,当后继指令需要用到前面指令的执行结果时发生的。可能改变对操作数的读写访问顺序。

        控制相关:是当流水线遇到分支指令和其它改变PC值的指令时引起的。

    2. 为了保证DRAM的存储信息不遭破坏,必须在电荷漏掉前就进行充电,称为刷新。常见的刷新方式有哪三种,试分析它们间的区别。P86

        集中刷新:是在规定的一个刷新周期内,对全部存储单元集中一段时间逐行进行刷新,此刻必须停止读/写操作。

        分散刷新:是指对每行存储单元的刷新分散到每个存储周期内完成。

        异步刷新:是前两种方式的结合,既可缩短“死时间”,又充分利用最大刷新间隔2ms的特点。

    3. 说明计算机九大寻址方式及有效地址EA计算方法。P311

        立即寻址:无需寻址        隐含寻址:无需寻址       直接寻址:EA=A        间接寻址:EA=(A)         相对寻址:EA=(PC)+A

        基址寻址:EA=(BR)+A    变址寻址:EA=(IX)+A    寄存器寻址:EA=Rj    寄存器间接寻址:EA=(Rj)

    4. 按传输信息的不同,系统总线可分为哪几类?并加以简单描述。P43

        数据总线:用来传输各种功能部件间的数据信息,是双向传输总线,其位数与机器字长、存储字长有关,一般为8/16/32位。

        地址总线:主要用来指出数据总线上的源数据或目的数据在主存单元的地址或I/O设备的地址。

        控制总线:用来发送各种控制信号的传输线,通常对任意控制线而言,它的传输是单向的。

    5. 试说明具有Cache-主存结构的计算机,CPU在访问存储器时的工作流程。P110

        CPU欲读取主存某字时,有两种可能:一种是所需要的字已经在缓存中,即可直接访问Cache;另一种是所需的字不在Cache内,此时需将该字所在的主存整个字块一次调入Cache中(Cache与主存之间是字块传输)。当Cache未满时,主存块可被调入缓存块中,称该主存块与缓存块建立了联系。当Cache已满时,无法接收来自主存块的信息,就由Cache内的替换机构按一定的算法从Cache内移除哪块返回主存,并把新的主存块调入Cache中。

    6. 在写操作时,要考虑Cache和主存的数据一致性的问题,试说明写回法和写直达法的区别。P113

        写回法(拷回法):写操作时只把数据写入Cache而不写入主存(减少了主存的写操作次数),写操作时间=访Cache时间。但当(读操作且Cache已满时)Cache数据被替换出来时才写回主存,增加了Cache复杂性。

         写直达法(存直达法):写操作时数据既写入Cache又写入主存,写操作时间=访存时间,它能随时保证主存与Cache的数据始终一致,但增加了访存次数。(读操作时不涉及对主存的写操作,更新策划较容易实现。)

    7. 说明补码定点加减运算,判断溢出的两种方法。P239-240

         一位符号位判断溢出:参加操作的两个数(减法时即为被减数和“求补”后的减数)符号相同,其结果的符号与原操作数的符号不同,即为溢出。

         两位符号位判断溢出:若结果双符号位相同,则未溢出;若双符号位不同,则溢出。最高符号位为真结果符号。

    8. 说明Cache-主存的地址映像有哪三种方式,说明他们的基本映像原理。P117

        直接映射:将主存空间按Cache的尺寸分区,每区内相同的块号映像到Cache中相同的块位置。优:实现简单;缺:不够灵活

        全相连映射:主存中的每一个字块可映射到Cache任何一个字块位置上,当访问一个块中的数据时,块地址要与Cache块表中的所有地址标记进行比较以确认是否命中。

        组相连映射:是直接映射和全相连映射的一种折中方案,这种方案将存储空间分为若干组,各组间是直接映射,而组内各块间是全相连映射。

    9. 试说明指令周期,机器周期,时钟周期之间的关系。P386

         一个指令周期包含若干个机器周期,一个机器周期又包含若干个时钟周期(节拍),每个指令周期内的机器周期数可以不等,每个机器周期内的节拍数也可以不等。

    10. 试说明单译码方式(线选法)和双译码方式(重合法)的区别。P75

          存储芯片内的地址译码器有两种方式:一种是线选法,适用于地址线较少的芯片。地址信号只需经过一个方向的译码器就可以选中某一存储单元的所有位,结构较简单。

          另一种是重合法,适用于地址线较多的芯片。地址线分为两组,分别经行地址译码器和列地址译码器,通过两者“与”选中存储单元才能进行读/写。

    11. 分别说明一下名词MAR,MDR,CU,IR,PC的中文名称及该器件的主要功能。P14-16

         MAR是存储器地址寄存器,用来存放欲访问的存储单元的地址,其位数对应存储单元的个数。

         MDR是存储器数据寄存器,用来存放从存储体某单元取出or存入的代码,其位数与存储字长相等。

    如4K × 8位的存储芯片,有log2(4K)=12条地址线,8条数据线

         CU是控制单元,用来分析当前指令所需完成的操作,并发出各种微操作命令序列,用以控制所有被控对象。

         IR是指令寄存器,用来存放当前指令,IR的内容来自MDR。

         PC是程序计数器,用来存放当前欲执行指令的地址,它与主存的MAR间有一条直接通道且具有自动加1功能,即可自动形成下一条指令的地址。

    12. 计算机的五大基本组成是什么?P9

          运算器:用来完成算术运算和逻辑运算,并将运算的中间结果暂存在运算器里。

          存储器:用来存放数据和程序。

          控制器:用来控制、指挥程序和数据的输入、运行以及处理运算的结果。

          输入设备:用来将人们熟悉的信息形式转换为机器能识别的信息形式,常见的有键盘、鼠标等。

          输出设备:可将机器运算结果转换为人们熟悉的信息形式,如打印机输出等。

    13. 设某计算机采用微程序控制器,试说明微程序控制器的基本工作原理(即CPU执行指令时的操作过程)。P405

          首先将用户程序的首地址送到PC,然后进入

          取指阶段:①将取指周期微程序首地址M→CMAR

                            ②取微指令:将对应控存M地址单元中的第一条微指令读到控存数据寄存器中,记为CM(CMAR)→CMDR

                            ③产生微操作指令:第一条微指令的操作控制字段中为“1”的各位发出控制信号,如PC→MAR、I→R,命令主存    接收程序首地址并进行读操作。

                            ④形成下一条微指令的地址:此微指令的顺序控制字段指出了下一条微指令的地址为M+1,将M+1送至CMAR,即Ad(CMDR)→CMAR

                            ⑤取下一条微指令:将对应控存M+1地址单元中的第二条微指令读到CMDR中,即CM(CMAR)→CMDR

                            ⑥产生微操作指令:由第二条微指令的操作控制字段中对应“1”的各位发出控制信号,如M(MAR)→MDR使对应主存2000H地址单元中的第一条机器指令从主存中读出,送至MDR中。

                            ⑦形成下一条微指令地址:将第二条微指令下地址字段指出的地址M+2送至CMAR,即Ad(CMDR)→CMAR

          执行阶段:①取数指令微程序首地址的形成:当取数指令存入IR后,其操作码OP(IR)直接送到微地址形成部件,该部件的输出即为取数指令微程序的首地址P,且将P送至CMAR,记作OP(IR)→微地址形成部件→CMAR

                            ②取微指令:将对应控存P地址单元中的微指令读到CMDR中,记为CM(CMAR)→CMDR

                            ③产生为操作命令:由微指令操作控制字段中对应“1”的各位发出控制信号,如Ad(IR)→MAR、I→R,命令主存读操作数。

                            ④形成下一条微指令地址:将此条微指令下地址字段指出的P+1送至CMAR,即Ad(CMDR)→CMAR

    14. 试说明汉明码的校验原理(即如何生成汉明码,以及汉明码的检验原理),默认偶校验。P110

         汉明码的生成步骤:①确定校验位的位数 2^k ≥ n + k +1

                                         ②确定校验位的位置

                                         ③分组

                                         ④生成校验位的值

                                         ⑤得出结论

          检验原理:将已知的汉明码按照前三步正常进行,到第四步时,用H接收P和D一起异或,然后把H倒序排列,若都为0,即无错。否则,该序列对应的二进制位置出错。

    15. 试说明循环冗余校验码的校验原理。P144

           循环冗余校验码的生成步骤:①确定校验位的位数 r

                                                          ②写出信息多项式 M(x)

                                                          ③将信息多项式左移 r 位,得到 M(x)·x^r

                                                          ④用 M(x)·x^r 除以生成多项式 G(x),得到 r 位校验位

                                                          ⑤M(x)·x^r+R(x) 得到CRC码

         检验原理:根据余数判出错位,取反纠错。

    二、计算题

    第6章  运算方法和运算部件

    定点原码一位乘:符号位单独计算,运算数取绝对值参与计算。

    定点原码两位乘:提高了乘法速度,但仍基于重复相加和移位的思想,且随着乘数位数的↗,重复次数↗,仍影响乘法速度。计算较复杂,不常考,自行看书!

    并行阵列乘法器:可大大提升乘法速度。(拓展)

    定点补码一位乘:分校正法比较法(Booth法)。校正法中被乘数符号任意,乘数分正、负两种情况。若乘数为正,则按原码一位乘的算法计算,符号位不用另外计算,被乘数的符号位参与计算若乘数为负,则按原码一位乘的算法计算,被乘数和乘数取绝对值参与计算,最后加上 [-x]补 校正。虽然可将乘数和被乘数互换,使乘数保持+,不必校正,但当两数均为-时必须校正。∵Booth的运算规则不受乘数符号的约束 ∴控制线路较简明,在计算机中普遍使用,常考!

    定点补码两位乘:自行看书!

    区别:补码乘法中,乘积得符号位是在运算过程中自然形成的。而原码乘法中,符号位与数值部分分开计算。

    困扰作者得问题是:被乘数和乘数互换位置的其它情况在此不一 一列举,以上三个例子,两个源于书本,同一组数据,书上的校正法却不能全部适用。望指点!

    P8应=1,感谢网友指正

    较复杂,不怎么考,在此不赘述!

    第四章  主存储器

            

    第七章  指令系统

    教材P324

    第3篇  中央处理器

    教材P384

    看下方!!

        ←参考P412例10.6,上题改正为

    已确定是对的!

    第四章  存储系统

    书上P122原题!

    鉴于我用公式写易误导大家,我上传书上原解如下:

    4.4  辅助存储器

    1. 若某磁盘有两个记录面,每面80个磁道,每磁道18扇区,每扇区存512字节,计算该磁盘的容量是多少?

    解:         18×512×80×2B=1440KB

    举个栗子( o=^•ェ•)o

    如果对你有帮助,可以给点小赏。记得关注我呦!

    展开全文
  • Java基础知识面试题(2020最新版)

    万次阅读 多人点赞 2020-02-19 12:11:27
    文章目录Java概述何为编程什么是Javajdk1.5之后的大版本JVM、JRE和JDK的关系什么是跨平台性?原理是什么Java语言有哪些特点什么是字节码?采用字节码的最大好处是什么什么是Java程序的主类?应用程序和小程序的...

    Java面试总结(2021优化版)已发布在个人微信公众号【技术人成长之路】,优化版首先修正了读者反馈的部分答案存在的错误,同时根据最新面试总结,删除了低频问题,添加了一些常见面试题,对文章进行了精简优化,欢迎大家关注!😊😊

    【技术人成长之路】,助力技术人成长!更多精彩文章第一时间在公众号发布哦!

    文章目录

    Java面试总结汇总,整理了包括Java基础知识,集合容器,并发编程,JVM,常用开源框架Spring,MyBatis,数据库,中间件等,包含了作为一个Java工程师在面试中需要用到或者可能用到的绝大部分知识。欢迎大家阅读,本人见识有限,写的博客难免有错误或者疏忽的地方,还望各位大佬指点,在此表示感激不尽。文章持续更新中…

    序号内容链接地址
    1Java基础知识面试题(2020最新版)https://thinkwon.blog.csdn.net/article/details/104390612
    2Java集合容器面试题(2020最新版)https://thinkwon.blog.csdn.net/article/details/104588551
    3Java异常面试题(2020最新版)https://thinkwon.blog.csdn.net/article/details/104390689
    4并发编程面试题(2020最新版)https://thinkwon.blog.csdn.net/article/details/104863992
    5JVM面试题(2020最新版)https://thinkwon.blog.csdn.net/article/details/104390752
    6Spring面试题(2020最新版)https://thinkwon.blog.csdn.net/article/details/104397516
    7Spring MVC面试题(2020最新版)https://thinkwon.blog.csdn.net/article/details/104397427
    8Spring Boot面试题(2020最新版)https://thinkwon.blog.csdn.net/article/details/104397299
    9Spring Cloud面试题(2020最新版)https://thinkwon.blog.csdn.net/article/details/104397367
    10MyBatis面试题(2020最新版)https://thinkwon.blog.csdn.net/article/details/101292950
    11Redis面试题(2020最新版)https://thinkwon.blog.csdn.net/article/details/103522351
    12MySQL数据库面试题(2020最新版)https://thinkwon.blog.csdn.net/article/details/104778621
    13消息中间件MQ与RabbitMQ面试题(2020最新版)https://thinkwon.blog.csdn.net/article/details/104588612
    14Dubbo面试题(2020最新版)https://thinkwon.blog.csdn.net/article/details/104390006
    15Linux面试题(2020最新版)https://thinkwon.blog.csdn.net/article/details/104588679
    16Tomcat面试题(2020最新版)https://thinkwon.blog.csdn.net/article/details/104397665
    17ZooKeeper面试题(2020最新版)https://thinkwon.blog.csdn.net/article/details/104397719
    18Netty面试题(2020最新版)https://thinkwon.blog.csdn.net/article/details/104391081
    19架构设计&分布式&数据结构与算法面试题(2020最新版)https://thinkwon.blog.csdn.net/article/details/105870730

    Java概述

    何为编程

    编程就是让计算机为解决某个问题而使用某种程序设计语言编写程序代码,并最终得到结果的过程。

    为了使计算机能够理解人的意图,人类就必须要将需解决的问题的思路、方法、和手段通过计算机能够理解的形式告诉计算机,使得计算机能够根据人的指令一步一步去工作,完成某种特定的任务。这种人和计算机之间交流的过程就是编程。

    什么是Java

    Java是一门面向对象编程语言,不仅吸收了C++语言的各种优点,还摒弃了C++里难以理解的多继承、指针等概念,因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表,极好地实现了面向对象理论,允许程序员以优雅的思维方式进行复杂的编程 。

    jdk1.5之后的三大版本

    • Java SE(J2SE,Java 2 Platform Standard Edition,标准版)
      Java SE 以前称为 J2SE。它允许开发和部署在桌面、服务器、嵌入式环境和实时环境中使用的 Java 应用程序。Java SE 包含了支持 Java Web 服务开发的类,并为Java EE和Java ME提供基础。
    • Java EE(J2EE,Java 2 Platform Enterprise Edition,企业版)
      Java EE 以前称为 J2EE。企业版本帮助开发和部署可移植、健壮、可伸缩且安全的服务器端Java 应用程序。Java EE 是在 Java SE 的基础上构建的,它提供 Web 服务、组件模型、管理和通信 API,可以用来实现企业级的面向服务体系结构(service-oriented architecture,SOA)和 Web2.0应用程序。2018年2月,Eclipse 宣布正式将 JavaEE 更名为 JakartaEE
    • Java ME(J2ME,Java 2 Platform Micro Edition,微型版)
      Java ME 以前称为 J2ME。Java ME 为在移动设备和嵌入式设备(比如手机、PDA、电视机顶盒和打印机)上运行的应用程序提供一个健壮且灵活的环境。Java ME 包括灵活的用户界面、健壮的安全模型、许多内置的网络协议以及对可以动态下载的连网和离线应用程序的丰富支持。基于 Java ME 规范的应用程序只需编写一次,就可以用于许多设备,而且可以利用每个设备的本机功能。

    JVM、JRE和JDK的关系

    JVM
    Java Virtual Machine是Java虚拟机,Java程序需要运行在虚拟机上,不同的平台有自己的虚拟机,因此Java语言可以实现跨平台。

    JRE
    Java Runtime Environment包括Java虚拟机和Java程序所需的核心类库等。核心类库主要是java.lang包:包含了运行Java程序必不可少的系统类,如基本数据类型、基本数学函数、字符串处理、线程、异常处理类等,系统缺省加载这个包

    如果想要运行一个开发好的Java程序,计算机中只需要安装JRE即可。

    JDK
    Java Development Kit是提供给Java开发人员使用的,其中包含了Java的开发工具,也包括了JRE。所以安装了JDK,就无需再单独安装JRE了。其中的开发工具:编译工具(javac.exe),打包工具(jar.exe)等

    JVM&JRE&JDK关系图

    什么是跨平台性?原理是什么

    所谓跨平台性,是指java语言编写的程序,一次编译后,可以在多个系统平台上运行。

    实现原理:Java程序是通过java虚拟机在系统平台上运行的,只要该系统可以安装相应的java虚拟机,该系统就可以运行java程序。

    Java语言有哪些特点

    简单易学(Java语言的语法与C语言和C++语言很接近)

    面向对象(封装,继承,多态)

    平台无关性(Java虚拟机实现平台无关性)

    支持网络编程并且很方便(Java语言诞生本身就是为简化网络编程设计的)

    支持多线程(多线程机制使应用程序在同一时间并行执行多项任)

    健壮性(Java语言的强类型机制、异常处理、垃圾的自动收集等)

    安全性

    什么是字节码?采用字节码的最大好处是什么

    字节码:Java源代码经过虚拟机编译器编译后产生的文件(即扩展为.class的文件),它不面向任何特定的处理器,只面向虚拟机。

    采用字节码的好处

    Java语言通过字节码的方式,在一定程度上解决了传统解释型语言执行效率低的问题,同时又保留了解释型语言可移植的特点。所以Java程序运行时比较高效,而且,由于字节码并不专对一种特定的机器,因此,Java程序无须重新编译便可在多种不同的计算机上运行。

    先看下java中的编译器和解释器

    Java中引入了虚拟机的概念,即在机器和编译程序之间加入了一层抽象的虚拟机器。这台虚拟的机器在任何平台上都提供给编译程序一个的共同的接口。编译程序只需要面向虚拟机,生成虚拟机能够理解的代码,然后由解释器来将虚拟机代码转换为特定系统的机器码执行。在Java中,这种供虚拟机理解的代码叫做字节码(即扩展为.class的文件),它不面向任何特定的处理器,只面向虚拟机。每一种平台的解释器是不同的,但是实现的虚拟机是相同的。Java源程序经过编译器编译后变成字节码,字节码由虚拟机解释执行,虚拟机将每一条要执行的字节码送给解释器,解释器将其翻译成特定机器上的机器码,然后在特定的机器上运行,这就是上面提到的Java的特点的编译与解释并存的解释。

    Java源代码---->编译器---->jvm可执行的Java字节码(即虚拟指令)---->jvm---->jvm中解释器----->机器可执行的二进制机器码---->程序运行。
    

    什么是Java程序的主类?应用程序和小程序的主类有何不同?

    一个程序中可以有多个类,但只能有一个类是主类。在Java应用程序中,这个主类是指包含main()方法的类。而在Java小程序中,这个主类是一个继承自系统类JApplet或Applet的子类。应用程序的主类不一定要求是public类,但小程序的主类要求必须是public类。主类是Java程序执行的入口点。

    Java应用程序与小程序之间有那些差别?

    简单说应用程序是从主线程启动(也就是main()方法)。applet小程序没有main方法,主要是嵌在浏览器页面上运行(调用init()线程或者run()来启动),嵌入浏览器这点跟flash的小游戏类似。

    Java和C++的区别

    我知道很多人没学过C++,但是面试官就是没事喜欢拿咱们Java和C++比呀!没办法!!!就算没学过C++,也要记下来!

    • 都是面向对象的语言,都支持封装、继承和多态
    • Java不提供指针来直接访问内存,程序内存更加安全
    • Java的类是单继承的,C++支持多重继承;虽然Java的类不可以多继承,但是接口可以多继承。
    • Java有自动内存管理机制,不需要程序员手动释放无用内存

    Oracle JDK 和 OpenJDK 的对比

    1. Oracle JDK版本将每三年发布一次,而OpenJDK版本每三个月发布一次;

    2. OpenJDK 是一个参考模型并且是完全开源的,而Oracle JDK是OpenJDK的一个实现,并不是完全开源的;

    3. Oracle JDK 比 OpenJDK 更稳定。OpenJDK和Oracle JDK的代码几乎相同,但Oracle JDK有更多的类和一些错误修复。因此,如果您想开发企业/商业软件,我建议您选择Oracle JDK,因为它经过了彻底的测试和稳定。某些情况下,有些人提到在使用OpenJDK 可能会遇到了许多应用程序崩溃的问题,但是,只需切换到Oracle JDK就可以解决问题;

    4. 在响应性和JVM性能方面,Oracle JDK与OpenJDK相比提供了更好的性能;

    5. Oracle JDK不会为即将发布的版本提供长期支持,用户每次都必须通过更新到最新版本获得支持来获取最新版本;

    6. Oracle JDK根据二进制代码许可协议获得许可,而OpenJDK根据GPL v2许可获得许可。

    基础语法

    数据类型

    Java有哪些数据类型

    定义:Java语言是强类型语言,对于每一种数据都定义了明确的具体的数据类型,在内存中分配了不同大小的内存空间。

    分类

    • 基本数据类型
      • 数值型
        • 整数类型(byte,short,int,long)
        • 浮点类型(float,double)
      • 字符型(char)
      • 布尔型(boolean)
    • 引用数据类型
      • 类(class)
      • 接口(interface)
      • 数组([])

    Java基本数据类型图

    switch 是否能作用在 byte 上,是否能作用在 long 上,是否能作用在 String 上

    在 Java 5 以前,switch(expr)中,expr 只能是 byte、short、char、int。从 Java5 开始,Java 中引入了枚举类型,expr 也可以是 enum 类型,从 Java 7 开始,expr 还可以是字符串(String),但是长整型(long)在目前所有的版本中都是不可以的。

    用最有效率的方法计算 2 乘以 8

    2 << 3(左移 3 位相当于乘以 2 的 3 次方,右移 3 位相当于除以 2 的 3 次方)。

    Math.round(11.5) 等于多少?Math.round(-11.5)等于多少

    Math.round(11.5)的返回值是 12,Math.round(-11.5)的返回值是-11。四舍五入的原理是在参数上加 0.5 然后进行下取整。

    float f=3.4;是否正确

    不正确。3.4 是双精度数,将双精度型(double)赋值给浮点型(float)属于下转型(down-casting,也称为窄化)会造成精度损失,因此需要强制类型转换float f =(float)3.4; 或者写成 float f =3.4F;。

    short s1 = 1; s1 = s1 + 1;有错吗?short s1 = 1; s1 += 1;有错吗

    对于 short s1 = 1; s1 = s1 + 1;由于 1 是 int 类型,因此 s1+1 运算结果也是 int型,需要强制转换类型才能赋值给 short 型。

    而 short s1 = 1; s1 += 1;可以正确编译,因为 s1+= 1;相当于 s1 = (short(s1 + 1);其中有隐含的强制类型转换。

    编码

    Java语言采用何种编码方案?有何特点?

    Java语言采用Unicode编码标准,Unicode(标准码),它为每个字符制订了一个唯一的数值,因此在任何的语言,平台,程序都可以放心的使用。

    注释

    什么Java注释

    定义:用于解释说明程序的文字

    分类

    • 单行注释
      格式: // 注释文字
    • 多行注释
      格式: /* 注释文字 */
    • 文档注释
      格式:/** 注释文字 */

    作用

    在程序中,尤其是复杂的程序中,适当地加入注释可以增加程序的可读性,有利于程序的修改、调试和交流。注释的内容在程序编译的时候会被忽视,不会产生目标代码,注释的部分不会对程序的执行结果产生任何影响。

    注意事项:多行和文档注释都不能嵌套使用。

    访问修饰符

    访问修饰符 public,private,protected,以及不写(默认)时的区别

    定义:Java中,可以使用访问修饰符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。

    分类

    private : 在同一类内可见。使用对象:变量、方法。 注意:不能修饰类(外部类)
    default (即缺省,什么也不写,不使用任何关键字): 在同一包内可见,不使用任何修饰符。使用对象:类、接口、变量、方法。
    protected : 对同一包内的类和所有子类可见。使用对象:变量、方法。 注意:不能修饰类(外部类)。
    public : 对所有类可见。使用对象:类、接口、变量、方法

    访问修饰符图

    运算符

    &和&&的区别

    &运算符有两种用法:(1)按位与;(2)逻辑与。

    &&运算符是短路与运算。逻辑与跟短路与的差别是非常巨大的,虽然二者都要求运算符左右两端的布尔值都是true 整个表达式的值才是 true。&&之所以称为短路运算,是因为如果&&左边的表达式的值是 false,右边的表达式会被直接短路掉,不会进行运算。

    注意:逻辑或运算符(|)和短路或运算符(||)的差别也是如此。

    关键字

    Java 有没有 goto

    goto 是 Java 中的保留字,在目前版本的 Java 中没有使用。

    final 有什么用?

    用于修饰类、属性和方法;

    • 被final修饰的类不可以被继承
    • 被final修饰的方法不可以被重写
    • 被final修饰的变量不可以被改变,被final修饰不可变的是变量的引用,而不是引用指向的内容,引用指向的内容是可以改变的

    final finally finalize区别

    • final可以修饰类、变量、方法,修饰类表示该类不能被继承、修饰方法表示该方法不能被重写、修饰变量表
      示该变量是一个常量不能被重新赋值。
    • finally一般作用在try-catch代码块中,在处理异常的时候,通常我们将一定要执行的代码方法finally代码块
      中,表示不管是否出现异常,该代码块都会执行,一般用来存放一些关闭资源的代码。
    • finalize是一个方法,属于Object类的一个方法,而Object类是所有类的父类,该方法一般由垃圾回收器来调
      用,当我们调用System.gc() 方法的时候,由垃圾回收器调用finalize(),回收垃圾,一个对象是否可回收的
      最后判断。

    this关键字的用法

    this是自身的一个对象,代表对象本身,可以理解为:指向对象本身的一个指针。

    this的用法在java中大体可以分为3种:

    1.普通的直接引用,this相当于是指向当前对象本身。

    2.形参与成员名字重名,用this来区分:

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    

    3.引用本类的构造函数

    class Person{
        private String name;
        private int age;
        
        public Person() {
        }
     
        public Person(String name) {
            this.name = name;
        }
        public Person(String name, int age) {
            this(name);
            this.age = age;
        }
    }
    

    super关键字的用法

    super可以理解为是指向自己超(父)类对象的一个指针,而这个超类指的是离自己最近的一个父类。

    super也有三种用法:

    1.普通的直接引用

    与this类似,super相当于是指向当前对象的父类的引用,这样就可以用super.xxx来引用父类的成员。

    2.子类中的成员变量或方法与父类中的成员变量或方法同名时,用super进行区分

    class Person{
        protected String name;
     
        public Person(String name) {
            this.name = name;
        }
     
    }
     
    class Student extends Person{
        private String name;
     
        public Student(String name, String name1) {
            super(name);
            this.name = name1;
        }
     
        public void getInfo(){
            System.out.println(this.name);      //Child
            System.out.println(super.name);     //Father
        }
     
    }
    
    public class Test {
        public static void main(String[] args) {
           Student s1 = new Student("Father","Child");
           s1.getInfo();
     
        }
    }
    

    3.引用父类构造函数

    3、引用父类构造函数

    • super(参数):调用父类中的某一个构造函数(应该为构造函数中的第一条语句)。
    • this(参数):调用本类中另一种形式的构造函数(应该为构造函数中的第一条语句)。

    this与super的区别

    • super: 它引用当前对象的直接父类中的成员(用来访问直接父类中被隐藏的父类中成员数据或函数,基类与派生类中有相同成员定义时如:super.变量名 super.成员函数据名(实参)
    • this:它代表当前对象名(在程序中易产生二义性之处,应使用this来指明当前对象;如果函数的形参与类中的成员数据同名,这时需用this来指明成员变量名)
    • super()和this()类似,区别是,super()在子类中调用父类的构造方法,this()在本类内调用本类的其它构造方法。
    • super()和this()均需放在构造方法内第一行。
    • 尽管可以用this调用一个构造器,但却不能调用两个。
    • this和super不能同时出现在一个构造函数里面,因为this必然会调用其它的构造函数,其它的构造函数必然也会有super语句的存在,所以在同一个构造函数里面有相同的语句,就失去了语句的意义,编译器也不会通过。
    • this()和super()都指的是对象,所以,均不可以在static环境中使用。包括:static变量,static方法,static语句块。
    • 从本质上讲,this是一个指向本对象的指针, 然而super是一个Java关键字。

    static存在的主要意义

    static的主要意义是在于创建独立于具体对象的域变量或者方法。以致于即使没有创建对象,也能使用属性和调用方法

    static关键字还有一个比较关键的作用就是 用来形成静态代码块以优化程序性能。static块可以置于类中的任何地方,类中可以有多个static块。在类初次被加载的时候,会按照static块的顺序来执行每个static块,并且只会执行一次。

    为什么说static块可以用来优化程序性能,是因为它的特性:只会在类加载的时候执行一次。因此,很多时候会将一些只需要进行一次的初始化操作都放在static代码块中进行。

    static的独特之处

    1、被static修饰的变量或者方法是独立于该类的任何对象,也就是说,这些变量和方法不属于任何一个实例对象,而是被类的实例对象所共享

    怎么理解 “被类的实例对象所共享” 这句话呢?就是说,一个类的静态成员,它是属于大伙的【大伙指的是这个类的多个对象实例,我们都知道一个类可以创建多个实例!】,所有的类对象共享的,不像成员变量是自个的【自个指的是这个类的单个实例对象】…我觉得我已经讲的很通俗了,你明白了咩?

    2、在该类被第一次加载的时候,就会去加载被static修饰的部分,而且只在类第一次使用时加载并进行初始化,注意这是第一次用就要初始化,后面根据需要是可以再次赋值的。

    3、static变量值在类加载的时候分配空间,以后创建类对象的时候不会重新分配。赋值的话,是可以任意赋值的!

    4、被static修饰的变量或者方法是优先于对象存在的,也就是说当一个类加载完毕之后,即便没有创建对象,也可以去访问。

    static应用场景

    因为static是被类的实例对象所共享,因此如果某个成员变量是被所有对象所共享的,那么这个成员变量就应该定义为静态变量

    因此比较常见的static应用场景有:

    1、修饰成员变量 2、修饰成员方法 3、静态代码块 4、修饰类【只能修饰内部类也就是静态内部类】 5、静态导包

    static注意事项

    1、静态只能访问静态。 2、非静态既可以访问非静态的,也可以访问静态的。

    流程控制语句

    break ,continue ,return 的区别及作用

    break 跳出总上一层循环,不再执行循环(结束当前的循环体)

    continue 跳出本次循环,继续执行下次循环(结束正在执行的循环 进入下一个循环条件)

    return 程序返回,不再执行下面的代码(结束当前的方法 直接返回)

    在 Java 中,如何跳出当前的多重嵌套循环

    在Java中,要想跳出多重循环,可以在外面的循环语句前定义一个标号,然后在里层循环体的代码中使用带有标号的break 语句,即可跳出外层循环。例如:

    public static void main(String[] args) {
        ok:
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 10; j++) {
                System.out.println("i=" + i + ",j=" + j);
                if (j == 5) {
                    break ok;
                }
    
            }
        }
    }
    

    面向对象

    面向对象概述

    面向对象和面向过程的区别

    面向过程

    优点:性能比面向对象高,因为类调用时需要实例化,开销比较大,比较消耗资源;比如单片机、嵌入式开发、Linux/Unix等一般采用面向过程开发,性能是最重要的因素。

    缺点:没有面向对象易维护、易复用、易扩展

    面向对象

    优点:易维护、易复用、易扩展,由于面向对象有封装、继承、多态性的特性,可以设计出低耦合的系统,使系统更加灵活、更加易于维护

    缺点:性能比面向过程低

    面向过程是具体化的,流程化的,解决一个问题,你需要一步一步的分析,一步一步的实现。

    面向对象是模型化的,你只需抽象出一个类,这是一个封闭的盒子,在这里你拥有数据也拥有解决问题的方法。需要什么功能直接使用就可以了,不必去一步一步的实现,至于这个功能是如何实现的,管我们什么事?我们会用就可以了。

    面向对象的底层其实还是面向过程,把面向过程抽象成类,然后封装,方便我们使用的就是面向对象了。

    面向对象三大特性

    面向对象的特征有哪些方面

    面向对象的特征主要有以下几个方面

    抽象:抽象是将一类对象的共同特征总结出来构造类的过程,包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为,并不关注这些行为的细节是什么。

    封装

    封装把一个对象的属性私有化,同时提供一些可以被外界访问的属性的方法,如果属性不想被外界访问,我们大可不必提供方法给外界访问。但是如果一个类没有提供给外界访问的方法,那么这个类也没有什么意义了。

    继承

    继承是使用已存在的类的定义作为基础建立新类的技术,新类的定义可以增加新的数据或新的功能,也可以用父类的功能,但不能选择性地继承父类。通过使用继承我们能够非常方便地复用以前的代码。

    关于继承如下 3 点请记住:

    1. 子类拥有父类非 private 的属性和方法。

    2. 子类可以拥有自己属性和方法,即子类可以对父类进行扩展。

    3. 子类可以用自己的方式实现父类的方法。(以后介绍)。

    多态

    所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定,而是在程序运行期间才确定,即一个引用变量到底会指向哪个类的实例对象,该引用变量发出的方法调用到底是哪个类中实现的方法,必须在由程序运行期间才能决定。

    在Java中有两种形式可以实现多态:继承(多个子类对同一方法的重写)和接口(实现接口并覆盖接口中同一方法)。

    其中Java 面向对象编程三大特性:封装 继承 多态

    封装:隐藏对象的属性和实现细节,仅对外提供公共访问方式,将变化隔离,便于使用,提高复用性和安全性。

    继承:继承是使用已存在的类的定义作为基础建立新类的技术,新类的定义可以增加新的数据或新的功能,也可以用父类的功能,但不能选择性地继承父类。通过使用继承可以提高代码复用性。继承是多态的前提。

    关于继承如下 3 点请记住

    1. 子类拥有父类非 private 的属性和方法。

    2. 子类可以拥有自己属性和方法,即子类可以对父类进行扩展。

    3. 子类可以用自己的方式实现父类的方法。

    多态性:父类或接口定义的引用变量可以指向子类或具体实现类的实例对象。提高了程序的拓展性。

    在Java中有两种形式可以实现多态:继承(多个子类对同一方法的重写)和接口(实现接口并覆盖接口中同一方法)。

    方法重载(overload)实现的是编译时的多态性(也称为前绑定),而方法重写(override)实现的是运行时的多态性(也称为后绑定)。

    一个引用变量到底会指向哪个类的实例对象,该引用变量发出的方法调用到底是哪个类中实现的方法,必须在由程序运行期间才能决定。运行时的多态是面向对象最精髓的东西,要实现多态需要做两件事:

    • 方法重写(子类继承父类并重写父类中已有的或抽象的方法);
    • 对象造型(用父类型引用子类型对象,这样同样的引用调用同样的方法就会根据子类对象的不同而表现出不同的行为)。

    什么是多态机制?Java语言是如何实现多态的?

    所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定,而是在程序运行期间才确定,即一个引用变量倒底会指向哪个类的实例对象,该引用变量发出的方法调用到底是哪个类中实现的方法,必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类,这样,不用修改源程序代码,就可以让引用变量绑定到各种不同的类实现上,从而导致该引用调用的具体方法随之改变,即不修改程序代码就可以改变程序运行时所绑定的具体代码,让程序可以选择多个运行状态,这就是多态性。

    多态分为编译时多态和运行时多态。其中编辑时多态是静态的,主要是指方法的重载,它是根据参数列表的不同来区分不同的函数,通过编辑之后会变成两个不同的函数,在运行时谈不上多态。而运行时多态是动态的,它是通过动态绑定来实现的,也就是我们所说的多态性。

    多态的实现

    Java实现多态有三个必要条件:继承、重写、向上转型。

    继承:在多态中必须存在有继承关系的子类和父类。

    重写:子类对父类中某些方法进行重新定义,在调用这些方法时就会调用子类的方法。

    向上转型:在多态中需要将子类的引用赋给父类对象,只有这样该引用才能够具备技能调用父类的方法和子类的方法。

    只有满足了上述三个条件,我们才能够在同一个继承结构中使用统一的逻辑实现代码处理不同的对象,从而达到执行不同的行为。

    对于Java而言,它多态的实现机制遵循一个原则:当超类对象引用变量引用子类对象时,被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法,但是这个被调用的方法必须是在超类中定义过的,也就是说被子类覆盖的方法。

    面向对象五大基本原则是什么(可选)

    • 单一职责原则SRP(Single Responsibility Principle)
      类的功能要单一,不能包罗万象,跟杂货铺似的。
    • 开放封闭原则OCP(Open-Close Principle)
      一个模块对于拓展是开放的,对于修改是封闭的,想要增加功能热烈欢迎,想要修改,哼,一万个不乐意。
    • 里式替换原则LSP(the Liskov Substitution Principle LSP)
      子类可以替换父类出现在父类能够出现的任何地方。比如你能代表你爸去你姥姥家干活。哈哈~~
    • 依赖倒置原则DIP(the Dependency Inversion Principle DIP)
      高层次的模块不应该依赖于低层次的模块,他们都应该依赖于抽象。抽象不应该依赖于具体实现,具体实现应该依赖于抽象。就是你出国要说你是中国人,而不能说你是哪个村子的。比如说中国人是抽象的,下面有具体的xx省,xx市,xx县。你要依赖的抽象是中国人,而不是你是xx村的。
    • 接口分离原则ISP(the Interface Segregation Principle ISP)
      设计时采用多个与特定客户类有关的接口比采用一个通用的接口要好。就比如一个手机拥有打电话,看视频,玩游戏等功能,把这几个功能拆分成不同的接口,比在一个接口里要好的多。

    类与接口

    抽象类和接口的对比

    抽象类是用来捕捉子类的通用特性的。接口是抽象方法的集合。

    从设计层面来说,抽象类是对类的抽象,是一种模板设计,接口是行为的抽象,是一种行为的规范。

    相同点

    • 接口和抽象类都不能实例化
    • 都位于继承的顶端,用于被其他实现或继承
    • 都包含抽象方法,其子类都必须覆写这些抽象方法

    不同点

    参数抽象类接口
    声明抽象类使用abstract关键字声明接口使用interface关键字声明
    实现子类使用extends关键字来继承抽象类。如果子类不是抽象类的话,它需要提供抽象类中所有声明的方法的实现子类使用implements关键字来实现接口。它需要提供接口中所有声明的方法的实现
    构造器抽象类可以有构造器接口不能有构造器
    访问修饰符抽象类中的方法可以是任意访问修饰符接口方法默认修饰符是public。并且不允许定义为 private 或者 protected
    多继承一个类最多只能继承一个抽象类一个类可以实现多个接口
    字段声明抽象类的字段声明可以是任意的接口的字段默认都是 static 和 final 的

    备注:Java8中接口中引入默认方法和静态方法,以此来减少抽象类和接口之间的差异。

    现在,我们可以为接口提供默认实现的方法了,并且不用强制子类来实现它。

    接口和抽象类各有优缺点,在接口和抽象类的选择上,必须遵守这样一个原则:

    • 行为模型应该总是通过接口而不是抽象类定义,所以通常是优先选用接口,尽量少用抽象类。
    • 选择抽象类的时候通常是如下情况:需要定义子类的行为,又要为子类提供通用的功能。

    普通类和抽象类有哪些区别?

    • 普通类不能包含抽象方法,抽象类可以包含抽象方法。
    • 抽象类不能直接实例化,普通类可以直接实例化。

    抽象类能使用 final 修饰吗?

    不能,定义抽象类就是让其他类继承的,如果定义为 final 该类就不能被继承,这样彼此就会产生矛盾,所以 final 不能修饰抽象类

    创建一个对象用什么关键字?对象实例与对象引用有何不同?

    new关键字,new创建对象实例(对象实例在堆内存中),对象引用指向对象实例(对象引用存放在栈内存中)。一个对象引用可以指向0个或1个对象(一根绳子可以不系气球,也可以系一个气球);一个对象可以有n个引用指向它(可以用n条绳子系住一个气球)

    变量与方法

    成员变量与局部变量的区别有哪些

    变量:在程序执行的过程中,在某个范围内其值可以发生改变的量。从本质上讲,变量其实是内存中的一小块区域

    成员变量:方法外部,类内部定义的变量

    局部变量:类的方法中的变量。

    成员变量和局部变量的区别

    作用域

    成员变量:针对整个类有效。
    局部变量:只在某个范围内有效。(一般指的就是方法,语句体内)

    存储位置

    成员变量:随着对象的创建而存在,随着对象的消失而消失,存储在堆内存中。
    局部变量:在方法被调用,或者语句被执行的时候存在,存储在栈内存中。当方法调用完,或者语句结束后,就自动释放。

    生命周期

    成员变量:随着对象的创建而存在,随着对象的消失而消失
    局部变量:当方法调用完,或者语句结束后,就自动释放。

    初始值

    成员变量:有默认初始值。

    局部变量:没有默认初始值,使用前必须赋值。

    使用原则

    在使用变量时需要遵循的原则为:就近原则
    首先在局部范围找,有就使用;接着在成员位置找。

    在Java中定义一个不做事且没有参数的构造方法的作用

    Java程序在执行子类的构造方法之前,如果没有用super()来调用父类特定的构造方法,则会调用父类中“没有参数的构造方法”。因此,如果父类中只定义了有参数的构造方法,而在子类的构造方法中又没有用super()来调用父类中特定的构造方法,则编译时将发生错误,因为Java程序在父类中找不到没有参数的构造方法可供执行。解决办法是在父类里加上一个不做事且没有参数的构造方法。

    在调用子类构造方法之前会先调用父类没有参数的构造方法,其目的是?

    帮助子类做初始化工作。

    一个类的构造方法的作用是什么?若一个类没有声明构造方法,改程序能正确执行吗?为什么?

    主要作用是完成对类对象的初始化工作。可以执行。因为一个类即使没有声明构造方法也会有默认的不带参数的构造方法。

    构造方法有哪些特性?

    名字与类名相同;

    没有返回值,但不能用void声明构造函数;

    生成类的对象时自动执行,无需调用。

    静态变量和实例变量区别

    静态变量: 静态变量由于不属于任何实例对象,属于类的,所以在内存中只会有一份,在类的加载过程中,JVM只为静态变量分配一次内存空间。

    实例变量: 每次创建对象,都会为每个对象分配成员变量内存空间,实例变量是属于实例对象的,在内存中,创建几次对象,就有几份成员变量。

    静态变量与普通变量区别

    static变量也称作静态变量,静态变量和非静态变量的区别是:静态变量被所有的对象所共享,在内存中只有一个副本,它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的,在创建对象的时候被初始化,存在多个副本,各个对象拥有的副本互不影响。

    还有一点就是static成员变量的初始化顺序按照定义的顺序进行初始化。

    静态方法和实例方法有何不同?

    静态方法和实例方法的区别主要体现在两个方面:

    1. 在外部调用静态方法时,可以使用"类名.方法名"的方式,也可以使用"对象名.方法名"的方式。而实例方法只有后面这种方式。也就是说,调用静态方法可以无需创建对象。
    2. 静态方法在访问本类的成员时,只允许访问静态成员(即静态成员变量和静态方法),而不允许访问实例成员变量和实例方法;实例方法则无此限制

    在一个静态方法内调用一个非静态成员为什么是非法的?

    由于静态方法可以不通过对象进行调用,因此在静态方法里,不能调用其他非静态变量,也不可以访问非静态变量成员。

    什么是方法的返回值?返回值的作用是什么?

    方法的返回值是指我们获取到的某个方法体中的代码执行后产生的结果!(前提是该方法可能产生结果)。返回值的作用:接收出结果,使得它可以用于其他的操作!

    内部类

    什么是内部类?

    在Java中,可以将一个类的定义放在另外一个类的定义内部,这就是内部类。内部类本身就是类的一个属性,与其他属性定义方式一致。

    内部类的分类有哪些

    内部类可以分为四种:成员内部类、局部内部类、匿名内部类和静态内部类

    静态内部类

    定义在类内部的静态类,就是静态内部类。

    public class Outer {
    
        private static int radius = 1;
    
        static class StaticInner {
            public void visit() {
                System.out.println("visit outer static  variable:" + radius);
            }
        }
    }
    

    静态内部类可以访问外部类所有的静态变量,而不可访问外部类的非静态变量;静态内部类的创建方式,new 外部类.静态内部类(),如下:

    Outer.StaticInner inner = new Outer.StaticInner();
    inner.visit();
    
    成员内部类

    定义在类内部,成员位置上的非静态类,就是成员内部类。

    public class Outer {
    
        private static  int radius = 1;
        private int count =2;
        
         class Inner {
            public void visit() {
                System.out.println("visit outer static  variable:" + radius);
                System.out.println("visit outer   variable:" + count);
            }
        }
    }
    

    成员内部类可以访问外部类所有的变量和方法,包括静态和非静态,私有和公有。成员内部类依赖于外部类的实例,它的创建方式外部类实例.new 内部类(),如下:

    Outer outer = new Outer();
    Outer.Inner inner = outer.new Inner();
    inner.visit();
    
    局部内部类

    定义在方法中的内部类,就是局部内部类。

    public class Outer {
    
        private  int out_a = 1;
        private static int STATIC_b = 2;
    
        public void testFunctionClass(){
            int inner_c =3;
            class Inner {
                private void fun(){
                    System.out.println(out_a);
                    System.out.println(STATIC_b);
                    System.out.println(inner_c);
                }
            }
            Inner  inner = new Inner();
            inner.fun();
        }
        public static void testStaticFunctionClass(){
            int d =3;
            class Inner {
                private void fun(){
                    // System.out.println(out_a); 编译错误,定义在静态方法中的局部类不可以访问外部类的实例变量
                    System.out.println(STATIC_b);
                    System.out.println(d);
                }
            }
            Inner  inner = new Inner();
            inner.fun();
        }
    }
    

    定义在实例方法中的局部类可以访问外部类的所有变量和方法,定义在静态方法中的局部类只能访问外部类的静态变量和方法。局部内部类的创建方式,在对应方法内,new 内部类(),如下:

     public static void testStaticFunctionClass(){
        class Inner {
        }
        Inner  inner = new Inner();
     }
    
    匿名内部类

    匿名内部类就是没有名字的内部类,日常开发中使用的比较多。

    public class Outer {
    
        private void test(final int i) {
            new Service() {
                public void method() {
                    for (int j = 0; j < i; j++) {
                        System.out.println("匿名内部类" );
                    }
                }
            }.method();
        }
     }
     //匿名内部类必须继承或实现一个已有的接口 
     interface Service{
        void method();
    }
    

    除了没有名字,匿名内部类还有以下特点:

    • 匿名内部类必须继承一个抽象类或者实现一个接口。
    • 匿名内部类不能定义任何静态成员和静态方法。
    • 当所在的方法的形参需要被匿名内部类使用时,必须声明为 final。
    • 匿名内部类不能是抽象的,它必须要实现继承的类或者实现的接口的所有抽象方法。

    匿名内部类创建方式:

    new/接口{ 
      //匿名内部类实现部分
    }
    

    内部类的优点

    我们为什么要使用内部类呢?因为它有以下优点:

    • 一个内部类对象可以访问创建它的外部类对象的内容,包括私有数据!
    • 内部类不为同一包的其他类所见,具有很好的封装性;
    • 内部类有效实现了“多重继承”,优化 java 单继承的缺陷。
    • 匿名内部类可以很方便的定义回调。

    内部类有哪些应用场景

    1. 一些多算法场合
    2. 解决一些非面向对象的语句块。
    3. 适当使用内部类,使得代码更加灵活和富有扩展性。
    4. 当某个类除了它的外部类,不再被其他的类使用时。

    局部内部类和匿名内部类访问局部变量的时候,为什么变量必须要加上final?

    局部内部类和匿名内部类访问局部变量的时候,为什么变量必须要加上final呢?它内部原理是什么呢?

    先看这段代码:

    public class Outer {
    
        void outMethod(){
            final int a =10;
            class Inner {
                void innerMethod(){
                    System.out.println(a);
                }
    
            }
        }
    }
    

    以上例子,为什么要加final呢?是因为生命周期不一致, 局部变量直接存储在栈中,当方法执行结束后,非final的局部变量就被销毁。而局部内部类对局部变量的引用依然存在,如果局部内部类要调用局部变量时,就会出错。加了final,可以确保局部内部类使用的变量与外层的局部变量区分开,解决了这个问题。

    内部类相关,看程序说出运行结果

    public class Outer {
        private int age = 12;
    
        class Inner {
            private int age = 13;
            public void print() {
                int age = 14;
                System.out.println("局部变量:" + age);
                System.out.println("内部类变量:" + this.age);
                System.out.println("外部类变量:" + Outer.this.age);
            }
        }
    
        public static void main(String[] args) {
            Outer.Inner in = new Outer().new Inner();
            in.print();
        }
    
    }
    

    运行结果:

    局部变量:14
    内部类变量:13
    外部类变量:12
    

    重写与重载

    构造器(constructor)是否可被重写(override)

    构造器不能被继承,因此不能被重写,但可以被重载。

    重载(Overload)和重写(Override)的区别。重载的方法能否根据返回类型进行区分?

    方法的重载和重写都是实现多态的方式,区别在于前者实现的是编译时的多态性,而后者实现的是运行时的多态性。

    重载:发生在同一个类中,方法名相同参数列表不同(参数类型不同、个数不同、顺序不同),与方法返回值和访问修饰符无关,即重载的方法不能根据返回类型进行区分

    重写:发生在父子类中,方法名、参数列表必须相同,返回值小于等于父类,抛出的异常小于等于父类,访问修饰符大于等于父类(里氏代换原则);如果父类方法访问修饰符为private则子类中就不是重写。

    对象相等判断

    == 和 equals 的区别是什么

    == : 它的作用是判断两个对象的地址是不是相等。即,判断两个对象是不是同一个对象。(基本数据类型 == 比较的是值,引用数据类型 == 比较的是内存地址)

    equals() : 它的作用也是判断两个对象是否相等。但它一般有两种使用情况:

    情况1:类没有覆盖 equals() 方法。则通过 equals() 比较该类的两个对象时,等价于通过“==”比较这两个对象。

    情况2:类覆盖了 equals() 方法。一般,我们都覆盖 equals() 方法来两个对象的内容相等;若它们的内容相等,则返回 true (即,认为这两个对象相等)。

    举个例子:

    public class test1 {
        public static void main(String[] args) {
            String a = new String("ab"); // a 为一个引用
            String b = new String("ab"); // b为另一个引用,对象的内容一样
            String aa = "ab"; // 放在常量池中
            String bb = "ab"; // 从常量池中查找
            if (aa == bb) // true
                System.out.println("aa==bb");
            if (a == b) // false,非同一对象
                System.out.println("a==b");
            if (a.equals(b)) // true
                System.out.println("aEQb");
            if (42 == 42.0) { // true
                System.out.println("true");
            }
        }
    }
    

    说明:

    • String中的equals方法是被重写过的,因为object的equals方法是比较的对象的内存地址,而String的equals方法比较的是对象的值。
    • 当创建String类型的对象时,虚拟机会在常量池中查找有没有已经存在的值和要创建的值相同的对象,如果有就把它赋给当前引用。如果没有就在常量池中重新创建一个String对象。

    hashCode 与 equals (重要)

    HashSet如何检查重复

    两个对象的 hashCode() 相同,则 equals() 也一定为 true,对吗?

    hashCode和equals方法的关系

    面试官可能会问你:“你重写过 hashcode 和 equals 么,为什么重写equals时必须重写hashCode方法?”

    hashCode()介绍

    hashCode() 的作用是获取哈希码,也称为散列码;它实际上是返回一个int整数。这个哈希码的作用是确定该对象在哈希表中的索引位置。hashCode() 定义在JDK的Object.java中,这就意味着Java中的任何类都包含有hashCode()函数。

    散列表存储的是键值对(key-value),它的特点是:能根据“键”快速的检索出对应的“值”。这其中就利用到了散列码!(可以快速找到所需要的对象)

    为什么要有 hashCode

    我们以“HashSet 如何检查重复”为例子来说明为什么要有 hashCode

    当你把对象加入 HashSet 时,HashSet 会先计算对象的 hashcode 值来判断对象加入的位置,同时也会与其他已经加入的对象的 hashcode 值作比较,如果没有相符的hashcode,HashSet会假设对象没有重复出现。但是如果发现有相同 hashcode 值的对象,这时会调用 equals()方法来检查 hashcode 相等的对象是否真的相同。如果两者相同,HashSet 就不会让其加入操作成功。如果不同的话,就会重新散列到其他位置。(摘自我的Java启蒙书《Head first java》第二版)。这样我们就大大减少了 equals 的次数,相应就大大提高了执行速度。

    hashCode()与equals()的相关规定

    如果两个对象相等,则hashcode一定也是相同的

    两个对象相等,对两个对象分别调用equals方法都返回true

    两个对象有相同的hashcode值,它们也不一定是相等的

    因此,equals 方法被覆盖过,则 hashCode 方法也必须被覆盖

    hashCode() 的默认行为是对堆上的对象产生独特值。如果没有重写 hashCode(),则该 class 的两个对象无论如何都不会相等(即使这两个对象指向相同的数据)

    对象的相等与指向他们的引用相等,两者有什么不同?

    对象的相等 比的是内存中存放的内容是否相等而 引用相等 比较的是他们指向的内存地址是否相等。

    值传递

    当一个对象被当作参数传递到一个方法后,此方法可改变这个对象的属性,并可返回变化后的结果,那么这里到底是值传递还是引用传递

    是值传递。Java 语言的方法调用只支持参数的值传递。当一个对象实例作为一个参数被传递到方法中时,参数的值就是对该对象的引用。对象的属性可以在被调用过程中被改变,但对对象引用的改变是不会影响到调用者的

    为什么 Java 中只有值传递

    首先回顾一下在程序设计语言中有关将参数传递给方法(或函数)的一些专业术语。按值调用(call by value)表示方法接收的是调用者提供的值,而按引用调用(call by reference)表示方法接收的是调用者提供的变量地址。一个方法可以修改传递引用所对应的变量值,而不能修改传递值调用所对应的变量值。 它用来描述各种程序设计语言(不只是Java)中方法参数传递方式。

    Java程序设计语言总是采用按值调用。也就是说,方法得到的是所有参数值的一个拷贝,也就是说,方法不能修改传递给它的任何参数变量的内容。

    下面通过 3 个例子来给大家说明

    example 1

    public static void main(String[] args) {
        int num1 = 10;
        int num2 = 20;
    
        swap(num1, num2);
    
        System.out.println("num1 = " + num1);
        System.out.println("num2 = " + num2);
    }
    
    public static void swap(int a, int b) {
        int temp = a;
        a = b;
        b = temp;
    
        System.out.println("a = " + a);
        System.out.println("b = " + b);
    }
    

    结果

    a = 20
    b = 10
    num1 = 10
    num2 = 20
    

    解析

    img

    在swap方法中,a、b的值进行交换,并不会影响到 num1、num2。因为,a、b中的值,只是从 num1、num2 的复制过来的。也就是说,a、b相当于num1、num2 的副本,副本的内容无论怎么修改,都不会影响到原件本身。

    通过上面例子,我们已经知道了一个方法不能修改一个基本数据类型的参数,而对象引用作为参数就不一样,请看 example2.

    example 2

        public static void main(String[] args) {
            int[] arr = { 1, 2, 3, 4, 5 };
            System.out.println(arr[0]);
            change(arr);
            System.out.println(arr[0]);
        }
    
        public static void change(int[] array) {
            // 将数组的第一个元素变为0
            array[0] = 0;
        }
    

    结果

    1
    0
    

    解析

    img

    array 被初始化 arr 的拷贝也就是一个对象的引用,也就是说 array 和 arr 指向的时同一个数组对象。 因此,外部对引用对象的改变会反映到所对应的对象上。

    通过 example2 我们已经看到,实现一个改变对象参数状态的方法并不是一件难事。理由很简单,方法得到的是对象引用的拷贝,对象引用及其他的拷贝同时引用同一个对象。

    很多程序设计语言(特别是,C++和Pascal)提供了两种参数传递的方式:值调用和引用调用。有些程序员(甚至本书的作者)认为Java程序设计语言对对象采用的是引用调用,实际上,这种理解是不对的。由于这种误解具有一定的普遍性,所以下面给出一个反例来详细地阐述一下这个问题。

    example 3

    public class Test {
    
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            Student s1 = new Student("小张");
            Student s2 = new Student("小李");
            Test.swap(s1, s2);
            System.out.println("s1:" + s1.getName());
            System.out.println("s2:" + s2.getName());
        }
    
        public static void swap(Student x, Student y) {
            Student temp = x;
            x = y;
            y = temp;
            System.out.println("x:" + x.getName());
            System.out.println("y:" + y.getName());
        }
    }
    

    结果

    x:小李
    y:小张
    s1:小张
    s2:小李
    

    解析

    交换之前:

    img

    交换之后:

    img

    通过上面两张图可以很清晰的看出: 方法并没有改变存储在变量 s1 和 s2 中的对象引用。swap方法的参数x和y被初始化为两个对象引用的拷贝,这个方法交换的是这两个拷贝

    总结

    Java程序设计语言对对象采用的不是引用调用,实际上,对象引用是按值传递的。

    下面再总结一下Java中方法参数的使用情况:

    • 一个方法不能修改一个基本数据类型的参数(即数值型或布尔型》
    • 一个方法可以改变一个对象参数的状态。
    • 一个方法不能让对象参数引用一个新的对象。

    值传递和引用传递有什么区别

    值传递:指的是在方法调用时,传递的参数是按值的拷贝传递,传递的是值的拷贝,也就是说传递后就互不相关了。

    引用传递:指的是在方法调用时,传递的参数是按引用进行传递,其实传递的引用的地址,也就是变量所对应的内存空间的地址。传递的是值的引用,也就是说传递前和传递后都指向同一个引用(也就是同一个内存空间)。

    Java包

    JDK 中常用的包有哪些

    • java.lang:这个是系统的基础类;
    • java.io:这里面是所有输入输出有关的类,比如文件操作等;
    • java.nio:为了完善 io 包中的功能,提高 io 包中性能而写的一个新包;
    • java.net:这里面是与网络有关的类;
    • java.util:这个是系统辅助类,特别是集合类;
    • java.sql:这个是数据库操作的类。

    import java和javax有什么区别

    刚开始的时候 JavaAPI 所必需的包是 java 开头的包,javax 当时只是扩展 API 包来说使用。然而随着时间的推移,javax 逐渐的扩展成为 Java API 的组成部分。但是,将扩展从 javax 包移动到 java 包将是太麻烦了,最终会破坏一堆现有的代码。因此,最终决定 javax 包将成为标准API的一部分。

    所以,实际上java和javax没有区别。这都是一个名字。

    IO流

    java 中 IO 流分为几种?

    • 按照流的流向分,可以分为输入流和输出流;
    • 按照操作单元划分,可以划分为字节流和字符流;
    • 按照流的角色划分为节点流和处理流。

    Java Io流共涉及40多个类,这些类看上去很杂乱,但实际上很有规则,而且彼此之间存在非常紧密的联系, Java I0流的40多个类都是从如下4个抽象类基类中派生出来的。

    • InputStream/Reader: 所有的输入流的基类,前者是字节输入流,后者是字符输入流。
    • OutputStream/Writer: 所有输出流的基类,前者是字节输出流,后者是字符输出流。

    按操作方式分类结构图:

    IO-操作方式分类

    按操作对象分类结构图:

    IO-操作对象分类

    BIO,NIO,AIO 有什么区别?

    简答

    • BIO:Block IO 同步阻塞式 IO,就是我们平常使用的传统 IO,它的特点是模式简单使用方便,并发处理能力低。
    • NIO:Non IO 同步非阻塞 IO,是传统 IO 的升级,客户端和服务器端通过 Channel(通道)通讯,实现了多路复用。
    • AIO:Asynchronous IO 是 NIO 的升级,也叫 NIO2,实现了异步非堵塞 IO ,异步 IO 的操作基于事件和回调机制。

    详细回答

    • BIO (Blocking I/O): 同步阻塞I/O模式,数据的读取写入必须阻塞在一个线程内等待其完成。在活动连接数不是特别高(小于单机1000)的情况下,这种模型是比较不错的,可以让每一个连接专注于自己的 I/O 并且编程模型简单,也不用过多考虑系统的过载、限流等问题。线程池本身就是一个天然的漏斗,可以缓冲一些系统处理不了的连接或请求。但是,当面对十万甚至百万级连接的时候,传统的 BIO 模型是无能为力的。因此,我们需要一种更高效的 I/O 处理模型来应对更高的并发量。
    • NIO (New I/O): NIO是一种同步非阻塞的I/O模型,在Java 1.4 中引入了NIO框架,对应 java.nio 包,提供了 Channel , Selector,Buffer等抽象。NIO中的N可以理解为Non-blocking,不单纯是New。它支持面向缓冲的,基于通道的I/O操作方法。 NIO提供了与传统BIO模型中的 SocketServerSocket 相对应的 SocketChannelServerSocketChannel 两种不同的套接字通道实现,两种通道都支持阻塞和非阻塞两种模式。阻塞模式使用就像传统中的支持一样,比较简单,但是性能和可靠性都不好;非阻塞模式正好与之相反。对于低负载、低并发的应用程序,可以使用同步阻塞I/O来提升开发速率和更好的维护性;对于高负载、高并发的(网络)应用,应使用 NIO 的非阻塞模式来开发
    • AIO (Asynchronous I/O): AIO 也就是 NIO 2。在 Java 7 中引入了 NIO 的改进版 NIO 2,它是异步非阻塞的IO模型。异步 IO 是基于事件和回调机制实现的,也就是应用操作之后会直接返回,不会堵塞在那里,当后台处理完成,操作系统会通知相应的线程进行后续的操作。AIO 是异步IO的缩写,虽然 NIO 在网络操作中,提供了非阻塞的方法,但是 NIO 的 IO 行为还是同步的。对于 NIO 来说,我们的业务线程是在 IO 操作准备好时,得到通知,接着就由这个线程自行进行 IO 操作,IO操作本身是同步的。查阅网上相关资料,我发现就目前来说 AIO 的应用还不是很广泛,Netty 之前也尝试使用过 AIO,不过又放弃了。

    Files的常用方法都有哪些?

    • Files. exists():检测文件路径是否存在。
    • Files. createFile():创建文件。
    • Files. createDirectory():创建文件夹。
    • Files. delete():删除一个文件或目录。
    • Files. copy():复制文件。
    • Files. move():移动文件。
    • Files. size():查看文件个数。
    • Files. read():读取文件。
    • Files. write():写入文件。

    反射

    什么是反射机制?

    JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法和属性;这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

    静态编译和动态编译

    • **静态编译:**在编译时确定类型,绑定对象
    • **动态编译:**运行时确定类型,绑定对象

    反射机制优缺点

    • 优点: 运行期类型的判断,动态加载类,提高代码灵活度。
    • 缺点: 性能瓶颈:反射相当于一系列解释操作,通知 JVM 要做的事情,性能比直接的java代码要慢很多。

    反射机制的应用场景有哪些?

    反射是框架设计的灵魂。

    在我们平时的项目开发过程中,基本上很少会直接使用到反射机制,但这不能说明反射机制没有用,实际上有很多设计、开发都与反射机制有关,例如模块化的开发,通过反射去调用对应的字节码;动态代理设计模式也采用了反射机制,还有我们日常使用的 Spring/Hibernate 等框架也大量使用到了反射机制。

    举例:①我们在使用JDBC连接数据库时使用Class.forName()通过反射加载数据库的驱动程序;②Spring框架也用到很多反射机制,最经典的就是xml的配置模式。Spring 通过 XML 配置模式装载 Bean 的过程:1) 将程序内所有 XML 或 Properties 配置文件加载入内存中; 2)Java类里面解析xml或properties里面的内容,得到对应实体类的字节码字符串以及相关的属性信息; 3)使用反射机制,根据这个字符串获得某个类的Class实例; 4)动态配置实例的属性

    Java获取反射的三种方法

    1.通过new对象实现反射机制 2.通过路径实现反射机制 3.通过类名实现反射机制

    public class Student {
        private int id;
        String name;
        protected boolean sex;
        public float score;
    }
    
    public class Get {
        //获取反射机制三种方式
        public static void main(String[] args) throws ClassNotFoundException {
            //方式一(通过建立对象)
            Student stu = new Student();
            Class classobj1 = stu.getClass();
            System.out.println(classobj1.getName());
            //方式二(所在通过路径-相对路径)
            Class classobj2 = Class.forName("fanshe.Student");
            System.out.println(classobj2.getName());
            //方式三(通过类名)
            Class classobj3 = Student.class;
            System.out.println(classobj3.getName());
        }
    }
    

    网络编程

    网络编程的面试题可以查看我的这篇文章重学TCP/IP协议和三次握手四次挥手,内容不仅包括TCP/IP协议和三次握手四次挥手的知识,还包括计算机网络体系结构,HTTP协议,get请求和post请求区别,session和cookie的区别等,欢迎大家阅读。

    常用API

    String相关

    字符型常量和字符串常量的区别

    1. 形式上: 字符常量是单引号引起的一个字符 字符串常量是双引号引起的若干个字符
    2. 含义上: 字符常量相当于一个整形值(ASCII值),可以参加表达式运算 字符串常量代表一个地址值(该字符串在内存中存放位置)
    3. 占内存大小 字符常量只占两个字节 字符串常量占若干个字节(至少一个字符结束标志)

    什么是字符串常量池?

    字符串常量池位于堆内存中,专门用来存储字符串常量,可以提高内存的使用率,避免开辟多块空间存储相同的字符串,在创建字符串时 JVM 会首先检查字符串常量池,如果该字符串已经存在池中,则返回它的引用,如果不存在,则实例化一个字符串放到池中,并返回其引用。

    String 是最基本的数据类型吗

    不是。Java 中的基本数据类型只有 8 个 :byte、short、int、long、float、double、char、boolean;除了基本类型(primitive type),剩下的都是引用类型(referencetype),Java 5 以后引入的枚举类型也算是一种比较特殊的引用类型。

    这是很基础的东西,但是很多初学者却容易忽视,Java 的 8 种基本数据类型中不包括 String,基本数据类型中用来描述文本数据的是 char,但是它只能表示单个字符,比如 ‘a’,‘好’ 之类的,如果要描述一段文本,就需要用多个 char 类型的变量,也就是一个 char 类型数组,比如“你好” 就是长度为2的数组 char[] chars = {‘你’,‘好’};

    但是使用数组过于麻烦,所以就有了 String,String 底层就是一个 char 类型的数组,只是使用的时候开发者不需要直接操作底层数组,用更加简便的方式即可完成对字符串的使用。

    String有哪些特性

    • 不变性:String 是只读字符串,是一个典型的 immutable 对象,对它进行任何操作,其实都是创建一个新的对象,再把引用指向该对象。不变模式的主要作用在于当一个对象需要被多线程共享并频繁访问时,可以保证数据的一致性。

    • 常量池优化:String 对象创建之后,会在字符串常量池中进行缓存,如果下次创建同样的对象时,会直接返回缓存的引用。

    • final:使用 final 来定义 String 类,表示 String 类不能被继承,提高了系统的安全性。

    String为什么是不可变的吗?

    简单来说就是String类利用了final修饰的char类型数组存储字符,源码如下图所以:

    /** The value is used for character storage. */
    private final char value[];
    

    String真的是不可变的吗?

    我觉得如果别人问这个问题的话,回答不可变就可以了。 下面只是给大家看两个有代表性的例子:

    1) String不可变但不代表引用不可以变

    String str = "Hello";
    str = str + " World";
    System.out.println("str=" + str);
    

    结果:

    str=Hello World
    

    解析:

    实际上,原来String的内容是不变的,只是str由原来指向"Hello"的内存地址转为指向"Hello World"的内存地址而已,也就是说多开辟了一块内存区域给"Hello World"字符串。

    2) 通过反射是可以修改所谓的“不可变”对象

    // 创建字符串"Hello World", 并赋给引用s
    String s = "Hello World";
    
    System.out.println("s = " + s); // Hello World
    
    // 获取String类中的value字段
    Field valueFieldOfString = String.class.getDeclaredField("value");
    
    // 改变value属性的访问权限
    valueFieldOfString.setAccessible(true);
    
    // 获取s对象上的value属性的值
    char[] value = (char[]) valueFieldOfString.get(s);
    
    // 改变value所引用的数组中的第5个字符
    value[5] = '_';
    
    System.out.println("s = " + s); // Hello_World
    

    结果:

    s = Hello World
    s = Hello_World
    

    解析:

    用反射可以访问私有成员, 然后反射出String对象中的value属性, 进而改变通过获得的value引用改变数组的结构。但是一般我们不会这么做,这里只是简单提一下有这个东西。

    是否可以继承 String 类

    String 类是 final 类,不可以被继承。

    String str="i"与 String str=new String(“i”)一样吗?

    不一样,因为内存的分配方式不一样。String str="i"的方式,java 虚拟机会将其分配到常量池中;而 String str=new String(“i”) 则会被分到堆内存中。

    String s = new String(“xyz”);创建了几个字符串对象

    两个对象,一个是静态区的"xyz",一个是用new创建在堆上的对象。

    String str1 = "hello"; //str1指向静态区
    String str2 = new String("hello");  //str2指向堆上的对象
    String str3 = "hello";
    String str4 = new String("hello");
    System.out.println(str1.equals(str2)); //true
    System.out.println(str2.equals(str4)); //true
    System.out.println(str1 == str3); //true
    System.out.println(str1 == str2); //false
    System.out.println(str2 == str4); //false
    System.out.println(str2 == "hello"); //false
    str2 = str1;
    System.out.println(str2 == "hello"); //true
    

    如何将字符串反转?

    使用 StringBuilder 或者 stringBuffer 的 reverse() 方法。

    示例代码:

    // StringBuffer reverse
    StringBuffer stringBuffer = new StringBuffer();
    stringBuffer. append("abcdefg");
    System. out. println(stringBuffer. reverse()); // gfedcba
    // StringBuilder reverse
    StringBuilder stringBuilder = new StringBuilder();
    stringBuilder. append("abcdefg");
    System. out. println(stringBuilder. reverse()); // gfedcba
    

    数组有没有 length()方法?String 有没有 length()方法

    数组没有 length()方法 ,有 length 的属性。String 有 length()方法。JavaScript中,获得字符串的长度是通过 length 属性得到的,这一点容易和 Java 混淆。

    String 类的常用方法都有那些?

    • indexOf():返回指定字符的索引。
    • charAt():返回指定索引处的字符。
    • replace():字符串替换。
    • trim():去除字符串两端空白。
    • split():分割字符串,返回一个分割后的字符串数组。
    • getBytes():返回字符串的 byte 类型数组。
    • length():返回字符串长度。
    • toLowerCase():将字符串转成小写字母。
    • toUpperCase():将字符串转成大写字符。
    • substring():截取字符串。
    • equals():字符串比较。

    在使用 HashMap 的时候,用 String 做 key 有什么好处?

    HashMap 内部实现是通过 key 的 hashcode 来确定 value 的存储位置,因为字符串是不可变的,所以当创建字符串时,它的 hashcode 被缓存下来,不需要再次计算,所以相比于其他对象更快。

    String和StringBuffer、StringBuilder的区别是什么?String为什么是不可变的

    可变性

    String类中使用字符数组保存字符串,private final char value[],所以string对象是不可变的。StringBuilder与StringBuffer都继承自AbstractStringBuilder类,在AbstractStringBuilder中也是使用字符数组保存字符串,char[] value,这两种对象都是可变的。

    线程安全性

    String中的对象是不可变的,也就可以理解为常量,线程安全。AbstractStringBuilder是StringBuilder与StringBuffer的公共父类,定义了一些字符串的基本操作,如expandCapacity、append、insert、indexOf等公共方法。StringBuffer对方法加了同步锁或者对调用的方法加了同步锁,所以是线程安全的。StringBuilder并没有对方法进行加同步锁,所以是非线程安全的。

    性能

    每次对String 类型进行改变的时候,都会生成一个新的String对象,然后将指针指向新的String 对象。StringBuffer每次都会对StringBuffer对象本身进行操作,而不是生成新的对象并改变对象引用。相同情况下使用StirngBuilder 相比使用StringBuffer 仅能获得10%~15% 左右的性能提升,但却要冒多线程不安全的风险。

    对于三者使用的总结

    如果要操作少量的数据用 = String

    单线程操作字符串缓冲区 下操作大量数据 = StringBuilder

    多线程操作字符串缓冲区 下操作大量数据 = StringBuffer

    Date相关

    包装类相关

    自动装箱与拆箱

    装箱:将基本类型用它们对应的引用类型包装起来;

    拆箱:将包装类型转换为基本数据类型;

    int 和 Integer 有什么区别

    Java 是一个近乎纯洁的面向对象编程语言,但是为了编程的方便还是引入了基本数据类型,但是为了能够将这些基本数据类型当成对象操作,Java 为每一个基本数据类型都引入了对应的包装类型(wrapper class),int 的包装类就是 Integer,从 Java 5 开始引入了自动装箱/拆箱机制,使得二者可以相互转换。

    Java 为每个原始类型提供了包装类型:

    原始类型: boolean,char,byte,short,int,long,float,double

    包装类型:Boolean,Character,Byte,Short,Integer,Long,Float,Double

    Integer a= 127 与 Integer b = 127相等吗

    对于对象引用类型:==比较的是对象的内存地址。
    对于基本数据类型:==比较的是值。

    如果整型字面量的值在-128到127之间,那么自动装箱时不会new新的Integer对象,而是直接引用常量池中的Integer对象,超过范围 a1==b1的结果是false

    public static void main(String[] args) {
        Integer a = new Integer(3);
        Integer b = 3;  // 将3自动装箱成Integer类型
        int c = 3;
        System.out.println(a == b); // false 两个引用没有引用同一对象
        System.out.println(a == c); // true a自动拆箱成int类型再和c比较
        System.out.println(b == c); // true
    
        Integer a1 = 128;
        Integer b1 = 128;
        System.out.println(a1 == b1); // false
    
        Integer a2 = 127;
        Integer b2 = 127;
        System.out.println(a2 == b2); // true
    }
    

    常用工具类库

    单元测试

    日志

    展开全文
  • 基于51单片机的交通灯控制系统设计

    万次阅读 多人点赞 2018-11-24 13:38:11
    交通灯是生活中的重要系统。本设计为基于51单片机交通灯系统的设计,采用模块化、层次化设计。运用单片机AT89C51进行数据的分析和处理,为显示提供信号,显示部分采用8位数码管显示倒计时值。系统电路简单、集成度高...

    第一章 硬件设计与原理
    以AT89C51单片机为核心,起着控制作用。系统包括数码管显示电路、复位电路、时钟电路、发光二级管电路和按键电路。设计思路分为六个模块:复位电路、晶振电路模块、AT89C51、数码管显示电路、发光二级管电路和按键电路这六个模块。

    在这里插入图片描述

    1.2 硬件设计分析
    1.2.1 电源的设计
    系统电源使用直流5伏。
    由电脑USB接口提供电源。
    USB是通用串行总线(Universal Serial Bus)接口的简称。它是目前使用比较广泛的电脑接口之一,主要版本有1.0、1.1和最新的2.0三种版本。根据USB总线的工业标准,它可以提供额定功率为5V/500mA的电源供USB设备使用。
    1.2.2 单片机最小系统
    51单片机是对目前所有兼容intel 8031指令系统的单片机的统称。该系列单片机的始祖是intel的8031单片机,后来随着技术的发展,成为目前广泛应用的8为单片机之一。单片机是在一块芯片内集成了CPU、RAM、ROM、定时器/计数器和多功能I/O口等计算机所需要的基本功能部件的大规模集成电路,又称为MCU。51系列单片机内包含以下几个部件:
    一个8位CPU;一个片内振荡器及时钟电路;
    4KB的ROM程序存储器;
    一个128B的RAM数据存储器;
    寻址64KB外部数据存储器和64KB外部程序存储空间的控制电路;
    32条可编程的I/O口线;
    两个16位定时/计数器;
    一个可编程全双工串行口;
    5个中断源、两个优先级嵌套中断结构。
    如图1-2-1所示为AT89C51单片机基本构造,其基本性能介绍如下:
    图1-2-1 AT89C51单片机

    AT89C51本身内含40个引脚,32个外部双向输入/输出(I/O)端口,同时内含2个外中端口,3个16位可编程定时计数器,2个全双工串行通信口,STC89C51RC可以按照常规方法进行编程,但不可以在线编程。其将通用的微处理器和Flash存储器结合在一起,特别是可反复擦写的Flash存储器可有效地降低开发成本。
    AT89C51的主要特性如下表所示:

    在这里插入图片描述

    AT89C51为40脚双列直插封装的8位通用微处理器,采用工业标准的C51内核,在内部功能及管脚排布上与通用的8xc52相同,其主要用于会聚调整时的功能控制。功能包括对会聚主IC内部寄存器、数据RAM及外部接口等功能部件的初始化,会聚调整控制,会聚测试图控制,红外遥控信号IR的接收解码及与主板CPU通信等。主要管脚有:XTAL1(19脚)和XTAL2(18脚)为振荡器输入输出端口,外接12MHz 晶振。RST/Vpd(9脚)为复位输入端口,外接电阻电容组成的复位电路。VCC(40脚)和VSS(20脚)为供电端口,分别接+5V电源的正负端。P0~P3 为可编程通用I/O脚,其功能用途由软件定义,在本设计中,P0端口(32~39脚)被定义为N1功能控制端口,分别与N1的相应功能管脚相连接,13脚定义为IR输入端,10脚和11脚定义为I2C总线控制端口,分别连接N1的SDAS(18脚)和SCLS(19脚)端口,12脚、27脚及28脚定义为握手信号功能端口,连接主板CPU的相应功能端,用于当前制式的检测及会聚调整状态进入的控制功能。
    P0口:P0口是一组8位漏极开路型双向I/O 口,也即地址/数据总线复用口。作为输出口用时,每位能吸收电流的方式驱动8个TTL逻辑门电路,对端口P0写“1”时,可作为高阻抗输入端用。在访问外部数据存储器或程序存储器时,这组口线分时转换地址(低8位)和数据总线复用,在访问期间激活内部上拉电阻。在Flash 编程时,P0口接收指令字节,而在程序校验时,输出指令字节,校验时,要求外接上拉电阻。
    P1口:P1是一个带内部上拉电阻的8位双向I/O口,P1的输出缓冲级可驱动(吸收或输出电流)4个TTL逻辑门电路。对端口写“1”,通过内部的上拉电阻把端口拉到高电平,此时可作输入口。作输入口使用时,因为内部存在上拉电阻,某个引脚被外部信号拉低时会输出一个电流(IIL)。与AT89C51不同之处是,P1.0和P1.1还可分别作为定时/计数器2 的外部计数输入(P1.0/T2)和输入(P1.1/T2EX)。Flash编程和程序校验期间,P1接收低8位地址。
    P2口:P2是一个带有内部上拉电阻的8 位双向I/O口,P2的输出缓冲级可驱动(吸收或输出电流)4个TTL逻辑门电路。对端口P2写“1”,通过内部的上拉电阻把端口拉到高电平,此时可作输入口,作输入口使用时,因为内部存在上拉电阻,某个引脚被外部信号拉低时会输出一个电流(IIL)。在访问外部程序存储器或16位地址的外部数据存储器(例如执行MOVX @DPTR指令)时,P2口送出高8位地址数据。在访问8位地址的外部数据存储器(如执行MOVX @RI指令)时,P2口输出P2锁存器的内容。Flash编程或校验时,P2亦接收高位地址和一些控制信号。
    P3口:P3口是一组带有内部上拉电阻的8位双向I/O口。P3口输出缓冲级可驱动(吸收或输出电流)4个TTL逻辑门电路。对P3口写入“1”时,它们被内部上拉电阻拉高并可作为输入端口。此时,被外部拉低的P3口将用上拉电阻输出电流(IIL)。P3口除了作为一般的I/O口线外,更重要的用途是它的第二功能P3口还接收一些用于Flash 闪速存储器编程和程序校验的控制信号。
    RST:复位输入。当振荡器工作时,RST引脚出现两个机器周期以上高电平将使单片机复位。
    ALE/PROG:当访问外部程序存储器或数据存储器时,ALE(地址锁存允许)输出脉冲用于锁存地址的低8位字节。一般情况下,ALE仍以时钟振荡频率的1/6输出固定的脉冲信号,因此它可对外输出时钟或用于定时目的。要注意的是:每当访问外部数据存储器时将跳过一个AL脉冲。对Flash存储器编程期间,该引脚还用于输入编程脉冲(PROG)。如有必要,可通过对特殊功能寄存器(SFR)区中的8EH单元的D0位置位,可禁止ALE操作。该位置位后,只有一条 MOVX 和MOVC指令才能将ALE激活。此外,该引脚会被微弱拉高,单片机执行外部程序时,应设置ALE禁止位无效。
    PSEN:程序储存允许(PSEN)输出是外部程序存储器的读选通信号,当AT89C51由外部程序存储器取指令(或数据)时,每个机器周期两次PSEN有效,即输出两个脉冲。在此期间,当访问外部数据存储器,将跳过两次PSEN信号。
    EA/VPP:外部访问允许。欲使CPU仅访问外部程序存储器(地址为0000H—FFFFH),EA端必须保持低电平(接地)。需注意的是:如果加密位LB1被编程,复位时内部会锁存EA端状态。如EA端为高电平(接Vcc端),CPU则执行内部程序存储器中的指令。Flash存储器编程时,该引脚加上+12V的编程允许电源Vpp,当然这必须是该器件是使用12V编程电压Vpp。
    XTAL1:振荡器反相放大器的及内部时钟发生器的输入端。
    XTAL2:振荡器反相放大器的输出端。
    单片机最小原理图如图1-2-2所示。
    图1-2-2 单片机最小系统

    单片机最小系统说明:
    时钟信号的产生:在MCS-51芯片内部有一个高增益反相放大器,其输入端为芯片引脚XTAL1,其输出端为引脚XTAL2。而在芯片的外部,XTAL1和XTAL2之间跨接晶体振荡器和微调电容,从而构成一个稳定的自激振荡器,这就是单片机的时钟振荡电路。
    时钟电路产生的振荡脉冲经过触发器进行二分频之后,才成为单片机的时钟脉冲信号。
    一般地,电容C2和C3取30pF左右,晶体的振荡频率范围是1.2-12MHz。如果晶体振荡频率高,则系统的时钟频率也高,单片机的运行速度也就快。
    单片机复位使CPU和系统中的其他功能部件都处在一个确定的初始状态下,并从这个状态开始工作。单片机复位条件:必须使9脚加上持续两个机器周期(即24个振荡周期)的高电平。
    1.2.3 显示系统
    数码管是一种半导体发光器件,其基本单元是发光二极管。
    数码管按段数分为七段数码管和八段数码管,八段数码管比七段数码管多一个发光二极管单元(多一个小数点显示);按能显示多少个“8”可分为1位、2位、4位等等数码管;按发光二极管单元连接方式分为共阳极数码管和共阴极数码管。共阳数码管是指将所有发光二极管的阳极接到一起形成公共阳极(COM)的数码管。共阳数码管在应用时应将公共极COM接到+5V,当某一字段发光二极管的阴极为低电平时,相应字段就点亮。当某一字段的阴极为高电平时,相应字段就不亮。。共阴数码管是指将所有发光二极管的阴极接到一起形成公共阴极(COM)的数码管。共阴数码管在应用时应将公共极COM接到地线GND上,当某一字段发光二极管的阳极为高电平时,相应字段就点亮。当某一字段的阳极为低电平时,相应字段就不亮。
    数码管要正常显示,就要用驱动电路来驱动数码管的各个段码,从而显示出我们要的数字,因此根据数码管的驱动方式的不同,可以分为静态式和动态式两类。
    1) 静态显示驱动:静态驱动也称直流驱动。静态驱动是指每个数码管的每一个段码都由一个单片机的I/O端口进行驱动,或者使用如BCD码二-十进制译码器译码进行驱动。静态驱动的优点是编程简单,显示亮度高,缺点是占用I/O端口多,如驱动5个数码管静态显示则需要5×8=40根I/O端口来驱动(要知道一个89C51单片机可用的I/O端口才32个呢),实际应用时必须增加译码驱动器进行驱动,增加了硬件电路的复杂性。
    2) 动态显示驱动:数码管动态显示接口是单片机中应用最为广泛的一种显示方式之一,动态驱动是将所有数码管的8个显示笔划"a,b,c,d,e,f,g,dp"的同名端连在一起,另外为每个数码管的公共极COM增加位选通控制电路,位选通由各自独立的I/O线控制,当单片机输出字形码时,所有数码管都接收到相同的字形码,但究竟是那个数码管会显示出字形,取决于单片机对位选通COM端电路的控制,所以我们只要将需要显示的数码管的选通控制打开,该位就显示出字形,没有选通的数码管就不会亮。通过分时轮流控制各个数码管的的COM端,就使各个数码管轮流受控显示,这就是动态驱动。
    本设计中数码管采用的是动态驱动方式。
    数码管外形如图1-2-3,数码管电路结构如图1-2-4。

    图1-2-3 数码管外形图
    图1-2-4 数码管电路结构示意图

    在这里插入图片描述
    图1-2-5 数码管显示电路
    1.2.4 发光二级管电路

    图1-2-6 发光二级管电路
    1.2.5 按键电路
    图1-2-7 按键电路

    第二章 软件设计与分析
    2.1 软件设计的组成
    该系统由延时子函数、数码管显示子函数、定时器0中断子函数、主函数和数据定义这几部分组成。
    在这里插入图片描述

    在这里插入图片描述

    //----------------------------------------------------------------------//
    上传过程感觉繁琐,里面可能有不全面的地方,请见谅。下面的是实现的目的。以及电路原理图

    **本次设计的主要目的是设计一个城市十字路口的交通灯控制系统,设计中将交通灯控制系统分为东西方向(主干道)和南北方向(次干道)两个方向,且在东西南北四个路口的每个路口设置红、绿、黄三个交通信号灯(用发光二极管模拟)和一个二位的LED数码显示管。设计的要求是规定在每一段时间内东西和南北两个方向中只有一个方向能够通行,另一个方向处于禁行状态,然后在经过一段时间后,禁行的方向和通行的方向互相转换状态,原来通行的状态变禁行状态,原来禁行的状态变为通行状态,如此循环下去。详细过程如下图2-1:
    状态① 状态②
    图 1图2-1 交通灯状态图
    状态①:东西方向的交通灯黄灯闪烁3秒后,红灯熄灭,绿灯点亮(东西方向允许车辆和行人通行),同时南北方向绿灯熄灭,红灯点亮(南北方向禁止车辆和行人通行),LED数码管倒计时显示40秒,在倒计时3秒时进入状态②。
    状态②:南北方向黄灯闪烁3秒后,红灯熄灭绿灯点亮(南北允许车辆和行人通行);同时东西方向绿灯熄灭,红灯点亮
    (东西方向禁止车辆和行人通行),LED数码管倒计时显示40秒,在倒计时3秒时进入状态①。
    接下来在没有人为干涉下将会一直按照上述进行循环。设计中还外设6个按键实现对交通灯控制系统的调控作用。

    电路原理图

    在这里插入图片描述

    在这里插入图片描述

    //——————————————————————————-——————————//
    相应的代码已经上传

    下载地址
    https://download.csdn.net/download/weixin_43442020/12231456

    下载链接里可以下载,解压后里面有压缩文件,压缩文件里面的资料更详细

    展开全文
  • OFDM完整仿真过程及解释(MATLAB)

    万次阅读 多人点赞 2019-04-19 17:03:45
    因为是复制过来,如果出现图片显示不完整以及需要源程序请点击下面... ... 目录: 一、说明 二、ofdm总体概述 ...、基本原理 四、过程中涉及的技术 五、OFDM基本参数的选择 六、OFDM的MATLAB仿真程序 一、说...

    因为是复制过来,如果出现图片显示不完整以及需要源程序请点击下面链接查看原文:

    OFDM完整仿真过程及解释(MATLAB) - 子木的文章 - 知乎

    点击这里访问原文

    后面的更新没有同步,点上面链接可以看更新部分。

     

    目录:

    一、说明

    二、ofdm总体概述

    三、基本原理

    四、过程中涉及的技术

    五、OFDM基本参数的选择

    六、OFDM的MATLAB仿真程序

     

    一、说明

    0.能找到这篇文章,说明对ofdm已经有一点了解,所以其原理就不再赘述,这篇代码的目的只是希望能对ofdm整个过程有一个理解;

    1.看书上ofdm介绍挺简单的,自己来仿真才发现很多知识点都不知道;

    2.花了很长时间才理清整个ofdm过程,网上的程序都是一段一段的,不能直接理解整个过程。所以想着自己来做一个完整过程的仿真,加深理解;

    3.基带信号能完成整个过程,但是想加进频带传输这一部分,就完整了;

    4.信道部分想用瑞利信道的,程序写出来了,但是误差和信道估计这一块还不是很明白,所以就先用的高斯信道;

    5.不足之处欢迎指正。。。。

    二、概述

    OFDM是一种特殊的多载波传输方案,它可以被看作是一种调制技术,也可以被当作一种复用技术。

    简单来说:OFDM是一种多载波的传输方法,它将频带划分为多个子信道并行传输数据,将高速数据流分成多个并行的低速数据流,然后调制到每个信道的子载波上进行传输。由于它将非平坦衰落无线信道转化成多个正交平坦衰落的子信道,从而可消除信道波形间的干扰,达到对抗多径衰落的目的。

    正交频分复用(OFDM)是对多载波调制(MCM)的一种改进,在。它的特点是:各子载波相互正交,所以扩频调制后的频谱可以相互重叠,不但减少了子载波间的相互干扰,还大大提高了频谱利用率。

    选择OFDM的一个很大的原因是该系统能够很好的对抗频率选择性衰落和窄带干扰。在单载波系统中,一次衰落或者干扰会导致整个链路失效,但是在多载波系统中,某一时刻只会有少部分的子信道受到深衰落的影响。

    三、基本原理

    3.1 OFDM系统收发机的典型(根据实际需要可添/删部分)框图如下:

    OFDM收发机框图

    其中,上半部分对应于发射机链路,下半部分对应于接收机链路。

    发送端将被传输的数字信号转换成子载波幅度和相位的映射,并进行离散傅里叶变换(IDFT),将数据的频谱表达式变到时域上。IFFT和IDFT变换的作用相同,只是有更高的计算效率,所以适用于所有的应用系统。接收端进行与发送端相反的操作,用FFT变换分解,子载波的幅度和相位最终转换回数字信号。

    这里理解为传输的频域信号是因为IFFT是从频域到时域,实际上这里IFFT充当的是一个实现子载波正交的作用,具体可以推导其DFT公式。知乎里公式编辑太麻烦了。

     

    3.2 OFDM调制与解调

    一个OFDM符号之内包括多个经过调制的子载波的合成信号,其中每个子载波都可以收到psk(相移键控)和qam(正交幅度调制)的调制。

    OFDM发射机将信息比特流映射成一个psk或qam符号序列,之后将串行的符号序列转换为并行符号流。每N个经过串并转换的符号被不同的子载波调制。

    OFDM符号是N个并行符号的复合信号,若单个串行符号的传输时间(周期)是Ts,则一个OFDM符号的持续时间(周期)Tsym=N*Ts。

    频域调制信号X[k]的频率为:fk=k/Tsym,子载波数量为N,则k=0,1,2.....N-1。(由DFT原理推导)

    四、过程中涉及的技术

    为什么要用?怎么用?

    4.1 保护间隔

    多径信道会对OFDM符号造成ISI影响,破坏了子载波间的正交性。故需要采取一些方法来消除多径信道带来的符号间干扰(ISI)影响,即插入保护间隔。

    保护间隔有两种插入方法:一种是补零(zp),即在保护间隔中填充0;另一种是插入循环前缀(cp)或循环后缀(cs)实现OFDM的循环扩展(为了某种连续性)。

    zp是在保护间隔内不插入任何信号,但是在这种情况下,由于多径传播的影响,会产生载波间干扰(ICI),即不同的子载波间会产生干扰。

    一般采用cp。cp是将OFDM后部的采样复制到前面,长度为Tcp,故每个符号的长度为Tsym=Tsub+Tcp,Tsub为数据部分子载波数。Tcp大于或等于多径时延,符号间的ISI影响将被限制在保护间隔中,因此不会影响下一个OFDM的FFT变换。

    4.2交织

    交织的作用是将突发错误转换为随机错误,有利于前向纠错码的译码,提高了整个通信系统的可靠性。交织由两个变换过程组成。第一次变换保证了相邻的编码比特被映射到不相邻的子载波上。第二次变换保证了相邻的编码比特被分别映射到星座图的重要和非重要比特上,避免出现长时间的低比特位映射。

    交织块的长度Ncbps,对qpsk、16qam、64qam分别为2、4、6,s=Ncbps/2,d=16。

    4.3信道编码

    由于移动通信存在干扰和衰落,在信号传输过程中将出现差错,故对数字信号必须采用纠、检错技术,即纠、检错编码技术,以增强数据在信道中传输时抵御各种干扰的能力,提高系统的可靠性。

    这里的信道编码一般采用卷积编码,Viterbi译码。

    卷积编码是现代数字通信系统中常见的一种前向纠错码,区别于常规的线性分组码,卷积编码的码字输出不仅与当前时刻的信息符号输入有关,还与之前输入的信息符号有关。

    4.4 扩频

    “扩频通信技术是一种信息传输方式,其信号所占有的频带宽度远大于所传信息必需的最小带宽;频带的扩展是通过一个独立的码序列来完成,用编码及调制的方法来实现的,与所传信息数据无关;在接收端则用同样的码进行相关同步接收、解扩及恢复所传信息数据”

    根据香农定理,带宽和信噪比可用互换,扩频扩展了带宽,则对信噪比的要求可降低。

    4.5 导频

    导频不携带信息,导频是双方已知的数据,是用来做信道估计的。

    在接收机中,虽然利用接收到的段训练序列、长训练序列可以进行信道均衡、频率偏差校正,但符号还会存在一定的剩余偏差,且偏差会随着时间的累积而累积,会造成所有子载波产生一定的相位偏移。因此,还需要不断地对参考相位进行跟踪。要能实现这个功能,需要在52个非0子载波中插入导频符号。

    4.6 RF(射频)调制

    OFDM调制器的输出产生了一个基带信号,将此基带信号与所需传输的频率进行混频操作,利用模拟技术或数字上变频可完成。由于数字调制技术提高了处理I、Q信道之间的匹配性和数字IQ调制器相位的准确性,将会更加精确。

    五、OFDM基本参数的选择

    5.1 各种OFDM参数的选择就是需要在多项要求冲突中进行折衷考虑。通常来说,首先要确认3个参数:带宽、比特率、及保护间隔。

    5.1.1 按照惯例,保护间隔的时间长度应该为应用移动环境信道的时延扩展均方根值的2~4倍。

    5.1.2 确定保护间隔之后,则OFDM符号周期长度就确定了。为了最大限度的减少由于插入保护比特所带来的信噪比的损失,OFDM符号周期长度远远大于保护间隔长度。但是符号周期又不能任意大,否则就需要更多的子载波,带宽不变,子载波间隔就变小,系统的实现复杂度就提高了,而且还加大了系统的峰值平均功率比,同时系统对频率偏差更加敏感。因此,一般选择符号周期长度是保护间隔的5倍,这样,由于插入保护比特所造成的信噪比损耗只有1dB左右。

    5.1.3 确定保护间隔和符号周期长度之后,子载波的数量可由-3dB带宽除以子载波间隔(即去掉保护间隔之后的符号周期的倒数)得到。或者可由所要求比特速率除以每个子信道的比特速率来确定子载波的数量。每个信道中所传输的比特速率可由调制类型、编码速率、和符号速率来确定。

    5.2 有用符号持续时间T

    T对子载波之间间隔、译码的等待周期都有影响,为了保持数据的吞吐量,子载波数目和FFT的长度要有相对较大的数量,这就导致符号持续时间变长。总之,符号周期长度的选择以保证信道的稳定为前提。

    5.3 子载波数

    N=1/T

    其数值与FFT处理过的复数点数相对应,需适应数据速率和保护间隔的要求。

    5.4 调制模式

    OFDM系统的调制模式基于功率和频谱利用率来选择,可采用qam、psk。

    为了使所有的点有相同的平均功率,二进制序列映射后的复数要归一化。(BPSK\QPSK\16QAM\64QAM分别对应乘以1、1/根号2、1/根号10、1/根号42),解调的时候再变回去。

    5.5 以具体实例说明;

    要求:(1)比特率为25Mbit/s(2)可容忍的时延扩展为200ns(3)带宽小于18MHz。

    1)由200ns时延扩展得保护间隔为800ns;

    2)由保护间隔800ns得符号周期长度6*800ns=4.8us;

    3)子载波的间隔选取4.8-0.8=4us的倒数,即250KHz;

    4)由所要求的比特速率与OFDM符号速率的比值,每个符号需要传送的比特:25Mbit/s)/(1/4.8us)=120bit。

    5)为了完成上面120bit/符号,有两种选择:利用16QAM和码率为1/2的编码方法,这样每个子载波携带2bit的有用信息,因此需要60个子载波;另一种是利用QPSK和码率为3/4的编码方法,每个子载波携带1.5bit信息。因此需要80个子载波,然而80个子载波意外着带宽:80*250KHz=20MHz,大于所给带宽要求,故取第一种,即60个子载波。可利用64点IFFT来实现,剩余4个子载波补0.

    六、OFDM的MATLAB仿真主程序

    clc;
    clear;
    
    %————————————————————————————————————————————————————————%
    %q1:ifft点数难道不是应该等于子载波数吗?子载波数与ifft点数的关系?
    %a:ifft点数等于子载波数
    %q2:对矩阵进行fft?
    %a:y可以是一向量或矩阵,若y为向量,则Y是y的FFT,并且与y具有相同的长度。若y为一矩阵,则Y是对矩阵的每一列向量进行FFT。
    %q3:怎么对ofdm信号上变频
    %————————————————————————————————————————————————————————%
    
    %% 参数设置
    
    N_sc=52;      %系统子载波数(不包括直流载波)、number of subcarrier
    N_fft=64;            % FFT 长度
    N_cp=16;             % 循环前缀长度、Cyclic prefix
    N_symbo=N_fft+N_cp;        % 1个完整OFDM符号长度
    N_c=53;             % 包含直流载波的总的子载波数、number of carriers
    M=4;               %4PSK调制
    SNR=0:1:25;         %仿真信噪比
    N_frm=10;            % 每种信噪比下的仿真帧数、frame
    Nd=6;               % 每帧包含的OFDM符号数
    P_f_inter=6;      %导频间隔
    data_station=[];    %导频位置
    L=7;                %卷积码约束长度
    tblen=6*L;          %Viterbi译码器回溯深度
    stage = 3;          % m序列的阶数
    ptap1 = [1 3];      % m序列的寄存器连接方式
    regi1 = [1 1 1];    % m序列的寄存器初始值
    
    
    %% 基带数据数据产生
    P_data=randi([0 1],1,N_sc*Nd*N_frm);
    
    
    %% 信道编码(卷积码、或交织器)
    %卷积码:前向纠错非线性码
    %交织:使突发错误最大限度的分散化
    trellis = poly2trellis(7,[133 171]);       %(2,1,7)卷积编码
    code_data=convenc(P_data,trellis);
    
    
    %% qpsk调制
    data_temp1= reshape(code_data,log2(M),[])';             %以每组2比特进行分组,M=4
    data_temp2= bi2de(data_temp1);                             %二进制转化为十进制
    modu_data=pskmod(data_temp2,M,pi/M);              % 4PSK调制
    % figure(1);
    scatterplot(modu_data),grid;                  %星座图(也可以取实部用plot函数)
    
    %% 扩频
    %————————————————————————————————————————————————————————%
    %扩频通信信号所占有的频带宽度远大于所传信息必需的最小带宽
    %根据香农定理,扩频通信就是用宽带传输技术来换取信噪比上的好处,这就是扩频通信的基本思想和理论依据。
    %扩频就是将一系列正交的码字与基带调制信号内积
    %扩频后数字频率变成了原来的m倍。码片数量 = 2(符号数)* m(扩频系数)
    %————————————————————————————————————————————————————————%
    
    code = mseq(stage,ptap1,regi1,N_sc);     % 扩频码的生成
    code = code * 2 - 1;         %将1、0变换为1、-1
    modu_data=reshape(modu_data,N_sc,length(modu_data)/N_sc);
    spread_data = spread(modu_data,code);        % 扩频
    spread_data=reshape(spread_data,[],1);
    
    %% 插入导频
    P_f=3+3*1i;                       %Pilot frequency
    P_f_station=[1:P_f_inter:N_fft];%导频位置(导频位置很重要,why?)
    pilot_num=length(P_f_station);%导频数量
    
    for img=1:N_fft                        %数据位置
        if mod(img,P_f_inter)~=1          %mod(a,b)就是求的是a除以b的余数
            data_station=[data_station,img];
        end
    end
    data_row=length(data_station);
    data_col=ceil(length(spread_data)/data_row);
    
    pilot_seq=ones(pilot_num,data_col)*P_f;%将导频放入矩阵
    data=zeros(N_fft,data_col);%预设整个矩阵
    data(P_f_station(1:end),:)=pilot_seq;%对pilot_seq按行取
    
    if data_row*data_col>length(spread_data)
        data2=[spread_data;zeros(data_row*data_col-length(spread_data),1)];%将数据矩阵补齐,补0是虚载频~
    end;
    
    %% 串并转换
    data_seq=reshape(data2,data_row,data_col);
    data(data_station(1:end),:)=data_seq;%将导频与数据合并
    
    %% IFFT
    ifft_data=ifft(data); 
    
    %% 插入保护间隔、循环前缀
    Tx_cd=[ifft_data(N_fft-N_cp+1:end,:);ifft_data];%把ifft的末尾N_cp个数补充到最前面
    
    %% 并串转换
    Tx_data=reshape(Tx_cd,[],1);%由于传输需要
    
    %% 信道(通过多经瑞利信道、或信号经过AWGN信道)
     Ber=zeros(1,length(SNR));
     Ber2=zeros(1,length(SNR));
    for jj=1:length(SNR)
        rx_channel=awgn(Tx_data,SNR(jj),'measured');%添加高斯白噪声
        
    %% 串并转换
        Rx_data1=reshape(rx_channel,N_fft+N_cp,[]);
        
    %% 去掉保护间隔、循环前缀
        Rx_data2=Rx_data1(N_cp+1:end,:);
    
    %% FFT
        fft_data=fft(Rx_data2);
        
    %% 信道估计与插值(均衡)
        data3=fft_data(1:N_fft,:); 
        Rx_pilot=data3(P_f_station(1:end),:); %接收到的导频
        h=Rx_pilot./pilot_seq; 
        H=interp1( P_f_station(1:end)',h,data_station(1:end)','linear','extrap');%分段线性插值:插值点处函数值由连接其最邻近的两侧点的线性函数预测。对超出已知点集的插值点用指定插值方法计算函数值
    
    %% 信道校正
        data_aftereq=data3(data_station(1:end),:)./H;
    %% 并串转换
        data_aftereq=reshape(data_aftereq,[],1);
        data_aftereq=data_aftereq(1:length(spread_data));
        data_aftereq=reshape(data_aftereq,N_sc,length(data_aftereq)/N_sc);
        
    %% 解扩
        demspread_data = despread(data_aftereq,code);       % 数据解扩
        
    %% QPSK解调
        demodulation_data=pskdemod(demspread_data,M,pi/M);    
        De_data1 = reshape(demodulation_data,[],1);
        De_data2 = de2bi(De_data1);
        De_Bit = reshape(De_data2',1,[]);
    
    %% (解交织)
    %% 信道译码(维特比译码)
        trellis = poly2trellis(7,[133 171]);
        rx_c_de = vitdec(De_Bit,trellis,tblen,'trunc','hard');   %硬判决
    
    %% 计算误码率
        [err,Ber2(jj)] = biterr(De_Bit(1:length(code_data)),code_data);%译码前的误码率
        [err, Ber(jj)] = biterr(rx_c_de(1:length(P_data)),P_data);%译码后的误码率
    
    end
     figure(2);
     semilogy(SNR,Ber2,'b-s');
     hold on;
     semilogy(SNR,Ber,'r-o');
     hold on;
     legend('4PSK调制、卷积码译码前(有扩频)','4PSK调制、卷积码译码后(有扩频)');
     hold on;
     xlabel('SNR');
     ylabel('BER');
     title('AWGN信道下误比特率曲线');
    
     figure(3)
     subplot(2,1,1);
     x=0:1:30;
     stem(x,P_data(1:31));
     ylabel('amplitude');
     title('发送数据(以前30个数据为例)');
     legend('4PSK调制、卷积译码、有扩频');
    
     subplot(2,1,2);
     x=0:1:30;
     stem(x,rx_c_de(1:31));
     ylabel('amplitude');
     title('接收数据(以前30个数据为例)');
     legend('4PSK调制、卷积译码、有扩频');
    

    七、能看到这里,如果有丢丢帮助的话,emmmm点个赞~呗

    原文:

    整个过程

    本来对每一步都有讲解注释的,但是程序编辑多了感觉不美观,就删掉了。比如扩频,其原理、作用、如何实现~

    三、代码及说明

    1.尽量把每一句程序都注释,能达到初学者拿到程序就能懂的程度;

    2.下面这段程序是上变频之前的,包含了画图,对ofdm信号有一个直观的感受(与上面图片中的流程可能冲突,这里仅仅是为了画图解释,所以这也是最开始学容易绕晕的地方)

    clear;
    %% 参数设置
    sub_carriers=2048;%子载波数
    T = 1 / sub_carriers;
    time = [0:T:1-T];% Nifft份,每份相隔T
    
    Lp=4984;
    P_Tx=(rand(1,Lp)>0.5);%(bits)%产生1个长为Lp的数据包:
    conv_out=convolutional_en(P_Tx);%(卷积编码):
    interleave_table = interleav_matrix(ones(1,2*(Lp+8)));
    interleav_out = interleaving(conv_out ,interleave_table);%(交织器)
    
    x=qpsk(interleav_out);%(4QAM 调制)
    L=length(x);%信号长度
    
    s=48;
    symbol_used_len=L/s;%把输入分为S个符号,每个符号长为symbol_used_len
    %循环前缀的长度
    cp=256;
    %每一个OFDM符号的抽样值应补‘0’个数zeros_pad
    zeros_pad=sub_carriers-symbol_used_len;
    %每一个OFDM符号一侧应该补‘0’个数zeros_pad_side
    zeros_pad_side=zeros_pad/2;
    
    %对输入信号进行分割,分割为s个符号,再对每个符号进行FFT运算,实现OFDM解调,并保证能量不变
    time_domain_x_link=[];
    for I=0:(s-1)
        %对输入进行分割 
        x_temp=x(I*symbol_used_len+1:I*symbol_used_len+symbol_used_len);
        %对每个分割的部分进行补零操作,使其长为sub_carriers
        x_temp_pad=[zeros(1,zeros_pad_side),x_temp,zeros(1,zeros_pad_side)];
        %对每个符号进行IFFT运算
        time_domain_x_temp=ifft(x_temp_pad)*sqrt(sub_carriers);
        %对每个符号添加循环前缀
        time_domain_x_cp_temp=[time_domain_x_temp(sub_carriers-cp+1:sub_carriers),time_domain_x_temp];
        %将符号连接成为串行数据流
        time_domain_x_link=[time_domain_x_link,time_domain_x_cp_temp];
    
    end
    sum_xI = real(time_domain_x_link);
    sum_xQ = imag(time_domain_x_link);
    
    figure;
    num=1000;%画出前num个点  
    xaxis   = zeros(length(time(1:num)));
    plot(time(1:num), sum_xI(1:num), 'b:', time(1:num), sum_xQ(1:num), 'g:', time(1:num), abs(sum_xI(1:num)+j*sum_xQ(1:num)), 'k-', time(1:num), xaxis, 'r-');
    ylabel('y'),xlabel('t'),
    title(['前', num2str(num),'个点经ifft的QAM符号实部之和虚部之和以及实部与虚部的绝对值波形']),
    legend('实部之和','虚部之和', '绝对值');

    3.与上面图片流程相符的代码

    代码前面的问题也是我在这个过程中遇到的,困扰了好久,可以带着问题看看。欢迎讨论。

    clc;
    clear;
    
    %————————————————————————————————————————————————————————%
    %q1:fft点数难道不是应该等于子载波数吗?子载波数与ifft点数的关系?
    %q2:对矩阵进行fft?
    %q3:怎么对ofdm信号上变频
    %q4:基带速率是多少?怎么实现?
    %q5传输频带是多少?怎么实现?
    %q6子载波间隔是多少?怎么实现?
    %q7符号周期是多少?怎么实现?
    %————————————————————————————————————————————————————————%
    
    %% 参数设置
    
    N_sc=52;      %系统子载波数(不包括直流载波)、number of subcarrier
    N_fft=64;            % FFT 长度
    N_cp=16;             % 循环前缀长度、Cyclic prefix
    N_symbo=N_fft+N_cp;        % 1个完整OFDM符号长度
    N_c=53;             % 包含直流载波的总的子载波数、number of carriers
    M=4;               %4PSK调制
    SNR=0:1:25;         %仿真信噪比
    N_frm=10;            % 每种信噪比下的仿真帧数、frame
    Nd=6;               % 每帧包含的OFDM符号数
    P_f_inter=6;      %导频间隔
    data_station=[];    %导频位置
    L=7;                %卷积码约束长度
    tblen=6*L;          %Viterbi译码器回溯深度
    stage = 3;          % m序列的阶数
    ptap1 = [1 3];      % m序列的寄存器连接方式
    regi1 = [1 1 1];    % m序列的寄存器初始值
    
    
    %% 基带数据数据产生
    P_data=randi([0 1],1,N_sc*Nd*N_frm);
    
    
    %% 信道编码(卷积码、或交织器)
    %卷积码:前向纠错非线性码
    %交织:使突发错误最大限度的分散化
    trellis = poly2trellis(7,[133 171]);       %(2,1,7)卷积编码
    code_data=convenc(P_data,trellis);
    
    
    %% qpsk调制
    data_temp1= reshape(code_data,log2(M),[])';             %以每组2比特进行分组,M=4
    data_temp2= bi2de(data_temp1);                             %二进制转化为十进制
    modu_data=pskmod(data_temp2,M,pi/M);              % 4PSK调制
    % figure(1);
    scatterplot(modu_data),grid;                  %星座图(也可以取实部用plot函数)
    
    %% 扩频
    %————————————————————————————————————————————————————————%
    %扩频通信信号所占有的频带宽度远大于所传信息必需的最小带宽
    %根据香农定理,扩频通信就是用宽带传输技术来换取信噪比上的好处,这就是扩频通信的基本思想和理论依据。
    %扩频就是将一系列正交的码字与基带调制信号内积
    %扩频后数字频率变成了原来的m倍。码片数量 = 2(符号数)* m(扩频系数)
    %————————————————————————————————————————————————————————%
    
    code = mseq(stage,ptap1,regi1,N_sc);     % 扩频码的生成
    code = code * 2 - 1;         %将1、0变换为1、-1
    modu_data=reshape(modu_data,N_sc,length(modu_data)/N_sc);
    spread_data = spread(modu_data,code);        % 扩频
    spread_data=reshape(spread_data,[],1);
    
    %% 插入导频
    P_f=3+3*1i;                       %Pilot frequency
    P_f_station=[1:P_f_inter:N_fft];%导频位置(导频位置很重要,why?)
    pilot_num=length(P_f_station);%导频数量
    
    for img=1:N_fft                        %数据位置
        if mod(img,P_f_inter)~=1          %mod(a,b)就是求的是a除以b的余数
            data_station=[data_station,img];
        end
    end
    data_row=length(data_station);
    data_col=ceil(length(spread_data)/data_row);
    
    pilot_seq=ones(pilot_num,data_col)*P_f;%将导频放入矩阵
    data=zeros(N_fft,data_col);%预设整个矩阵
    data(P_f_station(1:end),:)=pilot_seq;%对pilot_seq按行取
    
    if data_row*data_col>length(spread_data)
        data2=[spread_data;zeros(data_row*data_col-length(spread_data),1)];%将数据矩阵补齐,补0是虚载频~
    end;
    
    %% 串并转换
    data_seq=reshape(data2,data_row,data_col);
    data(data_station(1:end),:)=data_seq;%将导频与数据合并
    
    %% IFFT
    ifft_data=ifft(data); 
    
    %% 插入保护间隔、循环前缀
    Tx_cd=[ifft_data(N_fft-N_cp+1:end,:);ifft_data];%把ifft的末尾N_cp个数补充到最前面
    
    %% 并串转换
    Tx_data=reshape(Tx_cd,[],1);%由于传输需要
    
    %% 信道(通过多经瑞利信道、或信号经过AWGN信道)
     Ber=zeros(1,length(SNR));
     Ber2=zeros(1,length(SNR));
    for jj=1:length(SNR)
        rx_channel=awgn(Tx_data,SNR(jj),'measured');%添加高斯白噪声
        
    %% 串并转换
        Rx_data1=reshape(rx_channel,N_fft+N_cp,[]);
        
    %% 去掉保护间隔、循环前缀
        Rx_data2=Rx_data1(N_cp+1:end,:);
    
    %% FFT
        fft_data=fft(Rx_data2);
        
    %% 信道估计与插值(均衡)
        data3=fft_data(1:N_fft,:); 
        Rx_pilot=data3(P_f_station(1:end),:); %接收到的导频
        h=Rx_pilot./pilot_seq; 
        H=interp1( P_f_station(1:end)',h,data_station(1:end)','linear','extrap');%分段线性插值:插值点处函数值由连接其最邻近的两侧点的线性函数预测。对超出已知点集的插值点用指定插值方法计算函数值
    
    %% 信道校正
        data_aftereq=data3(data_station(1:end),:)./H;
    %% 并串转换
        data_aftereq=reshape(data_aftereq,[],1);
        data_aftereq=data_aftereq(1:length(spread_data));
        data_aftereq=reshape(data_aftereq,N_sc,length(data_aftereq)/N_sc);
        
    %% 解扩
        demspread_data = despread(data_aftereq,code);       % 数据解扩
        
    %% QPSK解调
        demodulation_data=pskdemod(demspread_data,M,pi/M);    
        De_data1 = reshape(demodulation_data,[],1);
        De_data2 = de2bi(De_data1);
        De_Bit = reshape(De_data2',1,[]);
    
    %% (解交织)
    %% 信道译码(维特比译码)
        trellis = poly2trellis(7,[133 171]);
        rx_c_de = vitdec(De_Bit,trellis,tblen,'trunc','hard');   %硬判决
    
    %% 计算误码率
        [err,Ber2(jj)] = biterr(De_Bit(1:length(code_data)),code_data);%译码前的误码率
        [err, Ber(jj)] = biterr(rx_c_de(1:length(P_data)),P_data);%译码后的误码率
    
    end
     figure(2);
     semilogy(SNR,Ber2,'b-s');
     hold on;
     semilogy(SNR,Ber,'r-o');
     hold on;
     legend('4PSK调制、卷积码译码前(有扩频)','4PSK调制、卷积码译码后(有扩频)');
     hold on;
     xlabel('SNR');
     ylabel('BER');
     title('AWGN信道下误比特率曲线');
    
     figure(3)
     subplot(2,1,1);
     x=0:1:30;
     stem(x,P_data(1:31));
     ylabel('amplitude');
     title('发送数据(以前30个数据为例)');
     legend('4PSK调制、卷积译码、有扩频');
    
     subplot(2,1,2);
     x=0:1:30;
     stem(x,rx_c_de(1:31));
     ylabel('amplitude');
     title('接收数据(以前30个数据为例)');
     legend('4PSK调制、卷积译码、有扩频');

    4.上面就是整个基带传输过程,其实上变频和下变频也很简单,将信号分为IQ路,分别乘cos和-sin即可,关于这一步,可以参考我另一篇8PSK调制的文章,在那篇文章里有相似的原理。链接:https://blog.csdn.net/qq_41687938/article/details/89514982和贼详细的8PSK调制与解调详细过程 - 子木的文章 - 知乎 https://zhuanlan.zhihu.com/p/47258287

    5.本来打算解释解释原理的,但是想着网上资料很多,就不献丑了,想打王者了~

    展开全文
  • C语言

    万次阅读 多人点赞 2019-12-18 23:01:50
    C语言 42.C语言是一种计算机高级语言。 43.C语言允许直接访问物理地址,能进行位操作。 44.C语言是结构化程序设计语言 45.c程序要通过编译,连接...50.C语言的每语句的最后必须有一分号 51.C语言本身没有输入...
  • Python语言中的缩进在程序中长度统一且强制使用,只要统一即可,不一定是4空格(尽管这是惯例) IPO模型指:Input Process Output 字符串的正向递增和反向递减序号体系:正向是从左到右,0到n-1,反向是从右到左...
  • 测试开发笔记

    万次阅读 多人点赞 2019-11-14 17:11:58
    测试开发笔记 第一章 测试基础 7 什么是软件测试: 7 ...验收测试:(在系统测试之后) 11 回归测试: 11 4.测试过程(干什么,怎么干) 12 5.各阶段输入、输出标准以及入口、出口准则:(测试阶段过程要素) 1...
  • 软件测试_笔记(完整版)

    万次阅读 多人点赞 2018-07-02 08:51:28
    广义的软件测试定义:人工或自动地运行或测定某系统的过程,目的在于检验它是否满足规定的需求或弄清预期结果和实际结果间的差别 为什么要做软件测试 发现软件缺陷 功能错 功能遗漏 超出需求部分(画蛇添足) ...
  • 什么是MIMO-OFDM技术

    千次阅读 2019-04-08 12:55:47
    通过这两种技术的优势互补,可以为系统提供高传输速率,同时也能提高系统容量,降低成本。文中详细介绍了这两种技术及信道估计。 图1. 采用MIMO-OFDM技术的新标准。 一、引言 目前没有第四代移动通信的确切...
  • Linux实用教程(第版)

    万次阅读 多人点赞 2019-08-27 22:55:59
    1.2 Linux系统的特点和组成 1.3 Linux版本介绍 1.4 Red Hat Linux系统概述 1.1 Linux系统简介 1.1.1 什么是Linux 1.1.2 Linux系统的产生 1.1.3 Linux系统应用领域 1.1.1什么是Linux     ...
  • 计算机组成原理复习笔记-2

    千次阅读 多人点赞 2018-05-27 10:37:04
    此原理说明,可以用不同的选择来实现相同的计算机功能如对于微波炉的控制系统,一简单的嵌入式系统会比一复杂的计算机程序性能好的多。计算机体系结构:硬件系统 + 指令集体系结构(ISA)ISA: 在机器上运...
  • 史上最全面Java面试汇总(面试题+答案)

    万次阅读 多人点赞 2018-07-06 14:09:25
    JAVA面试精选【Java基础第部分】 JAVA面试精选【Java算法与编程一】 JAVA面试精选【Java算法与编程二】 Java高级工程师—面试(1) Java高级工程师—面试(2) Java高级工程师—面试(3) BAT/网易等面试心得 ...
  • 计算机系统概述 计算机发展历程 计算机硬件的发展 世界上第一台电子数字计算机【ENIAC】 计算机的四代变化 电子管时代 晶体管时代 中小规模集成电路时代 超大规模集成电路时代 计算机元件的更新换代 计算机...
  • 假设一个由三个神经元组成的离散Hopfield神经网络,其结构如下: 上图中,第0层仅仅是作为网络的输入,它不是实际神经元,所以无计算功能;第一层是神经元,故而执行对输入信息和权系数乘积求累加和,并经非...
  • 软件测试入门知识了解

    万次阅读 多人点赞 2018-09-05 14:59:58
    需求评审和设计评审是验证软件产品的需求定义和设计实现,验证所定义的产品特性是否符合客户的期望、系统的设计是否合理、是否具有可测试性以及满足非功能质量特性的要求。这阶段主要通过对需求文档、设计文档等...
  • Python实验实例

    万次阅读 多人点赞 2019-06-27 19:28:05
    Python 运算符、内置函数 ... 2、编写程序,输入两集合 setA 和 setB,分别输出它们的交集、并集和差集 setA-setB。  3、编写程序,输入一自然数,输出它的二进制、八进制、十六进制表示形式。 num ...
  • 数据在计算机系统内加工、存取和传送的过程中可能会产生错误。为了减少和避免这类错误,引入了数据校验码。数据校验码是一种常用的带有发现某些错误,甚至带有一定自动改错能力的数据编码方法。 例子: 码距:两...
  • 《计算机组成原理》— 指令系统

    万次阅读 多人点赞 2017-05-29 10:54:45
    基本知识点:指令系统和指令的基本概念,指令格式,指令操作码扩展技术,各种寻址方式及其特点,RISC 和 CISC 指令系统的特点。 重 点:指令格式,指令操作码扩展技术,各种寻址方式及其特点。 难 点:指令格式,...
  • 《计算机系统概论》-第1章-习题答案

    千次阅读 多人点赞 2019-06-12 22:07:37
    试解释1.5节中两重要思想中的第一。 所有计算机的模型都是一样的,只要输入是一样的,输出结果也是一样的。 试问,同汇编语言相比,高级语言是否能向底层计算机表述更多的计算方式? 不能。因为高级语言...
  • 流程图

    千次阅读 2018-09-12 17:59:11
    流程图一般圆角矩形、矩形、菱形、平行四边形、箭头组成。 二、流程图图形的作用 流程图一般是圆角矩形来表示开始与结束,用矩形表示行动方案,普通工作环节使用,菱形表示问题判断或判定环节,平行四边形...
  • 嵌入式系统三级考试终结版2019.3

    万次阅读 2019-03-28 15:25:59
    嵌入式系统上的软件具有结构精简,代码轻量化,占用存储资源少的特点。...按照软硬件技术的复杂程度进行分类,可以把嵌入式系统分为:高端系统、终端系统和低端系统三大类。 仿真平台指嵌入式系统开发中使用的虚拟...
  • Python循环产生批量数据batch

    万次阅读 2018-10-28 11:49:33
    Python循环产生批量数据batch 目录 Python循环产生批量数据batch 一、Python循环产生批量数据batch 二、TensorFlow循环产生批量数据batch (1)tf.train.slice_input_producer (2)tf.train.batch和tf.train....
  • 基于PLC的自动配料控制系统设计,PLC自动控制专业论文 原文地址:/www.deogoo.com/n127.html 购买原文联系vfbvfb#163.com [#=@] The Design of Automatic Batching Control System Based on PLC 系(院)...
  • 设计一彩灯循环控制器

    万次阅读 多人点赞 2017-06-30 22:36:35
    设计一彩灯循环控制器二、课程设计的要求与数据 设计要求包括: 1.10路彩灯分别用10发光二极管L0、L1…..L9模拟,发光二极管L0、L1…..L9从左到右排列。 2.要求显示四种不同的花型:1)10路彩灯按照L0、L1…....
  • 以前,搞无人机的十个人有八是航空、气动、机械出身,更多考虑的是如何让飞机稳定飞起来、飞得更快、飞得更高。如今,随着芯片、人工智能、大数据技术的发展,无人机开始了智能化、终端化、集群化的趋势,大批自动...
  • 背景 比较经典的光学维测量方法有:双目立体视觉、线激光扫描、格雷码结构光、相移结构光。立体匹配方法误匹配点...本文介绍的是一种基于格雷码结构光和双目立体视觉的维测量系统,该测量系统可以避免传统单相...
  • 计算机组成原理(哈工大)学习笔记

    万次阅读 多人点赞 2020-07-08 08:10:46
    文章目录计算机组成原理一、计算机系统概论1.1计算机系统简介一、计算机的软硬件概念二、计算机系统的层次结构、计算机体系结构和计算机组成1.2计算机的基本组成1.3计算机硬件的主要技术指标一、机器字长二、运算...
  • 计算机组成原理实验总结

    千次阅读 2019-05-27 14:23:43
    2.学习和了解 TEC-XP16 教学实验系统的指令系统; 3.学习简单的 TEC-XP16 教学实验系统汇编程序设计; 实验内容: 1.学习联机使用 TEC-XP16 教学实验系统和仿真终端软件 PCEC. 2.学习使用 WINDOWS 界面的串口...
  • 深度学习常见算法的介绍和比较

    万次阅读 多人点赞 2018-02-08 22:00:06
    其实深度学习是机器学习的一分支。可以理解为具有多层结构的模型。具体的话,深度学习是机器学习中的具有深层结构的神经网络算法,即机器学习>神经网络算法>深度神经网络(深度学习)。 关于深度学习的理论推导,...
  • 计算机组成原理之MIPS指令系统和MIPS体系结构

    万次阅读 多人点赞 2016-06-13 13:17:34
    (3)熟悉MIPS指令系统及其特点,加深对MIPS指令操作语义的理解 (4)熟悉MIPS体系结构 模拟器360云盘分享https://yunpan.cn/cRLzwTkYc3TEt 访问密码 f9a6 二. 实验内容和步骤 首先要阅读MIPSsim模拟器的使用...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 246,335
精华内容 98,534
关键字:

循环系统由三个组成