java二级笔记
文章目录
- java二级笔记
- 一、 二叉树的遍历
- 二、 排序方式
- 三、 队列
- 四、 java容器
- 五、 java运算和体系结构
- 六、文件I/O
- 七、考查类、函数和java基础知识
- 八、软件工程基础
- 九、数据库基础
- 十、简单应用
- 1、考查do-while语句
- 2、考查Applet的编写
- 3、考查数组
- 4、考查线程的创建
- 5、考查线程的生命周期与线程控制
- 6、考查输入与输出
- 7、考查异常处理
- 8、考查文件和递归调用
- 9、考查方法参数的传递和对象的实例化
- 10、考查构造方法的重载
- 11、考查矩阵的计算
- 12、考查对文件读、写对象数
- 13、考查输出流
- 14、考查图形用户界面
- 15、考查JavaSwing
- 16、考查构造方法的重载
- 17、考查对Comparable的理解
- 18、考查对Java基本类型
- 19、考查继承
- 20、考查对主函数参数的理解
- 21、考查JavaSwing
- 22、考查对Java语言基本语法以及函数等基本要素的掌握情况
- 23、考查对类的使用的理解
- 23、考查对题目要求的理解
- 24、考查对Java语言类定义以及继承类的掌握
- 考查考生对Java语言线程的掌握
- 考查对Java语言线程的掌握
- 考查对Java语言线程的掌握
- 考查io流
- 考查类的实例化
- 考查对Java语言类的基本使用以及线程基本要
- 考查对Java语言线程和类的基本用法的
- 考查对Java语言堆栈和类的基本用法的掌握
- 考查对类的继承的掌握
- 基本操作
一、 二叉树的遍历
前序遍历（根左右）
中序遍历（左根右）
后续遍历（左右根）
二、 排序方式
1.冒泡排序
- 通过相邻数据元素的交换逐步将线性表变成有序
最坏情况下，需要比较次数为 n(n-1)/2 次，时间复杂度为 O(n²）
2.快速排序
- 快速排序法也是一种互换类的排序方法，但由于它比冒泡排序法的速度快，因此称之为快速排序。快速排序法的基本思想是:从线性表中选取一个元素，设为T，将线性表后面小于T的元素移到前面，而前面大于T的元素移到后面，结果就将线性表分成了两部分（称为两个子表），T插入到其分界线的位置处，这个过程称为线性表的分割。如果对分割后的各子表再按上述原则进行分割，并且，这种分割过程可以一直做下去，直到所有子表为空为止，则此时的线性表就变成了有序表。
快速排序是所有同量级O(nlogn)的排序方法中，平均性能最好的排序方式。但是若快速排序的初始记录序列按关键字有序或基本有序，最坏情况下，需要比较次数为 n(n-1)/2 次，时间复杂度为 O(n²）
3.简单排序
- 将无序列表中的各元素依次插入到已经有序的线性表中
最坏情况下，需要比较次数为 n(n-1)/2 次
4.希尔排序
- 将整个无序序列分割成若干个小的子序列分别进行插入排序
最坏情况下，需要比较次数为 O(n的1.5次方）
5.堆排序
最坏情况下，时间复杂度为 O(nlog2的n次方）
6. 查找的时间复杂度比较
- 最坏情况下，二分法查找，的时间复杂度为 O(log2的n次方）→最低
最坏情况下，（顺序查找）有序链表查找，的时间复杂度为 O(n）→较高
最坏情况下，（查找最大项）循环链表查找，的时间复杂度为 O(n-1）→较低
最坏情况下，堆排序的时间复杂度为0(nlog2的n次方)。→最高
三、 队列
例题：
- 分析案例
设循环队列为Q(1:m),其初始状态为front=rear =m.经过一系列入队与退队运算后,front=20,rear=15.
点击跳转查看解析
155、某循环队列的荐储空间为Q(1:m)，初始状态为front=rear=m。现经过一系列的入队操作和退队操作后，front=m-1, rear=m，则该循环队列中的元素个数为？
解：在循环队列中，用队尾指针rear指向队列中的队尾元素，用队头指针front指向队头元素的前一个位置，因此从队头指针front指向的后一个位置直到队尾指针rear指向的位置之间所有的元素均为队列中的元素。（尾指针入队，头指针出队（队尾进，队头出））进来一个元素，rear加1， 出去一个元素，front加1
经过一系列的入队操作和退队操作后，头指针(front=m-1）尾指针(rear=m)说明：
入队m次，退队m-1次。所以公式m- (m-1〉得出队列中有元素1个。
177、设循环队列的存储空间为Q(1:m)，初始状态为空。现经过一系列正常的入队与退队操作后，front=m-1, rear=m，此后再向该循环队列中插入一个元素，则队列中的元素个数为？
解：经过一系列的入队操作和退队操作后，头指针(front=m-1）尾指针(rear=m)说明入队m次，退队m-1次，此时队列中有一个元素，此后再向该循环队列中插入一个元素，队列中元素个数为2。
150、设循环队列为Q(1:m)，初始状态为front=rear=m。现经一系列入队与退队操作后，front=rear=m-1，则？
答：该循环队列已空或已满
169、设栈的顺序存储空间为S(1:m)，初始状态为top=m+1。现经过一系列正常的入栈与退栈操作后，top=0，则栈中的元素个数为？
答：在栈的顺序存储空间s(1:m)中，S(bottom)通常为栈底元素，s(top)为栈顶元素。top=0表示栈空;top=m表示栈满。所以此时栈中没有元素
194、设栈的顺序存储空间为S(1:m)，初始状态为top=m+1，则栈中的数据元素个数为？
解：栈是限定在一端进行插入与删除的线性表。在栈的顺序存储空间S(1 :m)中，s(bottom)通常为栈底元素（在栈非空的情况下)，s(top)为栈顶元素。,Top=0表示栈空;top=m表示栈满。入栈运算时指在栈顶位置插入一个新元素（即top加1）退栈运算是指取出栈顶元素赋给一个指定的变量（即top减1），因此栈内元组个数为m-top+1。
224、设栈的存储空间为S(1:50)，初始状态为top=0。现经过一系列正常的入栈与退栈操作后，top=51，则栈中的元素个数为？
解：栈中的元素一共50个，所以top的最大值为50。故栈中的元素个数为不可能
228、设栈的顺序存储空间为S(1:m)，初始状态为top=m+1。现经过一系列正常的入栈与退栈运算后，top=20，则栈中的元素个数为？
解:栈存放一个元素之后， top=m+1-1=m，存两个元素之后，top=m+1-2=m-1，因此当top=20时，栈中有m+1-20=m-19个元素。
236、设循环队列的存储空间为Q(1:100)，初始状态为空。现经过一系列正常操作后，front=49，则循环队列中的元素个数为?
解：经过一系列的正常操作后，头指针front=49只能确定出队49次，不能确定入队次数，所以不能确定此时队列中元素的个数。
241、在带链栈中，经过一系列正常的操作后，如果top=bottom，则栈中的元素个数为？
解：如果top=bottom不等于NULL，则top=bottom同时指向唯一一个元素的数据域，此时栈中的元素个数为1;如果top=bottom=NULL,则栈中的元素个数为0。故：栈中的元素个数为0或1
263、设栈的顺序存储空间为S(1:m)，初始状态为top=-1,则栈中的数据元素个数为？
解：这是一个正向压的栈，初始情况，即0个元素时: top=-1; 压入1个元素时: top=-1+1=0; 压入2个元素时: top=-1+2=1; 压入3个元素时:top=- 1+3=2;所以压入的元素的个数=top+1。
284、设循环队列的存储空间为Q(1: m),初始状态为front rear=m。经过一系列正常的操作后，front=1, rear=m。 为了在该队列中寻找值最大的元素，在最坏情况下需要的比较次数为？
解：经过一系列的入队操作和退队操作后front=1，rear=m，计算(rear- front+m) %m= (2m- 1)%m，所以此循环队列的元素个数为:m-1。所以最坏比较次数为m-2次。
290、循环队列的存储空间为Q(0:59)，初始状态为空。经过一系列正常的入队与退队操作后，front 25，rear=24。 循环队列中的元素个数为?
解;循环队列是将队列存储空间的最后一个位置绕到第一个位置， 形成逻辑上的环状空间，供队列循环使用。经过- - 系列的入队操作和退队操作后，头指针(front=25) 尾指针(rear=24)说明入队24次，退队25次，已经形成了循环效果。
循环队列的存储空间为Q(0:59)，可以存放60个元素，所以公式60+24-25得出队列中有元素59个。
306、设栈的存储空间为S(1:60)，初始状态为top=61。现经过系列正常的入栈与退栈操作后，top=25， 则栈中的元素个数为?
解：也就是说，栈是向上增长的，每次压入一一个元素，栈的TOP指针向.上移动一位。
当压入第一个元素时，TOP指针指向61-1 = 60
当压入第二个元素时，TOP指针指向61-2 = 59
以此类推，当压入第N个元素时，TOP指针指向61-N， 则N = 61-25
= 36。
310、某带链栈的初始状态为top=bottom=NULL,经过一系列正常的入栈与退栈操作后，top=bottom=20。 该栈中的元素个数为?
解：栈顶指针top动态反映了栈中元素的变化情况，栈元素入栈时在栈项插入一个新元素，top指向新结点的数据域，元素退栈时取出栈顶元素并赋给一个指定的变量，top指向此时的第1个结点的数据域。经过一系列正常的操作后，如果top=bottom不 等于NULL，则top=bottom同时指向唯一 一个元素的数据域，此时栈中的元素个数为1;如果top=bottom=NULL,则栈中的元素个数为0。
四、 java容器
- Frame（窗口容器）
- Dialog（对话框容器）
- Panel（面板容器）默认布局管理器FlowLayout
- Applet（java小程序的容器）默认布局管理器FlowLayout
构件和容器
- 按钮是一个常用构件，Swing的按钮（JButton）和标签可显示图标和文本
Swing构件不能直接添加到顶层容器中，它必须添加到一个与Swing顶层容器相关联的内容面板上。 - AWT的按钮（Button）和标签只能显示文本。
AWT直接添加到顶层容器中
JApplet的内容面板的默认布局管理器是BorderLayout;
而Applet的默认布局管理器是FlowLayout。
AWT与Swing的比较
- .单行文本输入区(TextField）是AWT构件库中的基本构件之一
ActionListener、FocusListener、MouseMotionListener都属于AWT事件监听器 - ChangeListener属于Swing事件监听器。
ChangeListener事件监听器可以处理的事件源有AbstractButton、DefaultCaret、JProgessBar、JSlider、JTabbedPane、JViewport。 - Swing继续沿用AWT中的布局管理器，包括FlowLayout、
BorderLayout、CardLayout、GridLayout、GridBagLayout，另外Swing新增加了一个BoxLayout布局管理器。
Swing简介：
Swing包提供了图形化界面的构件：
- JTabledPane提供一组可供用户选择的带有标签或图标的选项，每个选项下面都可以显示一个构件;
- JLayeredPane是分层面板;
- JScrollPane是带滚动条的面板;
- JSplitPane是分隔板，用于分隔两个构件。
Applet（java小程序的容器）
Applet执行过程。
Applet的生命周期中各方法的调用次序为: init()、start()、stop()、destroy()(其中start()和stop()可重复执行）。
- Applet是能够嵌入HTML语言中，并能够在浏览器中运行的类。Applet的运行环境是Web浏览器，所以必须建立Html文件，告诉浏览器如何加载与运行Applet。因此Applet是不能直接通过Java命令行启动运行的。
Applet的安全机制
Applet的安全限制:
- Applet不能运行任何本地可运行程序;
- 禁止加载本地库或方法。Applet只能使用自身的代码或Applet浏览器提供的Java API;
- 禁止读、写本地计算机的文件系统;
- 禁止向提供Applet之外的任何主机建立网络连接;
- 不能读取某些系统信息;
- 由一个Applet弹出的窗口外观上与一个Application弹出的窗口不同，Applet弹出的窗口中将会有警告提示信息，以帮助用户区分Applet窗口与可信的Application窗口。
Applet与工作环境的通信
通过AppletContext的showDocument()方法，Applet可以通知浏览器在哪个窗口中显示哪个URL中的文件。
Applet的图形绘制
Applet是工作在图形方式下的，向Applet中绘图、显示字符串，都要用paint()方法。
- paint()方法具体执行Applet的绘制功能。
- init()方法实现设置布局管理器、数据初始化、放置一些构件等功能，该方法在Applet运行时首先由浏览器调用，使Applet执行一些基本初始化。
- start()方法使Applet成为激活状态，该方法在Applet每次显示时都要调用。*
- paintComponent()方法位于JComponent类，该方法与paint()方法类似，但通常在Swing中使用其绘图。
Applet事件处理
Applet事件处理机制与Java Application相同，采用监听器方式，JApplet也是采用监听器方式。
Applet的使用
将Applet嵌入在htm1文件中，必须使用特殊的htm1标记<Applet>，实现Applet的运行。该标记中必须定义CODE、WIDTH和HEIGHT三个属性。
- CODE属性指定包含Applet字节码的文件名;
WIDTH和HEIGHT属性定义了Applet显示区以像素为单位i的高度和宽度。
线程与进程
- 进程是由代码、数据、内核状态和一组寄存器组成。
- 线程是由表示程序运行状态的寄存器，如程序计数器、栈指针以及堆栈组成。
线程的概念
线程与进程在概念上是相关的：
-
线程不包含进程地址空间中的代码和数据。多个线程之间可共享数据，例如:当两个线程访问同一对象时，将共享数据。
-
一个进程可以包含多个线程，在多任务操作系统中，通过运行多个进程来并发地执行多个任务。而在操作系统中引入线程的概念后，由于每个线程都是一个能独立执行自身指令的不同控制流，因此一个包含多线程的进程也能够实现多项任务的并发执行。
线程创建有两种方法:
- 1、通过实现Runnable接口创建线程;
- 2、通过继承Thread类创建线程。
当多个线程并发执行时，虽然各个线程中语句的执行顺序是确定的，但线程的相对执行顺序是不确定的，在有些情况下，如多线程对共享数据操作时，这种线程运行顺序的不确定性将会产生执行结果的不确定性，使共享数据的一致性被破坏，因此在某些应用程序中必须对线程的并发操作进行控制。
Java中的线程体是由线程类的run()方法定义，在该方法中定义线程的具体行为。
线程的调度与控制
- sleep():该方法使一个线程暂停运行一段固定的时间，在其休眠时间内，让优先级比其低的线程运行;
- yield():该方法使具有与当前线程相同优先级的线程有运行的机会;
- interrupt():如果一个线程在调用sleep()，join()， wait()等方法被阻塞时，则interrupt()方法将中断其阻塞状态，并且该线程将接收到InterruptException异常;
- start():新建的线程不会自动运行，必须调用该方法。调用该方法把嵌入在线程中的虚拟CPU置为可运行状态意味着它可以被调度，但并不意味着该线程会立刻执行。
接口
- 处理对象传输的接口是：Serializable
JDK工具。
- javac.exe: Java编译器，能将源代码编译成字节码，以.class扩展名存入java工作目录中。
javadoc.exe: Java文档生成器，对Java源文件和包以MML格式产生AP
javaprof.exe: Java剖析工具，提供解释器剖析信息。
javap.exe: Java类分解器，对.class文件提供字节代码反汇编，并打印。 - -D:定义属性名;
-debug:将程序连接到调试器;
-verbosegc:无用单元收集器每释放一次内存，打印一条信息;
-mx:分配最大内存值。
J2SDK的操作命令。
- Javah，生成C头文件和Stub文件;
Javap，Java类文件解析器，用于解析类文件;
Jar，Java类文件归档命令，可将多个文件合并为单个JAR归档文件;
Java，Java语言的解释器，解释运行Java字节码。
五、 java运算和体系结构
运算
体系结构
JDK目录结构：
- bin目录下有编译器、解释器和许多工具（如服务器工具、IDL、 package工具和jdb等）;
- demo目录下有各种演示例子;include目录下是Win32子目录，都是本地方法文件;
- lib目录下都是库文件;
- jre目录是Java程序运行环境的根目录，它下面有bin子目录，包括平台所用工具和库的可执行文件和DLL文件。
六、文件I/O
- FileInputStream可对一个磁盘文件涉及的数据进行处理。处理二进制数据不可以使用BufferedReader，否则提取的数据将不会保持原样。
- Java对I/o访问所提供的同步处理机制是过滤流。
七、考查类、函数和java基础知识
System类
- System类是一个final类，它不能被继承。
- 同时它又是一个抽象类，所以也是一个不能被实例化的类。
- 它主要提供标准输入输出、错误输出流、对外部定义的属性及环境变量的访问、加载文件和库的方法、还有快速复制数组的一部分的实用方法。
concat函数
字符串连接函数concat(String str)的作用是：将当前字符串对象与指定str字符串相连;
运算符
运算符表示各种不同运算的符号。按运算符的功能分，可以分为:
(1）算术运算符:+，-，*，/，%，++，- -
(2）关系运算符:>，<，>=，<=，==，!=
(3）布尔逻辑运算符:!，&&，||
(4）位运算符:>>，<<，>>>，&，|，，
(5）赋值运算符=，及其扩展赋值运算符
(6）条件运算符?:
(7）其他:包括分量运算符 ·，下标运算符[ ]，实例运算符
instanceof，内存分配运算符new，强制类型转换运算符(类型)，方法调用运算符()等。
位运算符:
>>:按位右移，高位扩展，即算术右移;
<<:按位左移;
>>>:添零右移,即逻辑右移;
&:按位与;
|:按位或;
^:按位异或;
~:按位取反。
java流程控制中的跳转语句
在java中，执行跳转功能的语句有: break语句、continue语句、return语句:
- continue语句的功能是跳过循环体中下面尚未执行的语句，回到循环体的开始，继续下一轮的循环。
事件适配器。
Java语言为一些Listener接口提供适配器(Adapter）类。可以通过继承事件所对应的Adapter类，重写需要的方法，无关方法不用实现。
事件适配器–EventAdapter。
java.awt.event包中定义的事件适配器包括以下几个:
- ComponentAdapter:构件适配器
ContainerAdapter:容器适配器
FocusAdapter:焦点适配器
KeyAdapter:键盘适配器
MouseAdapter:鼠标适配器
MouseMotionAdapter:鼠标运动适配器
WindowAdapter:窗口适配器
字节流抽象类
Java中处理字节流的抽象类有InputStream和OutputStream。
其中字节输入流都是抽象类InputStream的子类。
- ByteArrayInputStream以字节数组为输入流，它只能用于从内存中读取字节流。
ByteArrayOutputStream字节数组输出流。这个类将一个字节数组作为输出流，而任何*内存块都可以以字节数组的形式使用，故利用该类可以对内存进行写入操作。 - FileInputStream可对一个磁盘文件涉及的数据进行处理。
FileOutputStream用于对磁盘文件涉及的数据流进行输出处理，即向一个文件对象中写入数据。 - PipedInputStream是实现线程之间通信的一个类。
- FilterInputStream过滤器输入流本身也是一个抽象类。
- SequenceInputStream将多个输入流首尾连接，得到一个新的输入流。
- ObjectInputStream类实现了0bjectInput接口，对象在传输前，要首先实现Serializable接口。
对象的串行化
一个类只有实现了Serializable接口，它的对象才是可串行化的。
八、软件工程基础
软件测试的目的：发现程序中的错误
软件调试的目的：改正错误
软件是指：程序、数据和相关文档的集合
数据流图带箭头的线段表示：数据流
程序流程图（PFD）带箭头的线段表示：控制流
需求分析阶段产生的主要文档是：软件需求规格说明书
软件设计工具
软件过程设计工具包括:（1）图形工具：程序流程图、N-S图、PAD图、HIPO图（2）表格工具：判定表（3）语言工具：PDL(伪码）。
结构化分析工具
结构化分析的常用工具:
- 数据流图(DFD) 是需求分析阶段常用的（描述数据处理过程的）工具，是需求理解的逻辑模型的图形表示，直接支持系统的功能建模
- 数据字典(DD)
- 判定树
- 判定表
结构化程序设计方法
（1）逐步求精：对复杂的问题，应设计一些子目标作过渡，逐步细化
（2）自顶向下：程序设计时应先考虑总体，后考虑细节;先考虑全局目标，后考虑局部目标。不要一开始就过多追求众多的细节，先从最上层总目标开始设计，逐步使问题具体化
（3）模块化：一个复杂问题，肯定是由若干稍简单的问题构成。模块化是把程序要解决的总目标分解为分目标，再进一步分解为具体的小目标，把每个小目标称为一个模块，而可复用是面向对象程序设计的一个优点。
软件生命周期。
- 软件生命周期可以分成项目可行性研究与规划、软件需求分析、软件设计、软件实现、软件测试、软件运行与维护阶段。
其中，软件设计是系统设计人员和程序设计人员应该在反复理解软件需求的基础上，给
出软件的结构、模块的划分、功能的分配以及处理流程。在系统比较复杂的情况下，设计阶段可分解成概要设计阶段和详细设计阶段。编写概要设计说明书、详细设计说明书和测试设计初稿，提交评审。
- . 简单来说：软件生命周期可以分成定义阶段、开发阶段和维护阶段
- 软件开发阶段一般包括五个任务: 问题的定义和规划，需求分析，软件设计，程序编码，软件测试。
- 软件定义阶段：可行性研究和软件开发计划
- 软件维护阶段：软件运行
软件需求分析阶段
软件的需求分析阶段的工作，概括为四个方面:需求获取、需求分析、编写需求规格说明书和需求评审。
- 需求获取：的目的是确定对目标系统的各方面需求。涉及到的主要任务是建立获取用户需求的方法框架，并支持和监控需求获取的过程。
- 需求分析：是对获取的需求进行分析和综合，最终给出系统的解决方案和目标系统的逻辑模型。
- 编写需求规格说明书：作为需求分析的阶段成果，可以为用户、分析人员和设计人员之间的交流提供方便，可以直接支持目标软件系统的确认，又可以作为控制软件开发进程的依据。
- 需求评审：是对需求分析阶段的工作进行复审，验证需求文档的一致性、可行性、完整性和有效性。
软件设计阶段
软件设计阶段任务:设计软件系统结构、数据结构及数据库设计、编写概要设计文档、概要设计文档评审。
软件规格说明书
软件需求规格说明书的作用:
- 便于用户和开发人员进行理解和交流。
- 反映出用户问题的结构，可以作为软件开发工作的基础和依据。
- 作为确认测试和验收的依据。
软件测试
软件测试过程一般按4个步骤进行，即单元测试、集成测试、验收测试(确认测试)和系统测试。
黑盒测试
黑盒测试方法主要有:等价类划分法、边界值分析法、错误推测法、因果图等，主要用于软件确认测试。
软件集成测试
集成测试将模块组装成程序通常采用两种方式:非增量方式组装和增量方式组装。
集成测试依据的是概要设计说明书
- 非增量方式也称为一 次性组装方式。将测试号的每一个软件单元一
次组装在一起再进行整体测试。 - 增量方式包括自顶向 下、自底向上、自顶向下和自底向上相结合的混合增量方法。
单元测试
单元测试主要针对模块的下列5个基本特性进行:
- 模块的接口测试
- 局部数据结构测试
- 重要的执行路径的检查
- 出错处理测试
- 影响以上各点及其他相关点的边界条件测试。
软件工程的三要素
软件工程的三要素是：方法、工具和过程
计算机软件包括：程序、数据及相关文档
软件特点
软件的特点:
- 软件是一种逻辑实体，具有抽象性。
- 软件的生产与硬件不同，它没有明显的制作过程。
- 软件在使用中不存在磨损、老化问题。
- 软件的开发、运行对计算机具有依赖性，受计算机系统的限制，
这导致了软件移植的问题。 - 软件复杂性高，成本昂贵。
- 软件开发涉及诸多的社会因素。
软件设计准则
大量的软件设计的实践证明，以下的设计准则可以借鉴为设计的指导和对软件结构图进行优化。这些准则是:
- 提高模块独立性;
- 模块规模适中;
- 深度、宽度、扇入和扇出适当;
- 使模块的作用域在该模块的控制域内;
- 应减少模块的接口和界面的复杂性;
- 设计成单入口、单出口的模块。
- 设计功能可预测的模块。
九、数据库基础
- 数据模型的三个要素是：数据结构、数据操作、数据（完整性）约束。
数据模型
数据模型的表示
- 关系模型：采用二维表来表示，简称表。
- 概念模型：可以用一种非常直观的图的形式表示。
- 网状模型：是-一个不加任何条件限制的无向图。
- 层次模型：的基本结构是树形结构。
数据模型的作用
- 逻辑数据模型：也称为数据模型，它是一种面向数据库系统的模型，.该模型着重于在数据库系统级的实现。
- 概念数据模型：是一种面向客观世界、面向用户的模型，着重于对客观世界复杂事物的结构描述及它们之间的内在联系的刻画。
- 物理数据模型：又称物理模型，它是一种面向计算机物理表示的模型，此模型给出了数据模型在计算机上物理结构的表示。
概念模型
- 用于现实世界的建模， 与具体的DBMS无关
- 关系的完整性包括：实体完整性、参照完整性、用户自定义完整性。
- 数据库系统的三级模式包括：外模式、概念模式、内模式。
三级模式
- 概念模式：
是数据库系统中全局数据逻辑结构的描述，是全体用户公共数据视图; - 外模式：
也称为子模式或用户模式。它是用户的数据视图，也就是用户所见到的数据模式，它由概念模式推导而出; - 内模式：
又称物理模式，它给出了数据库物理存储结构与物理存取方法。
数据库管理技术
数据库管理的三个阶段:人工管理、文件系统、数据库系统。
人工管理阶段：数据管理主要用于科学计算，硬件无磁盘，直接存取，软件没有操作系统。
数据库管理系统
数据库管理系统是数据库的机构，它是一种系统软件，负责数据库中的数据组织、数据操纵、数据维护、控制及保护和数据服务等。
数据库管理阶段特点:
数据的管理者：数据库管理系统。
数据面向的对象：整个应用系统。
数据的共享程度：共享性高，冗余度小。
数据的独立性：具有高度的物理独立性和逻辑独立性。
数据的结构化：整体结构化，用数据模型描述。
数据控制能力：由数据库管理系统提供数据安全性、完整性、并发控制和恢复能力。.
数据库模式
- 外模式是用户级，即用户模式，它是某个或某几个用户所看到的数据库的数据视图，是与某一应用有关的数据的逻辑表示。
- 内模式是物理级，它是数据库中全体数据的内部表示或底层描述，是数据库最低一级
的逻辑描述，它描述了数据在存储介质上的存储方式和物理结构，对应着实际存储在外存储介质上的数据库。 - 模式是一个概念，是一个全局的逻辑结构。
数据库三级模式体系结构的划分有效地组织、管理数据，提高了数据库的逻辑独立性和物理独立性。
关系模式
E-R模型是长期以来被广泛使用的概念模型，是概念设计阶段所输出的图形表示。
数据库的逻辑设计主要工作是将E-R图转换成指定RDBMS中的关系模式。所以关系模式设计属于逻辑设计阶段。
关系数据库规范化
关系数据库规范化的目的是为了解决关系数据库中的插入、删除异常及数据冗余问题。
数据库基本特点
数据不一致性是指数据的矛盾性、不相容性。
产生数据不一致的原因主要有以下三种：
- 是由于数据冗余造成的;
- 是由于并发控制不当造成的;
- 是由于各种故障、错误造成的。.
根本原因:数据冗余。
十、简单应用
1、考查do-while语句
- 考题：
该程序的功能是:产生一-个0到20之间的随机整数，然后计算并打印它的阶乘。提示: 一个正整数n的阶乘等于所有1到n的乘积，即n!=1 * 2 * 3 * … * n.。
解析：
- 由于n!=1 * 2 * 3 * … * n.所以可用循环来求得阶乘的结果。
在本题已出现do,故用do-while循环，又因为本题在定义变量时用f来保存阶乘的结果，k表示循环变量。故本题所填循环体为: f=f*k和判断条件为: while (n>=k)。
import java. util. Random;
public class Java_ 2
public static void main(String args[]) {
Random random = new Random ()
float x = random. nextFloat();//产生0. 0与1.0之间的一个符点数
int n = Math. round (20*x); //构造20以内的一个整数
long f = 1; //保存阶乘的结果
int k =1; //循环变量
//*********F ound********
do {f*=k; （1、计算阶层结果）
k++ ;
//********Foun********
} while(k<=n) ; （2、条件判断）
System. out. println(n+"!= "+f);
}
}
2、考查Applet的编写
import java.awt.*;
import java.applet.*;
//*********Found********
public class Java_2 extends Applet （1、继承Applet）
{
//定义组件
TextArea outputArea;
//实例化
public void init()
{
//设置布局方式
setLayout(new BorderLayout());
outputArea = new TextArea();
//*********Found********
add( outputArea ); （2、将组件添加到布局中）
// 计算0至10的阶乘
for ( long i = 0; i <= 10; i++ )
//*********Found********
outputArea.append(i + "! = " + factorial(i) + "\n" ); （3、函数调用）
}
// 用递归定义阶乘方法
public long factorial( long number )
{
if ( number <= 1 ) // 基本情况
return 1;
else
//*********Found********
return number * factorial( number - 1 ); （4、计算阶乘）
}
}
3、考查数组
- 题目：
该程序的功能是:创建一个二维整型数组，并将其以4行5列对齐的格式输出。程序运行结果如下:
1 1 1 1 1
2 2 2 2 2
3 3 3 3 3
4 4 4 4 4
解析：
本题首先要理解二二维数组的定义，例如int[][]aMatrix = {{1,1,1,1,1}, {2,2,2, 2,2}, {3,3, 3, 3, 3},{4, 4, 4, 4, 4}} ;表示该二维数组由4个一-维数组aMatrix[0]、 aMatrix[1]、 aMatrix[2]、 aMatrix[3]组成， 每个一维数组都有5个元素。
- 获得行数:数组名. length;
获得列数:数组名[行标]. length
public class Java_2
{
public static void main(String[] args) {
int[][] aMatrix = {{1,1,1,1,1},{2,2,2,2,2},{3,3,3,3,3},{4,4,4,4,4}};
int i = 0; //循环变量
int j = 0; //循环变量
//print matrix
for (i = 0; i < aMatrix.length; i++) {
//*********Found********
for ( j = 0;j<5 ; j++) { （1、内层循环）
//*********Found********
System.out.print(aMatrix[i][j]+ " "); （2、输出）
}
System.out.println();
}
}
}
考查数组
- 构造一个5行5列的二维数组，给数组赋值，并将其按照行列对齐的方式输出，使程序输出结果如下:
0 0 0 0 1
0 0 0 2 3
0 0 4 5 6
0 7 8 9 10
11 12 13 14 15
解析：
- 第一组for循环的作用是为二维数组赋值，变量i为行数，变量j为列数，由于要求输出的数组为5行5列，所以第一空填”j<5"；
- 根据题目要求可知语句”if((i+j)<4)"，所以第二空填"4”，
- 当所判断元素为上三角元素时，通过语句”a[i][j]=0;“为其赋值为0， 若不是上三角元素，则自动转到else语句所带的表达式中，k的初始值为1，随循环依次递增。当”(i+j)>=4”时， 为a[i][j]赋值: a[i][j]=k， 所以第三空填"a[i][j]=k++”。
- 最后在输出时，由于大于10的数字占两个字符，打印空格需要区分，所以第四空填”10”。
import java.io.*;
public class Java_2{
public static void main(String args[]) {
int a[][] = new int[5][5];
int i,j,k=1;
for(i=0;i<5;i++)
//*********Found**********
for( j=0; j<5 ;j++ ) （1、数组的列数）
//*********Found**********
if((i+j)< 4) （2、判断是否是上三角形的数据）
a[i][j]=0;
else{
//*********Found**********
a[i][j]=k++; （3、数值递增赋值）
}
for(i=0;i<5;i++){
for(j=0;j<5;j++)
//*********Found**********
if(a[i][j]< 10) （4、大于10的数字占两个字符）
System.out.print(a[i][j]+ " ");
else
System.out.print(a[i][j]+ " ");
System.out.println();
}
}
}
考查二维数组
题目：
创建一个二维整型数组，并将其以4行4列左对齐的格式输出，程序输出结果如下:
1 1 1 1
2 2 2
3 3
4
解析：
-
二维数组的定义和一维数组类似，有多少维度即在定义时写多少方括号，所以第一-空填写”[][]”。
-
因数每行的个数依次是递减的，所以第二空填空"k–"
-
因为需要输出四行四列数据，所以二维数组中，第二维即每一 列，所以第三空填写”aMatrix[i]"。
-
在嵌套循环结束后，即输出了第二维的的每一项数据后，应当输出，所以第四空填写’ println()"。
public class Java_2{
public static void main(String[] args){
//*********Found**********
int [][]aMatrix = new int[4][]; （1、二维数组的定义）
int i = 0;
int j = 0;
int k = 4;
for(i = 0; i < 4; i++){
//*********Found**********
aMatrix[i] = new int[k--]; （2、控制数据逐行减少）
//*********Found**********
for (j = 0; j < aMatrix[i].length; j++) { （3、判断数据长度）
aMatrix[i][j] = i+1;
System.out.print(aMatrix[i][j] + " ");
}
//*********Found**********
System.out.println(); （4、换行输出）
}
}
}
考查多维数组
- 题目：
构造一个5行5列的矩阵并将其打印输出，使程序的输出结果如下:
1 2 3 4 5
6 7 8 9 0
1 2 3 0 0
4 5 0 0 0
6 0 0 0 0
解析：
-
用new关键字初始化多维数组，只指定数组行数和列数，为数组分配存储空间，并不给数组元素赋初始值。用new关键字初始化数组的格式如下:
数组名=new类型标识符[行数][列数]
所以第一空填" new"。 -
第一组for循环的作用是为二维数组赋值，变量i为行数，变量j为列数，根据语句"if((i+j)<5)”可知，当所判断元素为上三角元素时，通过语句”a[i][j]=k;"为其赋值，k的初始值为1，随循环依次递增，所以第二空填: "k++”。
-
当"(i+j)>=5"时，不满足if的条件，所以自动转到else语句所带的表达式中，因为要求输出的矩阵中右下三角元素都为0，所以，第三空填"a[i][j]=0”。
-
最后打印要实现自动换行，所以第四空填"System. out. println();"。
public class Java_2{
public static void main(String args[]) {
//*********Found**********
int a[][] = new int[5][5]; （1、用new关键字初始化多维数组）
int i,j,k = 1;
//给多维数组赋值，i为行数，j为列数
for(i=0;i<5;i++)
for(j=0;j<5;j++)
if((i+j)<5){
a[i][j] = k;
//*********Found**********
k++; （2、k的初始值为1，随循环依次递增）
if (k > 9) k = 1;
}else
//*********Found**********
a[i][j] =0; （3、输出的矩阵中右下三角元素都为0）
for(i=0;i<5;i++){
for(j=0;j<5;j++)
System.out.print(a[i][j]+ " ");
//*********Found**********
System.out.print("\n"); （4、换行）
}
}
}
4、考查线程的创建
- 题目：
本题的要求是:
创建一一个线程，按照从1到5递增的顺序将这两个整数打印出来，使程序的输出结果如下:
x=1,y =1
x=2,y =2
x=3,y =3
x=4,y =4
x=5,y =5
解析：
-
创建线程有两种方法，实现Runnable接口和继承Thread类， 所以第一空填"implements
Runnable"或" extends Thread" ； -
在Java_ 2类的main()方法中，以Java_ 2类的实例对象r创建线程t，所以第二空填"r”；
-
题面要求”按照从1到5递增的顺序将这两个整数打印出来”，所以通过语句”if (k>5) break;" 可知通过判断变量k的值，判断for循环是否继续，所以变量k初始值应该
为0，第三空填"k"; -
因为需要按照递增顺序输出x和y两个整数，程序中已经通过语句’x++;"实现了变量x的递增，所以第四空应该填’ y++"实现变量y的递增。
//*********Found**********
public class Java_2 extends Thread { （1、线程的创建）
private int x=0;
private int y=0;
public static void main(String[]args){
Java_2 r = new Java_2();
//*********Found**********
Thread t = new Thread(r); （2、实例化创建线程）
t.start();
}
public void run() {
//*********Found**********
int k = 0; （3、条件判断）
for(;;){
x++;
//*********Found**********
y++; （4、循环输出）
k++;
if (k>5) break;
System.out.println("x=" + x + ",y ="+ y);
}
}
}
考查线程
本题的要求是:
该程序的功能是程序运行后每隔100毫秒打印输出1个字符串，每个字符串占一行，共8个字符串，程序每次运行时，这些字符串输出的先后顺序可能有所不同。例如，某次运行结果如下:
first0
second0
first1
second1
first2
second2
second3
first3
解析：
-
在类的声明中，通过关键字extends来创建一个 类的子类，首先定义一一个类去继承Thread父类，所以第一空填”extends Thread" 。
-
通过调用Thread类的start()方法来启动一个线程，所以第二空和第三空填”start()"
-
定义了一个函数Java_ 2,参数是string类型的s，所以第四空填"Java_ 2”。
-
public String getThreadName() {}定义了返回类型为string的函数，所以第五空填”getThreadName()"。
//*********Found**********
public class Java_2 extends Thread{ （1、通过extends Thread 或者implements Runnable 创建线程）
private String sThreadName;
public static void main(String argv[]){
Java_2 first = new Java_2("first");
//*********Found**********
first.start(); （2、3、通过调用Thread类的start()方法来启动一个线程）
Java_2 second = new Java_2("second");
//*********Found**********
second.start();
}
//*********Found**********
public Java_2(String s){
sThreadName = s;
}
public String getThreadName(){
return sThreadName;
}
public void run(){
for(int i = 0; i < 4; i ++){
//*********Found**********
System.out.println(getThreadName()+i); （4、通过getThreadName（）方法返回值）
try{
Thread.sleep(100);
} catch(InterruptedException e){
System.out.println(e.getMessage());
}
}
}
}
考查线程
题目：
程序的功能是:定义了一个简单的线程，可以对其名称进行设置。该程序运行时的输出结果如下:
Running the Testing_ Thread:
__0__Testing_ Thread
__1__Testing_ Thread
__2__Testing_ Thread
__3__Testing_ Thread
__4__Testing_ Thread
解析：
- 线程的启动方法是start，所以第一空填写"t. start()”。
- 创建线程时，应该继承Thread类或者实现Runnable接口，本题中，该类己知的关键字为extends，所以第二空填写"Thread"。
- 当需要给线程命名时，只需要在本类中实现父类String参数的构造
器，所以第三空填写”super(str)”。 - 用start方法来启动线程，真正实现了多线程运行，这时无需等待run方法体代码执行完毕而直接继续执行下面的代码。而直接执行run方法却会出现等待。本类中，主函数调用start方法，具体实现则在run中，所以第四空填写”run’
- 异常的捕捉有很多种，这里给出了己知的try，所以第五空填写”catch" 。
public class Java_2
{
public static void main(String[] args)
{
Thread t = new SimpleThread("Testing_Thread");
//*********Found**********
t.start() ; （1、开启线程）
}
}
//*********Found**********
class SimpleThread extends Thread （2、通过extends Thread 或者implements Runnable 创建线程）
{
public SimpleThread(String str)
{
//*********Found**********
super(str); （3、给线程命名，实现父类参数的构造方法）
}
//*********Found**********
public void run() （4、主函数调用start方法，具体实现则在run中）
{
System.out.println("Running the " + getName() + ":");
for (int i = 0; i < 5; i++)
{
System.out.println("---" + i + "---" + getName());
try
{
sleep((int)(2 * 100));
}
//*********Found**********
catch(InterruptedException e) { } （5、try_catch_finally的使用）
}
}
}
5、考查线程的生命周期与线程控制
题目：
在主线程中创建一个线程， 该线程休眠50ms，然后再给变量i赋值。主线程要等该子线程结束后获得i的值并输出。程序的输出结果如下:
j=10,a. i=10
解析：
线程的生命周期包括5种状态:
- 新生状态:用new关键字和Thread类或其子类建立一个线程对象后， 该线程对象就处于新生状态。处于新生状态的线程有自己的内存空间，通过调用start方法进入就绪状态，所以第一空应该填”start"。
- 就绪:处于就绪状态的线程已经具备了运行条件，但需要进入线程队列，等待系统为其分配CPU，创建新线程有两种方式，这里是实现Runnable接口，所以第二空填”Runnable"。
- 运行:在运行状态的线程执行自己的run方法中的代码，直到调用其他方法而终止、或等待某资源而阻塞或完成任务而死亡。
- 阻塞:处于运行状态的线程在某些情况下，如执行了sleep()方法，将让出CPU并暂时终止自己的运行，进入阻塞状态。在本程序中，线程需要休眠50ms然后给变量i赋值，所以调用sleep()方法， 第三空应该填”sleep"。
- 死亡:线程死亡的原因有两个，一是 正常运行的线程完成了全部工作;另一个是线程被强制性地终止。
本程序用到的线程控制方法sleep():该方法使一个线程暂停运行一段固定的时间。在休眠时间内，线程将不运行，休眠时间的长短由sleep()方法的参数决定。sleep() 方法结束后，线程将进入可运行状态，进行接下来的给变量i赋值的操作。
public class Java_2 {
public static void main (String args[]) {
try {
Sleep a = new Sleep ();
Thread t = new Thread (a);
//*********Found**********
t.start(); （1、通过new对象创建线程后，调用start（）方法进入就绪状态）
t.join();
int j= a.i;
System.out.println("j="+j+",a.i="+a.i);
} catch (Exception e) {}
}
}
//*********Found**********
class Sleep implements Runnable{ （2、创建线程有两种方式，extends Thread或者实现Runnable接口）
int i;
public void run () {
try {
//*********Found**********
Thread.sleep(50); （3、执行了sleep()方法，将让出CPU并暂时终止自己的运行，进入阻塞状态）
i= 10;
}
//*********Found**********
catch(InterruptedException e) {} （4、try catch的搭配使用）
}
}
6、考查输入与输出
-
题目：
打开一个文本文件test. txt，统计该文件中包含的数字的个数与英文字母的个数(忽略大小写)。例如test. txt文本文件中包含的内容为”123abcDEF99G"，则程序的输出结果如下:数字数是5，字母数是7
解析：
- 新建一个byte型数组buf，在这里第一空填"byte"
- 在Java中可以通过try-catch-finally结构对异常进行捕获和处理，其中.finally块是个可选项，通过程序中的”catch (Exception e )“语句，可知第二空填"try”;
- 以字节流方式从磁盘文件中读取信息时，首先要为磁盘文件建立一个File对象，再为该File对象建立FileInputStream类流对象，然后就可以通过该类的read()方法逐个字节从文件读入，读入操作完成后，利用close() 方法关闭FileInputStream流，所以第三空填”new FileInputStream"，第四空填”close"
import java.io.*;
public class Java_2{
public static void main (String[] args){
//*********Found**********
byte buf[] = new byte[5]; （1、新建一个byte型数组buf）
int len= 0 ,c1 = 0,c2=0;
//*********Found**********
try{ （2、try-catch-finally结构对异常进行捕获和处理）
//*********Found**********
FileInputStream in = new FileInputStream("test.txt"); （3、建立FileInputStream类流对象）
while((len =in.read(buf,0,5))>0){
for(int i = 0; i < len;i++)
if(buf[i]>= '0' && buf[i] <= '9'){
c1 ++;
}
else
if((buf[i]>= 'a' && buf[i] <= 'z') || buf[i]>= 'A' && buf[i] <= 'Z')
c2++;
if(len <5) break;
}
//*********Found**********
in.close(); （4、关闭FileInputStream流）
}catch(Exception e ){}
System.out.println("数字数是 " + c1 + "，字母数是 " + c2);
}
}
7、考查异常处理
题目:
阅读Java_ 2. java程序，完成程序并运行，所得结果为:
Hello World!
————————————
Hello!
————————————
HELLO WORLD! !
————————————
Catch 3
Ending the print.
——————————-——
解析：
-
本题首先要理解数组的定义方法。在Java中定义一维数组格式为: type arrayName []或type[] arrayName;其中type可以是Java语言的任意数据类型，数组名是合法标识符，[]说明变量是数组变量，数组的元素类型必须与数组类型一 致。由语句”System. out. println (greetings[i]);“可知， 第一空填’ greetings”.
-
其次要注意异常处理。一个方法中为某种类型的异常对象提供有对应的处理时，调用该方法时就可捕获该种异常。异常被定义后，必须通过try-catch-finally语句处理。该语句执行时，解释器把可能产生异常的代码段形成一个”警戒区”，该”警戒区”由try引导。”警戒区”后面是catch从句， 一个”警戒区”后面可接多个catch从句。try"警戒区"在遇到异常情况时，停止执行而跳转到相应处理异常的程序，这就由catch来控制，所以第二空
填"catch”。 -
catch子句都带一个参数，该参数是某个异常的类及其变量名，catch用该参数去与抛出异常对象的类进行匹配，匹配上后就去执行catch后的程序段，即处理异常;如匹配不上就跳到下一.个catch, 直至找到为止，Throwable的getMessage()方法是用来获得异常事件信息的，所以第三空填”e”。
-
Java预定义了一些常见异常类，如:Array IndexOutofBoundsException， 数组索引越界异常，当数组的索引值为负数或大于等于数组大小时抛出。最后，while循环问题，while循环又称” 当型循环”，在每次循环开始时判断循环条件。程序中使用变量i作为循环条件，根据程序运行结果可知，循环每执行一次，变量i的值都要加1，所以，第四空填”i++”或其等效形式。
public class Java_2{
public static void main(String args[]){
int i=0;
String greetings[] ={ "Hello World!","Hello!","HELLO WORLD!!"};
while (i<4){
try{
//*********Found********
System.out.println(greetings[i]); （1、逐个输出数组元素）
}
//*********Found********
catch(ArrayIndexOutOfBoundsException e){ （2、try-catch-finally结构对异常进行捕获和处理）
//*********Found********
System.out.println("Catch " + e.getMessage()); （3、异常捕获）
System.out.println("Ending the print.");
}
finally{
System.out.println("---------------------");
}
//*********Found********
i++; （4、循环控制）
}
}
}
8、考查文件和递归调用
题目：
本题的要求是:
程序列出当前目录下所有文件和文件夹的名称。如果当前目录含有子文件夹，则也递归地列出子文件夹的内容，用缩进地方
式反映层次关系，文件夹的名称用尖括号括起来。某次运行结果如下:
当前的工作目录是:Z: \test
Java_ 2. class
< source>
<Java1>
Java_ 1. java
<Java2>
Java_ 2. java
<Java3>
Java_ 3. java
解析：
-
文件类File以一种系统无关的方式表示一个文件对象的属性。而目录在Java中作为一 种特殊文件，即文件名的列表，通过类File所提供的方法，可得到文件或目录的描述信息，也可以生成新文件、目录、修改文件和目录、查询文件属性，重命名文件或者删除文件。File类中封装了对文件系统进行操作的功能。
-
递归就是用自身的结构来描述自身。一个使用递归技术的方法将直接或间接地调用自身的方法。
import java.io.File;
public class Java_2
{
public static void main(String s[])
{
//Getting the Current Working Directory
String curDir = System.getProperty("user.dir");
System.out.println("当前的工作目录是:"+curDir);
//*********Found**********
File ff=new File(curDir); （1、以当前的工作目录来建立文件）
String[] files=ff.list();
for(int i=0; i<files.length; i++) （2、for循环）
{
String ss=curDir+"\\"+files[i];
traverse(0,ss);
}
}
/**
* 递归地遍历目录树
* @param level 目录的层次
* @param s 当前目录路径名
*/
public static void traverse(int level,String s)
{
File f=new File(s);
for(int i=0; i<level; i++) System.out.print(" ");
if(f.isFile())
{
System.out.println(f.getName());
}
else if(f.isDirectory())
{
//*********Found**********
System.out.println("<"+f.getName()+">"); （3、输出路径名）
String[] files=f.list();
level++;
//*********Found**********
for(int i=0; i<files.length; i++)
{
String ss=s+"\\"+files[i];
//*********Found**********
traverse(1evel,ss); （4、traverse方法包含两个参数int型的变量1eve1和String型的变量s，递归调用时，需要将参数带入）
}
}
else
{
System.out.println("ERROR!");
}
}
}
9、考查方法参数的传递和对象的实例化
题目：
运行程序后，输出结果为(2, 3)
解析：
-
对象实例化的一般格式是先定义一个对象变量，再用关键字new生成一个对象，并对对象中的变量赋初值。如下所示: type objectName=new type([参数])， 其中type objectName声明是定义对象的类型;new关键字的作用是实例化一个对象，给对象分配内存，它调用对象的构造方法，返回该对象的引用，所以第一空填”new"。
-
private修饰符修饰的类变量在类内可访问，其他类不能进行访问。根据语句private int y;“可知，第二空填”int x;”
-
构造方法用来初始化对象，其方法名必须与类名相同且只能通过new自动调用，第三空所在的方法是Point类的构造方法，所以，第三空填"Point”。
-
只要是一个类而且继承自object，那么这个类就会继承0b ject的toString方法， 功能是将对象转换为其字符串表现形式，使它适合于显示。第四空重写toString方法以
(x, y)的格式返回点的位置，所以填”toString”。
public class Java_2 {
public static void main(String[ ] args) {
Point pt;
//*********Found**********
pt = new Point(2, 3); （1、new关键字的作用是实例化一个对象，给对象分配内存）
System.out.println(pt);
}
}
class Point {
//*********Found**********
private int x; （2、考查代码上下文）
private int y;
//*********Found**********
public Point (int a, int b) { （3、构造方法）
x = a;
y = b;
}
int getX( ) {
return x;
}
int getY( ) {
return y;
}
void setX(int a) {
x = a;
}
void setY(int b) {
y = b;
}
//*********Found**********
public String toString( ) { （4、考查toString方法）
return "( " + x + "," + y + " ) ";
}
}
10、考查构造方法的重载
题目：
运行程序后，输出结果为(0,0) (2, 3)
解析：
-
构造方法是一种特殊的方法，当定义的类在使用new创建对象时自动引用构造方法对成员变量进行初始化操作。同样也可以对类的构造方法设置多个同名方法，根据参数的不同引用不同的构造方法。程序定义并初始化含有2个元素的一维数组pt，在Java
中定义并创建一个数组对象的方式是: type[] arrayName=new type [arraySize];所以第一空填Point[]”。 -
根据题面要求可知，程序需要通过for循环将数组pt的元素依次输出，i的取值应为0<=i <=pt. length-1,所以第二空填" length"。
-
构造方法用来初始化对象，其方法名必须与类名相同且只能通过new自动调用，第四空所在的方法是Point类的构造方法，所以，第三空填"Point”。
-
在这返回y的值，所以第四空填"y"。
public class Java_2 {
public static void main(String[ ] args) {
//*********Found**********
Point[] pt = new Point[2]; （1、new关键字的作用是实例化数组对象）
pt[0] = new Point();
pt[1] = new Point(2, 3);
//*********Found**********
for (int i=0; i < pt.length; i++) { （2、考查数组长度length）
System.out.print( pt[i] );
}
}
}
class Point {
private int x;
private int y;
public Point() {
this(0, 0);
}
//*********Found**********
public Point (int a, int b) { （3、有参构造）
x = a;
y = b;
}
int getX( ) {
return x;
}
int getY( ) {
//*********Found**********
return y; （4、getXXX方法）
}
void setX(int a) {
x = a;
}
void setY(int b) {
y = b;
}
public String toString ( ) {
return " ( " + x + "," + y + " ) ";
}
}
11、考查矩阵的计算
题目：
解析：
-
根据程序中，第一空之前的数组a和数组b的初始化语句“int [][]a = {{2， 3, 4}，{4, 6, 5}};”和“int [][]b={{1,5，2,8}，{5,9,10,-3}，{2,7,-5，-18}};”可知，第一空所在的语句的作用是初始化二维数组C,由于二维数组c的元素值是在之后由程序赋值，现在还不能定，因此，只需要采用动态初始化的方法，为数组c分配空间即可，根据题面中给出的输出结果可知，第一空填“new int[2][4]”
-
程序中的第一个for循环是控制数组c的行数，第二个for循环是控制数组c的列数，而第三个for循环则是为二维数组c的元素赋值。根据题面中给出的输出结果可知，2二维
数组c相当于一个2行4列的矩阵，所以，第二空填4。 -
由于程序中，第三个循环周期结束，即完成对一个元素的赋值，那么，在对下一个元素赋值前，需要将该元素的值初始化为0，所以第三空填“c[i][j]=0
-
运行结果计算：左矩阵的每一行分别与右矩阵的每一列相乘
eg:2×1+3×5+4×2 =25
根据矩阵乘法的计算准则可知，第四空填a[i][k]*b[k][j]”
public class Java_2 {
public static void main(String args[]) {
int [][]a = {{2, 3, 4}, {4, 6, 5}};
int [][]b = {{1, 5, 2, 8}, {5, 9, 10, -3}, {2, 7, -5, -18}};
//*********Found**********
int [][]c = new int[2][4]; （1、根据题面中给出的输出结果可知，实例化二维数组，new int[2][4]）
//控制数组c的行数
for (int i = 0; i < 2; i++) {
//*********Found**********
//控制数组c的列数
for (int j = 0; j < 4; j++) { （2、控制数组c的列数）
//*********Found**********
c[i][j]=0; （3、完成对一个元素的赋值，初始化为0）
for (int k = 0; k < 3; k++)
//*********Found**********
c[i][j] += a[i][k]*b[k][j]; （4、矩阵计算）
System.out.print(c[i][j] + " ");
}
System.out.println();
}
}
}
12、考查对文件读、写对象数
题目：
该程序的功能是:将-一个对象写入一个数据文件，再读出该对象并显示出来。.
该程序的运行结果是:小王.
解析：
-
需要使用到与对象有关的流0bjectInputStream/ 0bjectOutputStream.
-
ObjectOutputStream:对象输出流，使用writeObject(0bject obj) 方法将一个对象0bj写入输出流;
0bjectInputStream: 对象输入流，使用read0bject()方法读取一个对象所以第一空填"FileOutputStream”， 第二空填"read0bject"。
3、 当一个类实现了Serializable接口(该接口仅为标记接口，不包含任何方法定义)，表示该类可以序列化，序列化的目的是将一个实现了Serializable接口的对象转换成一个字节序列，所以第三空填”Serializable"。
- 默认执行0bject的toString方法，在该类重写该方法，达到输出姓名效果，所以第四空填”toString’
import java.io.*;
public class Java_2 {
public static void main(String[] args) {
ObjectOutputStream oos = null;
ObjectInputStream ois = null;
try {
File f = new File("Person.dat");
//*********Found**********
oos = new ObjectOutputStream(new FileOutputStream(f)); （1、FileOutputStream对象输出流）
//写入数据“小王”
oos.writeObject(new Person("小王"));
oos.close();
ois = new ObjectInputStream(new FileInputStream(f));
//*********Found**********
Person d = (Person) ois.readObject(); （2、读取数据）
System.out.println(d);
ois.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
//*********Found**********
class Person implements Serializable { （3、Serializable 接口）
String name = null;
public Person(String s) {
name = s;
}
//*********Found**********
public String toString() { （4、返回值类型为String的toString（）方法）
return name;
}
}
考查IO
题目：
1.以行的方式读入每个用户名及其密码信息，例如: user1 123456 (用户名和密码之间用-一个空格隔开);
2.循环读入，直到用户输入“quit”或者“QUIT”结束;
3.程序结束前提示用户输入一个文件名来保存前面输入的所有用户名和密码。
解析;
- 由InputStreamReader对象得知，本题应引入java. io下的类，所以第一空填写”io”
- InputStreamReader 是字节流通向字符流的桥梁，构造器为一个参数时，即填System. in,所以第二空填写"System. in”。
- 根据题 意得知，当用户输入quit或其大写时，退出程序，所以第三空填写"quit”。
- out. write是将内容写入文件，根据上下文可得知变量tmp即为需要写入的内容，所以第四空填写”tmp’
//*********Found**********
import java.io.*;
import java.util.Vector;
public class Java_2
{
public static void main(String args[])
{
Vector v=new Vector();
try
{
//*********Found**********
BufferedReader in = new BufferedReader(new InputStreamReader(v));
String str = "";
System.out.println("请输入用户和密码信息，中间用空格隔开，输入quit退出:");
//*********Found**********
while (!(str.equals("quit")||str.equals("QUIT")))
{
str = in.readLine();
if(isValid(str))
v.add(str);
else
{
if(!(str.equals("quit")||str.equals("QUIT")))
System.out.println("The string is NOT valid!");
}
}
System.out.println("请输入保存到的文件名:");
str=in.readLine();
String curDir = System.getProperty("user.dir");
File savedfile=new File(curDir+"\\"+ str );
BufferedWriter out = new BufferedWriter(new FileWriter(savedfile));
for(int i=0; i<v.size(); i++)
{
String tmp=(String)v.elementAt(i);
//*********Found**********
out.write(tmp);
out.write("\n");
}
out.close();
}
catch (Exception e)
{
System.out.print("ERROR:"+e.getMessage());
}
}
/**
* 判定输入的字符串是否符合规范
* @param s 输入的待校验的字符串
* @return 校验的结果，正确则返回为真
*/
public static boolean isValid(String s)
{
if(s.indexOf(" ")>0)
return true;
else
return false;
}
}
考查IO缓存流
题目：
解析：
- BufferedReader是一个缓存阅读器类， 并非接口，可以实例化，所以第一空写"BufferedReader”。
- 根据题意得知，需要输入用户名和密码，中间用空格隔开，isValid的方法可以看出是验证是否有空格，没有空格则会判断是否退出，所以需要验证的字符串为str，即用户自己输入的信息，所以第二空填写”str”。
- 判断完成后接着给str赋值下一行的内容，所以第三空填写”in’
FileWriter是一个文件写入类，根据题目上下文得知，这里需要保存一个文件，所以第四空填写”savedfile”。 - 文本换行符为”\n”，所以第五空填写:"\n"
- 捕捉异常的关键字是catch，所以第六空填写”catch"
import java.io.*;
import java.util.Vector;
public class Java_2{
public static void main(String s[]){
Vector v=new Vector();
try{
//*********Found**********
BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); //键盘输入
String str = "";
System.out.println("请输入用户和密码信息，中间用空格隔开，输入quit退出:");
while (!(str.equals("quit")||str.equals("QUIT"))){
str = in.readLine();
//*********Found**********
if(isValid(str)) //验证输入是否有空格
v.add(str);
else{
if(!(str.equals("quit")||str.equals("QUIT")))
System.out.println("The string is NOT valid!");
}
}
System.out.println("请输入保存到的文件名:");
//*********Found**********
str=in.readLine();
String curDir = System.getProperty("user.dir");
File savedfile=new File(curDir+"\\"+str);
//*********Found**********
BufferedWriter out = new BufferedWriter(new FileWriter(savedfile));
for(int i=0; i<v.size(); i++){
String tmp=(String)v.elementAt(i);
out.write(tmp);
//*********Found**********
out.write("\n"); //换行
}
out.close();
}
//*********Found**********
catch(Exception e){
System.out.print("ERROR:"+e.getMessage());
}
}
/**
* 判定输入的字符串是否符合规范
* @param s 输入的待校验的字符串
* @return 校验的结果，正确则返回为真
*/
public static boolean isValid(String s){
if(s.indexOf(" ")>0) return true;
else return false;
}
}
考查流文件
题目：
本题的要求是:
将四句歌词分行写入到test.txt文件中，然后从该文件读出所有内容并显示。
运行结果为:
第1行内容:在那山的那边海的那边有-群蓝精灵
第2行内容:它们活泼又聪明它们调皮又灵敏
第3行内容:它们自由自在生活在那绿色的大森林
第4行内容:它们善良勇敢相互都欢喜!
import java.io.*;
public class Java_2 {
public static void main(String args[]) {
String ShowMes[] = {"在那山的那边海的那边有一群蓝精灵", "它们活泼又聪明它们调皮又灵敏", "它们自由自在生活在那绿色的大森林", "它们善良勇敢相互都欢喜！"};
try {
//*********Found********
FileWriter out = new FileWriter(new File("test.txt")); （1、实例化文件对象（文件名称），作为输入流文件的参数）
BufferedWriter outBW = new BufferedWriter(out);
for (int i = 0; i < ShowMes.length; i++) {
outBW.write(ShowMes[i]);
outBW.newLine();
}
//*********Found********
outBW.close(); （2、关闭文件输入流）
} catch (Exception e) {
e.printStackTrace();
}
try {
//*********Found********
FileReader in = new FileReader(new File("test.txt")); （3、实例化文件输出流对象）
BufferedReader inBR = new BufferedReader(in);
String stext = null;
int j = 1;
while ((stext = inBR.readLine()) != null) {
System.out.println("第" + j + "行内容：" + stext);
//*********Found********
j++; （4、每输出一行，行数+1）
}
inBR.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
13、考查输出流
题目：
本题程序的运行结果如下:
in SuperClass:x=3 .
in SubClass :x=5 .
in SuperClass. doSomething ()
in SubClass. doSomething()
super. x=3
sub. x=5
public class Java_2{
public static void main(String args[]) {
SubClass subC = new SubClass();
subC.doSomething();
}
}
class SuperClass {
int x;
SuperClass() {
//*********Found********
x = 3; （1、根据题意填写x的值）
System.out.println("in SuperClass : x=" + x);
}
void doSomething() {
//*********Found********
System.out.println("in SuperClass.doSomething()"); （2、输出字符串）
}
}
class SubClass extends SuperClass {
int x;
SubClass() {
super();
//*********Found********
x = 5;
System.out.println("in SubClass :x=" + x);
}
void doSomething() {
super.doSomething();
//*********Found********
System.out.println("in SubClass.doSomething()");
System.out.println("super.x=" + super.x + " sub.x=" + x);
}
}
14、考查图形用户界面
题目：
//*********Found********
import java.awt.*; （1、导入图形用户界面包）
import java.io.*;
import java.awt.event.* ;
import javax.swing.*;
//*********Found********
public class Java_2 implements ActionListener{ （2、实现图形监听接口implements ActionListener）
JTextArea ta;
JFrame f ;
JLabel label;
JButton bt;
public static void main(String args[ ]){
Java_2 t = new Java_2();
t.go();
}
void go(){
f = new JFrame("Save data");
label = new JLabel("请输入需要保存的文本：");
ta = new JTextArea(3,20);
bt = new JButton("保存");
//*********Found********
f.add(label,BorderLayout.NORTH); （3、将文本区label域添加到南边）
f.add(ta,BorderLayout.CENTER);
f.add(bt,BorderLayout.SOUTH);
//*********Found********
bt.addActionListener(this); （4、添加按钮组件监听）
f.setSize(400,400);
f.pack( );
f.setVisible(true) ;
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
public void actionPerformed(ActionEvent event){
try{
FileWriter out = new FileWriter("out.txt");
String str = ta.getText();
//*********Found********
out.write(str); （5、调用write（）方法写入数据）
out.close();
} catch( Exception e){
}
}
}
15、考查JavaSwing
题目：
解析：
- 由代码上下文可知。本题将用到javax. swing相关包，所以第一-空填写swing
- 由题意得知需要判断骰子每一面出现的次数，在本例中，循环内的face变量即为随机骰子数是几，在之后的switch中可看出，能够根据变量对相应的出现面数的变量做加法操作，所以swi tch里应判断face变量，所以第二空填写“face”。
- JTextArea是一 文本域对象，需要new关键字来实例化，所以第三空填写“new”。
- JOpt ionPane. showMessageDialog是创建一个提示框窗口， 第二个参数是加入其中的组件，根据题意得知，需要加入的是outputArea文本域对象, .所以第四空填写“outputArea”。
- 最后 程序退出，所以第五空填写“exit"
//*********Found**********
import javax.swing.*;
public class Java_2{
public static void main( String args[] ){
int frequency1 = 0, frequency2 = 0,
frequency3 = 0, frequency4 = 0,
frequency5 = 0, frequency6 = 0, face;
//骰子旋转500次的代码
for ( int roll = 1; roll <= 500; roll++ ) {
face = 1 + (int) ( Math.random() * 6 );
//*********Found**********
switch ( face ) {
case 1:
++frequency1;
break;
case 2:
++frequency2;
break;
case 3:
++frequency3;
break;
case 4:
++frequency4;
break;
case 5:
++frequency5;
break;
case 6:
++frequency6;
break;
}
}
//*********Found**********
JTextArea outputArea = new JTextArea( 7, 10 );
outputArea.setText(
"面\t频率" +
"\n1\t" + frequency1 +
"\n2\t" + frequency2 +
"\n3\t" + frequency3 +
"\n4\t" + frequency4 +
"\n5\t" + frequency5 +
"\n6\t" + frequency6 );
//*********Found**********
JOptionPane.showMessageDialog( null, outputArea,
"骰子旋转500次",
JOptionPane.INFORMATION_MESSAGE );
//*********Found**********
System.exit( 0 );
}
}
16、考查构造方法的重载
题目：
import java.awt.*;
import java.awt.event.*;
import java.util.Vector;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.table.*;
//*********Found********
public class Java_2 implements ActionListener{ （1、实现图形监听接口implements ActionListener）
JTable table = null;
DefaultTableModel defaultModel = null;
//*********Found********
public Java_2 (){ （2、构造方法）
JFrame f = new JFrame();
String[] name = {"字段 1","字段 2","字段 3","字段 4","字段 5"};
String[][] data = new String[5][5];
int value =1;
for(int i=0; i<data.length; i++){
for(int j=0; j<data.length ; j++)
data[i][j] = String.valueOf(value++);
}
defaultModel = new DefaultTableModel(data,name);
table=new JTable(defaultModel);
table.setPreferredScrollableViewportSize(new Dimension(400, 80));
JScrollPane s = new JScrollPane(table);
JPanel panel = new JPanel();
JButton b = new JButton("增加行");
panel.add(b);
//*********Found********
b.addActionListener(this); （3、给“添加行”按钮添加监听事件addActionListener）
b = new JButton("删除行");
panel.add(b);
b.addActionListener(this);
//*********Found********
Container contentPane = f.getContentPane(); （4、调用getContentPane（）方法将容器添加到JFrame 面板中）
contentPane.add(panel, BorderLayout.NORTH);
contentPane.add(s, BorderLayout.CENTER);
//*********Found********
f.setTitle("增删表格行"); （5、设置JFrame面板的标题）
f.pack();
f.setVisible(true);
f.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
//*********Found********
table.addMouseListener(new MouseAdapter() { （6、调用鼠标点击事件）
public void mouseClicked(MouseEvent e) {
if(table.isCellSelected(table.getSelectedRow(), table.getSelectedColumn())){
int selRow=table.getSelectedRow();
int selCol=table.getSelectedColumn();
JOptionPane.showMessageDialog(null,
"位于 ("+selRow+","+selCol+")的元素： "+table.getValueAt(selRow,selCol),
"PLAIN_MESSAGE", JOptionPane.PLAIN_MESSAGE);
}
}
});
}
public void actionPerformed(ActionEvent e){
if(e.getActionCommand().equals("增加行"))
defaultModel.addRow(new Vector());
if(e.getActionCommand().equals("删除行")){
int rowcount = defaultModel.getRowCount()-1; //getRowCount返回行数，rowcount<0代表已经没有任何行了。
if(rowcount >= 0){
defaultModel.removeRow(rowcount);
defaultModel.setRowCount(rowcount);
}
}
table.revalidate();
}
public static void main(String[] args) {
new Java_2();
}
}
17、考查对Comparable的理解
Comparable接口，在你要排序的类中去实现comparable接口，同时在你要排序的类中先写一个方法用来声明你想让你类中的属性根据什么规则来排序。
题目：
对于给定的3位学生的Java成绩进行降序排序。程序输出结果如下:
Java成绩降序排序的结果是:
name='王晓，fenshu=98. 0
name=李明，fenshu=80. 0
name=赵冬，fenshu=75. 0
解析：
-
需要对成绩排序，所以sort的参数应为-一个含有成绩的数组对象，所以第一空填写”java”。
-
输出语句要求前面带有学生的名字，所以第二空填写”getName ()”。
-
Comparable是一个接口， 所以第三空填写”implements"
-
因为成绩是一个带有小数点的数值，所以第四空填写”double"。
import java.util.*;
public class Java_2
{
public static void main(String[] args)
{
Student[] java = new Student[3];
java[0] = new Student("李明", 80);
java[1] = new Student("赵冬", 75);
java[2] = new Student("王晓", 98);
//*********Found**********
Arrays.sort(java); （1、对数组对象进行降序）
System.out.println("Java 成绩降序排序的结果是：");
for (int i = 0; i < java.length; i++)
{
Student e = java[i];
//*********Found**********
System.out.println("name=" + e.getName() （3、调用getXXX()方法获取学生名字）
+ ",fenshu=" + e.getFenshu());
}
}
}
//*********Found**********
class Student implements Comparable
{
public Student(String n, double f)
{
name = n;
fenshu = f;
}
public String getName()
{
return name;
}
public double getFenshu()
{
return fenshu;
}
public int compareTo(Object otherObject)
{
Student other = (Student)otherObject;
if (fenshu < other.fenshu) return 1;
if (fenshu > other.fenshu) return -1;
return 0;
}
private String name;
//*********Found**********
private double fenshu; (4、double类型小写）
}
18、考查对Java基本类型
Double的理解
题目：
解析：
- 根据题目输出示例，可以看出canshu变量是–个带有小数点的值，所以第一空填写’ double”。
- 第一句输出的语句中，值应为cansnshu变量， 所以第二空填写canshu
- 主函数中调用了一个函数triple，且没有实例化任何对象就调用了它，可得知第三空填写”triple"。
- 在triple方法内， 参数10变为30可得知，变量进行了乘以3的操作，所以第四空填写"x=x* 3”。
- 最后还需要输出变量，所以第五空填写"x”。
public class Java_2
{
public static void main(String[] args)
{
System.out.println("观察triple方法参数 double 10.0 的改变：");
//*********Found********** （1、定义double数据类型）
double canshu = 10;
//*********Found**********
System.out.println("参数*３前，参数值为 " +canshu); （2、输出成员变量值）
triple(canshu);
System.out.println("在triple方法外，参数值仍为 " + canshu);
System.out.println("思考：方法能否改变参数值？");
}
//*********Found**********
public static void triple(double x) （3、定义成员方法）
{
//*********Found**********
x=x*3; （4、成员方法处理的实际内容）
//*********Found**********
System.out.println("在triple方法内，参数 10 变为 " + x); （5、输出参数最终值）
}
}
19、考查继承
题目：
解析：
- 根据题意得知，输出开头为每一个人的名字，所以第一-空填写”p. getName”
- 在本题中，无论是老张还是小王等，他们虽然职业不同，年龄不同等，但是他们都有一个共同点，那就是都是人类，所以在该例中，创建了一个Person类，但是由于每一个人的职业不同，所以导致Person类并不一定适用于所有人，只能抽取其中共同点，如:每个人都有名字，年龄等。所以该类是抽象类，第二空填写”abstract
- getDescription根据后面的工人类和学生类可知，该方法输出的是每个，人的职业的特点，所以该方法是抽象方法，第三空填写”abstract
- 抽象类是用来继承的，所以第四空和第五空填写”extends
import java.text.*;
public class Java_2
{
public static void main(String[] args)
{
Person[] people = new Person[2];
people[0] = new Worker("老张", 30000);
people[1] = new Student("小王", "计算机科学");
for (int i = 0; i < people.length; i++)
{
Person p = people[i];
//*********Found**********
System.out.println(p.getName() + ", " + p.getDescription()); （1、输出名字和其它信息）
}
}
}
//*********Found**********
abstract class Person （2、编写抽象类）
{
public Person(String n)
{
name = n;
}
//*********Found**********
public abstract String getDescription(); （3、定义抽象方法）
public String getName()
{
return name;
}
private String name;
}
//*********Found**********
class Worker extends Person （4、子类继承父类extends ）
{
public Worker(String n, double s)
{
super(n);
salary = s;
}
public String getDescription()
{
NumberFormat formatter = NumberFormat.getCurrencyInstance();
return "工人，年薪是 " + formatter.format(salary) + "。";
}
private double salary;
}
//*********Found**********
class Student extends Person
{
public Student(String n, String m)
{
super(n);
major = m;
}
public String getDescription()
{
return "学生，专业是 " + major + "。";
}
private String major;
}
20、考查对主函数参数的理解
题目：
程序的功能是:以两个文件名做为命令行参数，如果两个文件都存在，则将第二个文件的内容追加到第一个文件中，并将第二个文件从系统中删除。
程序运行时，将“a. txtb. txt”作为命令行参数，会显示:
has done!
SUCCESS!
解析：
- 由题意可知，aargs数组中是两个文件名，f1已经用了args[0]表示，那么第二个文件自然是args[1]， 所以第一空填写”args[1]"。
- 由题意得知， 需要将第二个文件加入到第一 个文件并删除第二个文件，FileReader是读取文件内容的类，所以第二空填写”f2"。
- b=fr.read()中的b表示的是第二个文件的位置，所以当需要写入第一一个文件时，则将b传入write，所以第三空填写”b”。
- 最后删除时要求输出"SUCCESS!"，所以第四空填写"SUCCESS!"
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class Java_2
{
public static void main(String args[])
{
if(args.length<2)
{
System.out.println("ERROR: need parameters.");
System.out.println("\n -usage: java <classname> <file1> <file2>");
System.exit(0);
}
File f1=new File(args[0]);
//*********Found**********
File f2=new File(args[1]); （2、根据题意填写args[1]）
try
{
//*********Found**********
FileReader fr=new FileReader(f2); （2、读取f2、写入f1）
FileWriter fw=new FileWriter(f1,true);
int b;
//*********Found**********
while(( b=fr.read() ) != -1 ) fw.write(b); （3、判断不为空，则写入）
fr.close();
fw.close();
}
catch(IOException e)
{
e.printStackTrace();
}
System.out.println("has done!");
//*********Found**********
if(f2.delete()) System.out.print("SUCCESS!"); （4、根据运行结果填入）
}
}
21、考查JavaSwing
题目：
解析：
- 根据题意和代码得知，b对象是-一个按钮，加入的事件监听则是本类的私有类HandleButton, 因为HandleButton类中实现了题目的要求，所以第一空填写“new
HandleButton()” - setVisible方法表示是否显示组件，所以第二空填写true
- Equals方法是字符串的比较方法，这里则是根据题意比较Hel1o和按钮的文本是否一致，所以第三空填写“b. getText ()”
- 题目要求窗口名称显示二级Java，所以第四空填写“Java_ 2(“二级Java”)”。
import javax.swing.*;
import java.awt.event.*;
public class Java_2 extends JFrame {
private JButton b;
public Java_2(String s){
setTitle(s);
b=new JButton("Hello");
getContentPane().add(b);
//*********Found********
b.addActionListener( new HandleButton );
setSize(150,150);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//*********Found********
setVisible( true);
}
class HandleButton implements ActionListener{
public void actionPerformed(ActionEvent e){
//*********Found********
if ( "Hello".equals( b.getText() )
b.setText("你好");
else
b.setText("Hello");
}
}
public static void main(String args[]){
//*********Found********
new Java_2 ("二级java");
}
}
考查JavaSwing
题目：
解析：
- Main方法中的frame对象，并没有在初始化时进行是否显示的操作，所以第一空填写”frame. show()"。
- 根据代码 上下文得知button是一个JRadioButton对象， 所以第二空填写”JRadioButton"。
- 事件监听器实现了actionPerformed方法， 它的参数是ActionEvent对象， 所以第三空填写”ActionEvent"。
- button. addActionListener是加入一个事件监听，由代码上下文得知，这里加入的是之前创建的listener对象， 所以第四空填写"listener”。
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class Java_2{
public static void main(String[] args){
RadioButtonFrame frame = new RadioButtonFrame();
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//*********Found**********
frame.show;
}
}
class RadioButtonFrame extends JFrame{
public RadioButtonFrame(){
setTitle("Radio按钮实例");
setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
Container contentPane = getContentPane();
label = new JLabel("热烈庆祝Java程序语言开考三周年");
label.setForeground(Color.yellow);
contentPane.setBackground(Color.red);
label.setFont(new Font("黑体", Font.PLAIN, DEFAULT_SIZE));
contentPane.add(label, BorderLayout.CENTER);
buttonPanel = new JPanel();
group = new ButtonGroup();
addRadioButton("小", 8);
addRadioButton("中", 12);
addRadioButton("大", 18);
addRadioButton("特大", 30);
contentPane.add(buttonPanel, BorderLayout.SOUTH);
}
public void addRadioButton(String name, final int size){
boolean selected = size == DEFAULT_SIZE;
//*********Found**********
JRadioButton button = new JRadioButton(name, selected);
group.add(button);
buttonPanel.add(button);
ActionListener listener = new ActionListener(){
//*********Found**********
public void actionPerformed(ActionEvent evt){
label.setFont(new Font("黑体", Font.PLAIN, size));
}
};
//*********Found**********
button.addActionListener(listener);
}
public static final int DEFAULT_WIDTH = 340;
public static final int DEFAULT_HEIGHT = 200;
private JPanel buttonPanel;
private ButtonGroup group;
private JLabel label;
private static final int DEFAULT_SIZE = 12;
}
考查JavaSwing
题目：
解析：
- JFrame对象的setDefaul tCloseOperation可以设置关闭程序后，进程是否关闭，所以第一空填写’ EXIT_ ON_ CLOSE"。
- WelcomFrame是一个由多个组件和容器组成的框架，所以第二空填写"JFrame
- DEFAULT_WIDTH, DEFAULT _ HEIGHT表示框架容器的宽和高，所以第三空填写”setSize"
- WelcomPanel是加入到JFrame的Pane1对象，所以第四空填写”JPanel"。
import javax.swing.*;
import java.awt.*;
public class Java_2{
public static void main(String[] args){
WelcomFrame frame = new WelcomFrame();
//*********Found**********
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE );
frame.setVisible(true);
}
}
//*********Found**********
class WelcomFrame extends JFrame {
public WelcomFrame(){
setTitle("Java等级考试");
//*********Found**********
setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
WelcomPanel panel = new WelcomPanel();
Container contentPane = getContentPane();
contentPane.add(panel);
}
public static final int DEFAULT_WIDTH = 250;
public static final int DEFAULT_HEIGHT = 100;
}
//*********Found**********
class WelcomPanel extends JPanel {
public void paintComponent(Graphics g){
super.paintComponent(g);
g.drawString("欢迎参加Java等级考试！",MESSAGE_X, MESSAGE_Y);
}
public static final int MESSAGE_X = 60;
public static final int MESSAGE_Y = 50;
}
考查JavaSwing
题目：
解析：
-
根据代码上下文可知，TimePrinter是 一个事件监听器类，用来输出当前时间，所以第一空填写TimePrinter
-
ActionListener是接口，所以第二空填写implements”
-
actionPerformed方法的参数是ActionEvent，所以第空填写ActionEvent
import java.awt.*;
import java.awt.event.*;
import java.util.*;
import javax.swing.*;
import javax.swing.Timer;
public class Java_2{
public static void main(String[] args){
//*********Found**********
ActionListener listener = new TimePrinter();
Timer t = new Timer(10000, listener);
t.start();
JOptionPane.showMessageDialog(null, "退出程序吗?");
System.exit(0);
}
}
//*********Found**********
class TimePrinter implements ActionListener{
//*********Found**********
public void actionPerformed(ActionEvent event){
Date now = new Date();
System.out.println("At the tone, the time is " + now);
Toolkit.getDefaultToolkit().beep();
}
}
考查JavaSwing
题目：
解析：
- JOptionPane属 于javax. swing包下的类，所以第一空填写”javax. swing”。
- JOptionPane. showInputDialog(“你想抽几位数?”)返回的是一个字符串，所以第二空填写”String’”
- 循环的次数是共有几个数， 所以第三空填写"k”。
- lottery0dds即中奖概率，所以第四空填写”lottery0dds”
//*********Found**********
import javax.swing.*;
public class Java_2{
public static void main(String[] args){
//*********Found**********
String input = JOptionPane.showInputDialog("你想抽几个数?");
int k = Integer.parseInt(input);
input = JOptionPane.showInputDialog("你想在自然数中抽的最大数是几?");
int n = Integer.parseInt(input);
int lotteryOdds = 1;
//*********Found**********
for (int i = 1; i <= k; i++)
lotteryOdds = lotteryOdds * (n - i + 1)/i;
//*********Found**********
System.out.println("你中奖的几率是1/" + lotteryOdds + ". Good luck!");
System.exit(0);
}
}
考查对Java语言中swing组件的掌握
题目;
解析：
- 本题中的第一个空格:在Java语 言中，JFrame为swing组件下的类，因此要引入swing包，因此此处空格填入swing;
- 本题中的第二个空格: DrawFrame 类的对象frame被创建后需要设置为可见才能在界面上显示，因此此处空格填入setVisible;
- 本题中的第三个空格: java中构造函数和类名一致， DrawFrame作 为一个类已经被使用，因此此处空格填入DrawFrame;
- 本题中的第四个空格: java中Swing组 件的窗体通常和组件的容器相关，所以在JFrame对象创建完成后，需要调用getContentPane()方法将窗体转换为容器，然后在容器中添加组件，因此此处空格填入getContentPane;
- 本题中的第五个空格:container转换为容器后就可以将drawpanel加进来，容器中添加panel- 般使用add方法，因此此处空格填入add;
- 本题中的第六个空格: DrawPanel继承 自JPanel，因此此处空格填入extends JPanel。
import java.awt.*;
import java.awt.geom.*;
//*********Found**********
import javax.swing.*;
public class Java_2
{
public static void main(String[] args)
{
DrawFrame frame = new DrawFrame();
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//*********Found**********
frame.setVisible(true);
}
}
//*********Found**********
class DrawFrame extends JFrame
{
public DrawFrame()
{
setTitle("千里共婵娟");
setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
DrawPanel panel = new DrawPanel();
//*********Found**********
Container contentPane = new getContentPane();
//*********Found**********
contentPane.add(panel);
}
public static final int DEFAULT_WIDTH = 400;
public static final int DEFAULT_HEIGHT = 240;
}
//*********Found**********
class DrawPanel extends JPanel
{
public void paintComponent(Graphics g)
{
super.paintComponent(g);
Graphics2D g2 = (Graphics2D)g;
double l = 0;
double r = 0;
double w = 400;
double h = 400;
Rectangle2D re = new Rectangle2D.Double(l,r,w,h);
g2.setPaint(Color.BLUE);
g2.fill(re);
double leftX = 50;
double topY = 50;
double width = 50;
double height = 50;
Rectangle2D rect = new Rectangle2D.Double(leftX, topY, width, height);
Ellipse2D ellipse = new Ellipse2D.Double();
ellipse.setFrame(rect);
g2.setPaint(Color.YELLOW);
g2.fill(ellipse);
}
}
考查对Java语言数组和文本框绘制的掌握
题目：
解析：
- 本题中的第一 个空格:由程序运行结果可以看出最终显示为文本区域，因此此处空格填入JTextArea;
- 本题中的第二个空格:容器初始化完成后要加入具体展示的内容，此处为创建好的JTextArea对象，因此此处空格填入outputArea;
- 本题中的第三个空格:要算出每个学生的平均分，需要以学生人数为最大值进行循环，因此此处空格填入students;
- 本题中的第四个空格:新建好的JTextArea对象需要设置显示的内容，使用setText 方法，因此此处空格填入setText;
- 本题中的第五个空格:所有的成绩放在二维数组grades中，因此要对每个二维数组的值进行比较后将最大值存入highGrade， 当二维数组值大于hi ghGrade时则将该值存入，因此此处空格填入grades[ i ][ j ];
- 本题中的第六个空格:计算平均分之前需要算好总分，要将每个学生的所有成绩相加，因此此处空格填入setOfGrades[i]。
import java.awt.*;
import javax.swing.*;
public class Java_2{
int grades[][] = { { 77, 68, 86, 73 },
{ 96, 87, 89, 81 },
{ 70, 90, 86, 81 } };
int students, exams;
String output;
JTextArea outputArea;
public Java_2(){
students = grades.length;
exams = grades[ 0 ].length;
JFrame f = new JFrame();
f.setSize(300,300);
f.setVisible(true);
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//*********Found**********
outputArea = new JTextArea();
Container c = f.getContentPane();
//*********Found**********
c.add( outputArea );
output = "数组是:";
buildString();
output += "\n\n最高分: " + maximum() + "\n";
//*********Found**********
for ( int i = 0; i < students; i++ )
output += "\n第" + (i+1) + "个学生的平均分是: " +
average( grades[ i ] );
//*********Found**********
outputArea.setText( output );
}
//找最高分
public int maximum(){
int highGrade = 0;
for ( int i = 0; i < students; i++ )
for ( int j = 0; j < exams; j++ )
if ( grades[ i ][ j ] > highGrade )
//*********Found**********
highGrade = grades[ i ][ j ];
return highGrade;
}
//对各组学生确定平均分
public int average( int setOfGrades[] ){
int total = 0;
for ( int i = 0; i < setOfGrades.length; i++ )
//*********Found**********
total += setOfGrades[i];
return total /exams;
}
//输出格式
public void buildString(){
output += " ";
for ( int i = 0; i < exams; i++ )
output += "[" + i + "] ";
for ( int i = 0; i < students; i++ ) {
output += "\ngrades[" + i + "] ";
for ( int j = 0; j < exams; j++ )
output += grades[ i ][ j ] + " ";
}
}
public static void main(String[ ]args){
new Java_2();
}
}
考查对按钮事件和布局的理解
题目：
解析：
- 本题中的第一个空格:新建按钮后需要对按钮设置监听，因此此处空格填入button. addActionListener;
- 本题中的第二个空格:新建按钮后需要对按钮设置监听，因此此处空格填入saveButton. addActionListener;
- 本题中的第三个空格: textArea为JTextArea类型，第一次使用之前需要创建对象，因此此处空格填入new;
- 本题中的第四个空格:图中button都在 界面的上部，因此在将按钮添加到frame的时候添加到上部，因此此处空格填入buttonPanel;
- 本题中的第五个空格:函数内部的程序是按钮的操作逻辑，因此此处是按钮的响应事件，actionPerformed是接收操作事件的监听器接口，因此此处空格填actionPerformed;
- 本题中的第六个空格:初始化采用init() 方法，因此此处空格填入init。
import javax.swing.*;
import java.awt.event.*;
import java.io.*;
import java.awt.*;
public class Java_2 implements ActionListener {
private JFrame frame;
private JButton button,saveButton;
private JTextArea textArea;
private JFileChooser dia;
private JPanel buttonPanel;
public void init() {
frame=new JFrame("file chooser");
dia=new JFileChooser();
button=new JButton("open file");
button.setActionCommand("open");
//*********Found**********
button.addActionListener(this);
saveButton=new JButton("save file");
//*********Found**********
saveButton.addActionListener(this);
buttonPanel=new JPanel();
buttonPanel.add(button);
buttonPanel.add(saveButton);
//*********Found**********
textArea=new JTextArea("",10,10);
//*********Found**********
frame.getContentPane().add(buttonPanel,BorderLayout.NORTH);
frame.getContentPane().add(textArea,BorderLayout.CENTER);
frame.setSize(300,300);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
}
//*********Found**********
public void ActionCommand(ActionEvent event) {
if(event.getActionCommand().equals("open"))
dia.showOpenDialog(frame);
else
dia.showSaveDialog( frame );
dia.setVisible(true);
File file=dia.getSelectedFile();
if (file!=null){
String fileName=file.getAbsolutePath();
textArea.append("path of selected file: "+fileName+"\r\n");
}
}
public static void main(String args[]){
Java_2 example=new Java_2();
//*********Found**********
example.init();
}
}
22、考查对Java语言基本语法以及函数等基本要素的掌握情况
题目：
生成1-20之间的- -个随机数并计算该随机数的阶乘，使输出结果形式如下(不一定完全相同) :
20! = 2432902008176640000
解析：
- 本题中的第一个空格: 在Java语言中，main函数必须使用static进行修饰，因此此处空格填入static;
- 本题中的第二个空格:在Java语言中， 生成0-1随机数使用random方法，因此此处填入random;
- 本题中的第三个空格:在Java语言中， 将浮点数变为整数可以使用Math. round();
- 本题中的第四个空格:循环中缺少计数器，K为循环变量，k自增1即可以满足跳出循环的要求，也可以作为阶乘的乘数，即此处空格填入k++。
import java.util.Random;
public class Java_2{
//*********Found**********
public static void main(String args[]){
Random random = new Random();
//*********Found**********
float x = random.nextFloat();//产生0.0与1.0之间的一个浮点数
//*********Found**********
int n = Math.round(21*x); //构造20以内的一个整数
long f = 1 ; //保存阶乘的结果
int k = 1 ; //循环变量
do {
//*********Found**********
f*= k++;
}while(k<=n);
System.out.println(n+"!= "+f);
}
}
23、考查对类的使用的理解
题目：
程序中定义了二维点的类，类中定义了包括点的平移在内的部分方法。完善
程序，使其运行时的输出结果如下:
点的当前坐标: (5， 5)
平移到: (8， 9)
解析：
本题中的第一个空格: p有两个参数: x和y，程序中有这两个参数的类只有Point,因此此处空格填入Point;
本题中的第二个空格: 由于是平移，因此对x和y坐标的改变应该是一致的，因此此处空格填入this.y += dy;
本题中的第三个空格: p为坐标为(5, 5)的新点，需要新建对象，因此此处空格填入Point;
本题中的第四个空格:输出结果为p平移之后的坐标值，
Point提供了toString()方法可以输出当前的坐标值，因此此处空格填入p. toString.
class Point{
public int x,y;
public Point() {
}
public Point(int x,int y){
this.x = x;
this.y = y;
}
//*********Found**********
public Point(Point p){
x = p.x;
y = p.y;
}
public int getX(){
return x;
}
public int getY(){
return y;
}
public void moveTo(int x,int y){
this.x = x;
this.y = y;
}
public void moveTo(Point p){
x = p.x;
y = p.y;
}
public String toString(){
return "("+ x + ","+ y + ")";
}
public void translate(int dx,int dy){ //平移
this.x += dx;
//*********Found**********
this.y += dy;
}
}
public class Java_2 {
public static void main(String args[]){
//*********Found**********
Point p = new Point(5,5);
System.out.println("点的当前坐标：("+p.x + "," + p.y+")");
p.translate(3,4);
//*********Found**********
System.out.println("平移到："+p.Point());
}
}
23、考查对题目要求的理解
题目：
解析：
本题中的第 一个空格:数组使用之前先对数组进行初始化，因此此处空格填入new;
本题中的第 二个空格:要查看当前字符串的缓存字符，查看程序中只有对buf作了缓存，因此此处空格填入buf;
本题中的第 三个空格:根据输出结果要求将第1位和第7位的字符进行更
改，因此此处空格填入charArray. length;
本题 中的第四个空格: output 是最终输出的字符串，因此要将更改好的字符串放到output中，因此此处空格填入output。
import javax.swing.*;
public class Java_2{
public static void main( String args[] ){
StringBuffer buf = new StringBuffer( "你好!祝你成功!" );
String output = "buf = " + buf.toString() +
"\nCharacter at 0: " + buf.charAt( 0 ) +
"\nCharacter at 4: " + buf.charAt( 4 );
//*********Found**********
char charArray[] = new char[ buf.length() ];
//*********Found**********
buf.getChars( 0, buf.length(), charArray, 0 );
output += "\n\n在字符串缓存中的字符是: ";
//*********Found**********
for ( int i = 0; i < charArray.length; ++i )
output += charArray[ i ];
buf.setCharAt( 0, '您' );
buf.setCharAt( 6, '材' );
//*********Found**********
output += "\n\nbuf = " + buf.toString();
buf.reverse( );
output += "\n\nbuf = " + buf.toString();
JOptionPane.showMessageDialog( null, output,
"字符串缓存的字符相关方法示范",
JOptionPane.INFORMATION_MESSAGE );
System.exit( 0 );
}
}
24、考查对Java语言类定义以及继承类的掌握
题目：
运行程序后，输出结果如下:
Name: Zhao Age: 20
Name: Wang Age: 18 School: Cambridge
解析：
- 本题中的第一个空格:将形参的值传递给类的成员变量，this. name .代表的就是对象中的成员变量，后面的name代表的就是形参，因此填入this. name;
- 本题中的第二个空格:将形参的值传递给类的成员变量，this. age代表的就是对象中的成员变量，后面的age代表的就是形参，因此填入this. age;
- 本题中的第三个空格:将形参的值传递给类的成员变量，this. name代表的就是对象中的成员变量，name因为没有引起重名，也是可以识别为成员变量，后面的n代表的就是形参，因此填name;
- 本题中的第四个空格:子类构造器的第一条语句一般是调用超类的构造器，完成实例域参数的初始化，一 般都会使用super关键字，因此填入super (name, age) :
- 本题中的第五个空格: Student 类需要覆盖Person类中的toString方法，但同时也需要调用Person类中的toString方法，因此在Student类中使用super. toString ()即可完用，因此填入super;
public class Java_2 {
public static void main(String[] args) {
Person p = new Person("Zhao",20);
Student s = new Student("Wang",18,"Cambridge");
System.out.println(p);
System.out.println(s);
}
}
class Person {
private String name;
private int age;
public Person(String name, int age) {
//*********Found********
this.name = name;
//*********Found********
this.age = age;
}
public void setName(String n) {
//*********Found********
name= n;
}
public String toString() {
return "Name: " + name + " Age: " + age;
}
}
class Student extends Person {
private String school;
public Student(String name, int age, String s) {
//*********Found********
super(name,age);
school = s;
}
public String toString() {
//*********Found********
return super.toString() + " School: " + school;
}
}
考查考生对Java语言线程的掌握
题目：
程序采用两种不同方式生成线程，使上面的5个线程输出5个1，使下面的5个线程输出1到5。
运行结果如下:
1
1
1
1
1
1
2
3
4
5
解析：
- 本题中的第一个空格:根据题干5个线程先输出5个1，即5个线程是独立的，因此继承的是Tread类，此处填入Thread;
- 本题中的第二个空格:每个线程相互独立，要想输出1，此处填入++x;
- 本题中的第三个空格:结合题干，每个线程的数值加1,输出语句中也是++x， 此处填入Runnable;
- 本题中的第四个空格:运行线程，此处填入run;
- 本题中的第五个空格:结合题干，输出5个数字，此处填入i<5;
- 本题中的第六个空格:线程定义完成后，启动线程使用start()方法，此处填入start;
import java.io.*;
import java.lang.Thread;
//**************found*****************
class MyThread extends Thread{
public int x = 0;
public void run(){
//**************found*****************
System.out.println(++x);
}
}
//**************found*****************
class R implements Runnable{
private int x = 0;
//**************found*****************
public void run(){
System.out.println(++x);
}
}
public class Java_2 {
public static void main(String[] args) throws Exception{
for(int i=0;i<5;i++){
Thread t = new MyThread();
t.start();
}
Thread.sleep(1000);
R r = new R();
//**************found*****************
for(int i=0;i< 6;i++){
Thread t = new Thread(r);
//**************found*****************
t.start();
}
}
}
考查对Java语言线程的掌握
题目：
程序的功能是:将-一个字符串数组中指定序号后的元素全部输出，如果指定的序号小于0，则序号被赋予0;如果指定的序号大于数组元素的最大序号，则序号被赋予最大的序号。
程序的运行结果如下:
one two three four five
解析：
- 本题中的第一个空格:根据Java_ 2类可以看出此处用线程的方式来实现，一 般情况下我们使用实现Runnable接口来实现线程，此处填入Runnable;
- 本题中的第二个空格: strings是一个字符串型的数组，对strings的类型定义应该为String[], 此处填入String[];
- 本题中的第三个空格:结合题干，如果指定的序号大于数组元素的最大序号，则序号被赋予最大的序号，此处填入strings. length-1;
- 本题中的第四个空格:线程要实现run方法，因此此处填入run;
- 本题中的第五个空格:结合题干，需要打印strings数组，因此要对ind进行自增，此处填入ind++;
- 本题中的第六个空格: t作为新开的线程，需要定义，p作为已经新建的对象可以作为参数传递，此处填入Threadt=new Thread( p );
//***************************Found*********************
class PrintStrings implements Runnable{
int ind = 0 ;
//***************************Found*********************
String[] strings = { "one", "two", "three", "four", "five"};
public PrintStrings( int n) {
if( n < 0)
n = 0;
else if ( n >= strings.length)
//***************************Found*********************
n = strings.length-1;
ind = n;
}
//***************************Found*********************
public void run( ){
while(ind < strings.length){
System.out.print(strings[ind] + " ");
//***************************Found*********************
ind++;
}
System.out.println();
}
}
public class Java_2{
public static void main(String[] args){
PrintStrings p = new PrintStrings(-1);
//***************************Found*********************
Thread t =new Thread(p);
t.start( );
}
}
考查对Java语言线程的掌握
题目：
下列程序包含了两个线程，分别打印字符串"Good Morning” 和”Hello”。程序某次运行的结果如下。请在横线处填入正确.的代码，使程序完整并能正确运行。
Good Morning0
Good Morning1
Main waiting for He1lo!
Hello0
Hello1.
Hello2
Hello3
Hello4
Good Morning2
Good Morning3
Good Morning4
解析：
- 本题中的第一个空格: 使用线程时，关键字extends对应的是类，因此此处填入Thread;
- 本题中的第 二个空格:根据题干，程序包含两个线程，因此此处应该再开一个线程，填入Java_ 2;
- 本题中的第三个空格:线程创建完成后需.要启动才能开始工作，因此此处填入t. start，();
- 本题中的第四个空格:根据注释，需要等待t线程运行完，因此此处填入t. join()，阻.
塞线程; - 本题中的第五个空格: 根据题干，只输出五组值，因此此处填入break;
- 本题中的第六个空格:线程的运行主体在run函数中，因此此处填入run();
//**********found**********
public class Java_2 extends Thread {
public static void main(String[ ] args) throws Exception{
int i=0;
//**********found**********
Thread t = new Java_2 ( );
//**********found**********
t.start();
while( true){
System.out.println("Good Morning"+ i++);
if (i == 2 && t.isAlive()){
System.out.println("Main waiting for Hello!");
//**********found**********
t.join(); //等待线程t运行结束
}
//**********found**********
if (i==5) break;
}
}
//**********found**********
public void run(){
int i =0;
while( true){
System.out.println("Hello"+ i++);
if (i==5) break ;
}
}
}
考查io流
题目：
下列程序的功能是:基于Java文件输入输出流技术，实现将in. txt文件的内容复制到out. txt文件中。
解析：
- 本题中的第一个空格: 使用FileInputStream类 读取硬盘中的文件in. txt，将其写入File0utputStream类定义的对象out中，所以第一空填写"in. txt";
- 本题中的第 二个空格:使用缓冲输入流和缓冲输出流实现文件的复制，将输入流中的数据通过缓冲输出流写入目标文件”out. txt"中，所以第二空写"BufferedOutputStream" ;
- 本题中的第三空: 新建一个byte型数组data，存放读取的数据，所以第三空填写"byte"
- 本题中的第四空: BufferedInputStream类中 的read()方法一次读取一个数组data，所以需要使用循环结构来判断是否到达文件的末尾，也就是当读取到的数据不为空时，执行循环将读取到的内容利用缓冲输出流写入文件，所以第四空写"while";
- 本题中的第 五空:使用close ()方法关闭缓冲输入输出流，所以第五空填bufferedOut;
- 本题中的第六空:在Java中可以通过try-catch-finally结构对异常进行捕获和处理，其中final1y块是个可选项， 所以第六空填写"catch’
import java.io.*;
public class Java_2 {
public static void main(String[] args) {
try {
//**********found**********
FileInputStream in = new FileInputStream("in.txt");
FileOutputStream out = new FileOutputStream("out.txt");
BufferedInputStream bufferedIn = new BufferedInputStream(in);
//**********found**********
BufferedOutputStream bufferedOut = new BufferedOutputStream(out);
//**********found**********
byte[] data = new byte[1];
//**********found**********
while(bufferedIn.read(data) != -1) {
bufferedOut.write(data);
}
bufferedOut.flush();
bufferedIn.close();
//**********found**********
bufferedOut.close();
//**********found**********
} catch (ArrayIndexOutOfBoundsException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
考查类的实例化
题目：
下列程序的功能是:图形的抽象类Figure，提供了计算图形面积的方法，并派生了圆和矩形的类，生成了三个图形的实例:
半径分别为1.0和2.0的两个圆，及边长为2.0和3.0的矩形，输出它们各自的面积。运行后的输出如下所示:
The area of figure 0 is:3. 141592653589793
The area of figure 1 is: 12.566370614359172
The area of figure 2 is:6. 0
解析：
- 本题中的第一-空:抽象类Figure中的area方法只有方法名，没有方法体，而方法的具体实现需要由该类的子类确定，可知是用关键字abstract声明的抽象方法area,所以此处填写abstract;
- 本题中的第二空:圆形类Circle继承父类Figure,重写了area()方法，这里的返回值是圆形的面积，已经定义了圆形的半径为r，所以此处填写r*r;
- 本题中的第三空:矩形类Rectangle继承父类Figure,重写了area()方法，这里的返回值是矩形的面积，已经定义了矩形的长宽分别为a和b,所以此处填写a*b;
- 本题中的第四空:在main函数中定 义了有三个元素的数组变量fig,分别代表半径为1的圆形、半径为2的圆形和边长为2.0和3.0的矩形，代表半径为1的圆形和半径为2的圆形已初始化，所以此处填写fig[2]=new Rectangle(2. 0,3. 0);
- 本题中的第五空: for循环执行结束后，分别输出半径为1的圆形、半径为2的圆形和边长为2.0和3.0矩形的面积，需要调用area()方法，所以此处填写fig[i]. area()。
import java.lang.*;
abstract class Figure {
//**********Found**********
public abstract double area();
}
class Circle extends Figure{
double r;
Circle(double r){
this.r=r;
}
public double area(){
//**********Found**********
return Math.PI*r*r;
}
}
class Rectangle extends Figure{
double a,b;
Rectangle(double a,double b) {
this.a=a;
this.b=b;
}
public double area() {
//**********Found**********
return a*b ;
}
}
public class Java_2 {
public static void main(String[] args){
Figure[] fig=new Figure[3];
fig[0]=new Circle(1.0);
fig[1]=new Circle(2.0);
//**********Found**********
fig[2] =newRectangle(2.0,3.0) ;
for(int i=0;i<3;i++)
//**********Found**********
System.out.println("The area of figure "+i+" is:"+fig[i]. area() );
}
}
考查对Java语言类的基本使用以及线程基本要
素的掌握
题目：
该程序的功能是:采用两个线程实现从银行某帐户取款的操作。己知帐户金额共计1000元，testAccount1线 程每次取款600元，testAccount2线程每次取款500元。 如果帐户金额不足，则提示“对不起,余额不足!”，并显示帐户余额。
运行结果如下:
被取走600.0元!
对不起，余额不足!
余额为:400.0元!
余额为:400.0元!
解析：
- 本题中的第一个空格: 根据题干意思，两个线程均完成取钱操作并打印余额，因此此部分功能可重用，题干中TestAccount1和TestAccount2为两个线程，均使用’private Accountaccount;"定义新的对象，因此公共的类名应该为"Account”，此处填写Account;
- 本题中的第二二个空格:根据题干意思，取完款原金额(即balance)会发生变化，money 表示被取走的钱，因此此处填写money;
- 本题中的第 三个空格:在Java语言中， 开启线程需要继承Thread，因此此处填写extends;
- 本题中的第四个空格:在Java语言中， 通过继承Thread类来.实现一个线程，继承以后，需要重载run()方法，因此此处填写run;
- 本题中的第五个空格:根据题干意思，TestAccount2也要 开启线程取钱，同样需要继承Thread类，因此此处填写Thread;
- 本题中的第六个空格:根据题干意思，testAccount2. start()启动了线程，因此此处填写testAccount2。
//**********Found**********
class Account {
private float balance = 1000;
public float getBalance() {
return balance;
}
public void setBalance(float balance) {
this.balance = balance;
}
public synchronized void withdrawals(float money) {
if (balance >= money) {
System.out.println("被取走" + money + "元!");
try{
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
//**********Found**********
balance -= money;
} else {
System.out.println("对不起,余额不足!");
}
}
}
//**********Found**********
class TestAccount1 extends Thread {
private Account account;
public TestAccount1(Account account) {
this.account = account;
}
//**********Found**********
public void run() {
account.withdrawals(600);
System.out.println("余额为:" + account.getBalance() + "元!");
}
}
//**********Found**********
class TestAccount2 extends Thread {
private Account account;
public TestAccount2(Account account) {
this.account = account;
}
public void run() {
account.withdrawals(500);
System.out.println("余额为:" + account.getBalance() + "元!");
}
}
public class Java_2 {
public static void main(String[] args) {
Account account = new Account();
TestAccount1 testAccount1 = new TestAccount1(account);
testAccount1.start();
//**********Found**********
TestAccount2 testAccount2 = new TestAccount2(account);
testAccount2.start();
}
}
考查对Java语言线程和类的基本用法的
掌握
题目：
该程序的功能是:创建了两个线程，分别打印当前日期和字符串"Hello”。
程序某次运行的结果如下所示。
in main:Hello! 0
in main:Hello! 1
Main waiting for date!
in date:tue Apr 02 16:09:11 CST 2019
in date:tue Apr 02 16:09:11 CST 2019
in date:tue Apr 02 16:09:11 CST 2019
in main:Hel1o! 2
in main:Hel1o! 3
in main:Hello! 4
解析：
- 本题中的第一个空格:根据题干意思，t是Java_ 2对象，t使用了start方法，则Java_ 2必须继承线程类Thread, 因此此处填写Thread;
- 本题中的第二个空格:在Java语言中， 类必须有构造函数，因此此处填写Java _2;
- 本题中的第三个空格:在Java语言中， 抛出异常使用throw和throws， 方法抛出的异常声明使用throws,因此此处填写throws;
- 本题中的第四个空格:根据题干意思，t是Java_ 2对象，因此此处填写Java_ 2;
- 本题中的第五个空格:根据题干意思，每次打印he1lo后的数字要自增1，因此此处填写i++;
- 本题中的第六个空格:根据题干意思，打印hel1o后的数字到5结束打印，需要退出线程才能停止打印，因此此处填写break.
import java.util.*;
//**********Found**********
class Java_2 extends Thread {
String name;
//**********Found**********
public Java_2( String n) {
name = n;
}
//**********Found**********
public static void main(String args[]) throws Exception {
int i = 0;
//**********Found**********
Java_2 t = new Java_2("date" );
t.start();
while( true){
//**********Found**********
System.out.println("in main: Hello! "+ i++);
if (i == 2 && t.isAlive()){
System.out.println("Main waiting for date!");
t.join( );
}
//**********Found**********
if (i==5) break ;
}
}
public void run() {
int i;
for (i=0;i<3; i++){
System.out.println("in "+name+": "+new Date());
}
}
}
考查对Java语言堆栈和类的基本用法的掌握
题目：
该程序的功能是: 定义了简单的字符堆栈类Mystack，堆栈大小为10，可实现互斥的压入和弹出操作。另外创建了两个线程分别向堆栈中压入字符和弹出字符，其中压入字符是随机生成的。.
解析：
- 本题中的第一个空格: 根据题干意思，压入和弹出操作是互斥的，因此使用同步锁的方式实现，因此此处填写synchronized;
- 本题中的第二个空格: 根据题干意思，data数组存储了所有的入栈的值，因此此处填写data[index]=c;
- 本题中的第三个空格: 根据题干意思，当index<=0时 停止出栈，index表示的是当前入栈值的数量，因此此处填写index–;
- 本题中的 第四个空格: c为随机数，根据题干意思，要将c入栈，因此此处应该填入push©;
- 本题 中的第五个空格: PopChar类中堆栈对象是通过参数传入的，因此若在线程中需要使用堆栈对象则需要将堆栈对象变为类可访问的对象，因此此处填写this. s=s;
- 本题中的第六个空格:根据题干意思，s是Mystack对象，因此此处
填写new Mystack()。
class Mystack
{
int index=0;
private char[] data=new char [10];
//**********Found**********
public synchronized void push(char c){
while(index>=10) {
try {
this.wait();
}catch(InterruptedException e) {
e.printStackTrace();
}
}
this.notifyAll();
//**********Found**********
data[index]=c ;
index++;
}
public synchronized char pop(){
while(index<=0) {
try {
this.wait();
}catch(InterruptedException e) {
e.printStackTrace();
}
}
this.notifyAll();
//**********Found**********
index--;
return data[index];
}
}
class PushChar extends Thread
{
Mystack s;
char c;
PushChar(Mystack s){
this.s=s;
}
public void run(){
System.out.println ("start push");
for (int i=0; i<20; i++){
c=(char)(Math.random()*26+'A');
//**********Found**********
s.push(c);
System.out.println("A:push "+c);
}
}
}
class PopChar extends Thread
{
Mystack s;
char c;
PopChar(Mystack s){
//**********Found**********
this.s=s;
}
public void run(){
System.out.println ("start pop");
for(int j=0;j<20;j++) {
c=s.pop();
System.out.println("B:pop "+c);
}
}
}
public class Java_2 {
public static void main (String[] args)
{
//**********Found**********
Mystack s=new Mystack() ;
PushChar a=new PushChar(s);
PopChar b=new PopChar(s);
a.start();
b.start();
}
}
考查对类的继承的掌握
题目：
该程序的功能是:使用继承类，输出柳树的相关信息。
程序运行结果如下:
柳树树根:
位置:土壤中
功能:吸收养份
柳树树干:
位置:地面
功能:传递养份
柳树树枝:
位置:树干上
功能:传递养份
柳树树叶: .
位置:树梢
功能:光合作用
颜色:绿色
形状:长形
柳树花:
哈哈，柳树没有花! !
解析：
- 本题中的第一个空格: 该条语句用来定义父类Tree，因此此处填写Tree;
- 本题中的第二个空格:根据题干, .子类有调用bolo方法，在父类中定义，因此此处填写bolo;
- 本题中的第 三个空格:根据程序, .子类中不存在print方法，需在父类定义，因此此处填写print;
- 本题中的第四个空格: main() 中定义了Java_ 2的对象o，因此此处填写extends;
- 本题中的第 五个空格: main()中调用了flower方法，因此此处填写flower;
- 本题中的第六个空格:这里需要使用new关键字，因此此处填写new。
//**********Found**********
class Tree {
public void root(){
String sSite = "土壤中";
String sFunction = "吸收养份";
print("位置："+sSite);
print("功能："+sFunction);
}
//**********Found**********
public void bolo(){
String sSite = "地面";
String sFunction = "传递养份";
print("位置："+sSite);
print("功能："+sFunction);
}
public void branch(){
String sSite = "树干上";
String sFunction = "传递养份";
print("位置："+sSite);
print("功能："+sFunction);
}
public void leaf(){
String sSite = "树梢";
String sFunction = "光合作用";
String sColor = "绿色";
print("位置："+sSite);
print("功能："+sFunction);
print("颜色："+sColor);
}
//**********Found**********
public void print(Object oPara){
System.out.println(oPara);
}
}
//**********Found**********
class Java_2 extends Tree{
public void leaf(){
super.leaf();
String sShape = "长形";
super.print("形状："+sShape);
}
//**********Found**********
public void flower(){
print("哈哈，柳树没有花！！");
}
public static void main(String[] args){
//**********Found**********
Java_2 o = new Java_2();
o.print("柳树树根：");
o.root();
o.print("柳树树干：");
o.bolo();
o.print("柳树树枝：");
o.branch();
o.print("柳树树叶：");
o.leaf();
o.print("柳树花：");
o.flower();
}
}
基本操作
考查Applet的使用
题目：
解析：
涉及到对继承知识点的考查。
在Java中， 我们可以声明一个类扩展(extends) 另一个类，即继承。继承使得一个类能够使用另一个类的属性和方法，就象使用自己的属性和方法一样。例如本题要求
填写的是继承Applet类，这是因为类Java_ 1需要使用Applet类的方法paint。
//*********Found********
import java.applet.*;
import java.awt.Graphics;
//*********Found********
public class Java_1 extends Applet {
public void paint( Graphics g )
{
//*********Found********
g.drawString( "欢迎你来参加Java 语言考试!", 25, 25 );
}
}
考查按位异或运算符
题目：
对Java_ 1. java文件进行完善并调试，使程序输出的结果如下:
b的结果是: 5
解析：
- 每个程序开始都有public class 类名，所以第一空填class
- 为防止计算机高低字节存储顺序不同，通常用byte类型来表示数据可以避免出错。通过语句"b=(byte) (b^ c) ;“可以知道，变量b的输出结果是变量c与10 (二进制表00001010)按位异或运算的结果，题面要求输出结果为”b的结果是: 5”，那么可知:C=00001010-00000101， 按位异或运算符的作用是，两个操作数中，如果两个相应位相同，则结果为0，否则为1，由此可以推算出c=00001010 00000101=00001111， 转换为十进制数为15，第二空填"0X000f”。
- 最后要输出b的结果，所以第三空填”+b”。
//*********Found**********
public class Java_1{
public static void main(String args[]) {
byte b = 10; // 二进制表示00001010 异或 00001111 =00000101
//*********Found**********
byte c = 15;
b = (byte)(b ^ c);
//*********Found**********
System.out.println("b的结果是："+ b);
}
}
考查字符串操作
题目：
对Java_1.java文件进行完善并调试，使程序的输出结果如下:字符串"现在学习如何访问一个字符串"
字符串长度:13
其中第7个字符是:访
从字节数组的第7到12获取字符是:访问一个字符
public class Java_1{
//*********Found**********
public static void main(String args[]){
String string="现在学习如何访问一个字符串";
System.out.println("字符串 \""+string+"\"");
//*********Found**********
System.out.println("字符串长度："+string.length());
//*********Found**********
System.out.println("其中第7个字符是："+string.charAt(6));
char sub[] = new char[20];
System.out.print("从字节数组的第7到12获取字符是：");
string.getChars(6,12,sub,0);
System.out.println(sub);
}
}
解析：
- 文件开始定义mina函数，所以第一空填"main"。
- String类中常用的成员方法中，方法length()的功能是返回字符串的长度，所以第二空
填"string.length()"。 - charAt()方法返回指定索引处的char值。索引范围是从0到length() - 1，所以第三空填"charAt"。
考查输入输出流
题目：
对该程序进行调试，使程序能够判断所输入的年份是否闰年。
解析：
- 将java.io包里的所有接口或类都导入到javaBean中，所以第一问填"io"。
- 为了明确指出一个方法不捕获某类异常，而让调用该方法的其他方法去捕获该类异常，可以在声明方法时，使用throws可选项，以抛出该类异常，根据程序第一空后的Exception可知，第二空填"throws"。
- System类是一个特殊类，它是一个final类，所有的方法都用类变量来调用，即对System类不能实例化，它主要提供了标准输入输出和系统环境的访问、设置。其中，它的属性"public static final InputStream in"表示标准输入，所以第三空填"in"。
- 变量year为int类型，变量s为String类型，如果要将变量s赋值给变量year，必须先将变量s转换为int类型，所以第四空为"s"。
//*********Found**********
import java.io.*;
public class Java_1{
//*********Found**********
public static void main(String[] args) throws Exception{
InputStreamReader ir;
BufferedReader in;
ir=new InputStreamReader(System.in);
in=new BufferedReader(ir);
System.out.println("输入年份是:");
//*********Found**********
String s=in.readLine();
//*********Found**********
int year=Integer.parseInt(s);
if(year%4==0&&year%100!=0||year%400==0){
System.out.println(""+year+"年是闰年.");
}
else{
System.out.println(""+year+"年不是闰年.");
}
}
}
考查流程控制
题目：
程序的功能是:从键盘输入5个整数，计算并打印所输入数中的偶数之和。例如:输入
1
2
3
4
5
则屏幕显示:偶数之和为6
解析：
- io是input out输入输出流，所以第一空填"io"。
- 程序定义变量sum的作用是存放偶数之和，需要先给其赋初值0，所以第二空填"sum=0"。
- 当从键盘输入5个数之后，需要通过循环语句将其读入，并转换成int类型依次赋值给变量x，所以第三空填"i<=5"”。
- 由于程序要求"计算并打印所输入数中的偶数之和"，那么第三空所在的if语句的作用就是判断输入的数是否为偶数，所以第四空为"x%2==0"。
//*********Found**********
import java.io.*;
public class Java_1 {
public static void main(String[ ] args) throws IOException {
InputStreamReader ir;
BufferedReader in;
int sum, x;
String data;
//*********Found**********
_______________;
ir = new InputStreamReader(System.in);
in = new BufferedReader(ir);
System.out.println("请输入5个整数：");
//*********Found**********
for (int i = 1; i<=5; i++) {
data = in.readLine();
x = Integer.parseInt(data);
//*********Found**********
if (x%2==0)
sum += x;
}
System.out.println("偶数之和为"+ sum );
}
}
考查流程控制
题目：
程序的功能是:从键盘输入5个正整数，输出其中的最大值。例如:从键盘输入
10
30
50
20
40
则屏幕显示
输入的最大值是50
解析：
- 当从键盘输入5个数之后，需要通过循环语句将其读入，并转换成int类型依次赋值给变量x，所以第一空填"i<=5"。
- Integer类的静态方法parseInt()的作用是将其它数据类型转换成整型，所以第二空填"parseInt"。
- 通过语句“if ( max < x )”可知，第三空是将if语句对比出的较大的整数赋值给变量max，所以第三空为"max=x"。
具体程序如下:
import java.io.*;
public class Java_1 {
public static void main(String[ ] args) throws IOException {
InputStreamReader ir;
BufferedReader in;
int max, x;
String data;
max = 0;
ir = new InputStreamReader(System.in);
in = new BufferedReader(ir);
System.out.println("请输入5个正整数：");
//*********Found**********
for (int i = 1; i<=5; i++) {
data = in.readLine();
//*********Found**********
x = Integer.parseInt(data);
if ( max < x )
//*********Found**********
max=x;
}
System.out.println("输入的最大值是 "+ max);
}
}
考查for循环语句
题目：
该程序的功能是:打印如下图形。
*
***
*****
*******
*********
解析：
- 因为打印输出的图形是5行，所以第一空填"i<=5"。
- 图形是空格和*组成，所以第二空填"System. out.print(" “)”。
- 内层循环j从1开始，所以第三空填"int j=1”。
- 每行输出后需要换行，所以第四空填"Svstem.out.println()"。
public class Java_1 {
public static void main(String[] args) {
//*********Found**********输出5行
for (int i=1;i<=5;i++){
for(int k=1;k<=5-i;k++)
//*********Found********** 图形是输出*和空格
System.out.print("");
//*********Found**********
for(int j=1;j<=2*i-1;j++)
System.out.print("*");
//*********Found**********换行
System.out.println();
}
}
}
考查输出流
题目：
该程序的功能是把一个数按逆序输出。运行结果如下
:2008 —> 8002
解析：
- 题目输出内容为原数据+"->"，所以第一空为"+"->""。
- 题面输出内容实际上是数据的千位数和个位数交换，原数据2008的个位数"8"可由原数据对10求余得到，所以第二空填"x%10"。
- 原数据2008的千位数"2"可由原数据对10整除得到，所以第三空填"x/10"。
public class Java_1 {
public static void main(String[] args) {
int a,x = 2008;
//*********Found**********
System.out.print( x + "->" );
while( x != 0 ){
//*********Found**********
a = x%10;
System.out.print(a);
//*********Found**********
x = x/10;
}
}
}
考查多维数组
题目：
解析：
- 由于程序中，第三个循环周期结束，即完成对一个元素的赋值，那么，在对下一个元素赋值前，需要将该元素的值初始化为0，所以第一空填"0"。
2. 程序中的第一个for循环是控制数组c的行数，第二个for循环是控制数组c的列数，而第三个for循环则是为二维数组c的元素值 - 根据题面中给出的输出结果可知，二维数组c相当于一个2行4列的矩阵，所以，第二空填"0"，第三空填"3"。
public class Java_1 {
public static void main(String args[]) {
int a[][] = {{2, 3, 4}, {4, 6, 5}};
int b[][] = {{1, 5, 2, 8}, {5, 9, 10, -3}, {2, 7, -5, -18}};
int c[][] = new int[2][4];
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 4; j++) {
//*********Found********
c[i][j] = 0;
//*********Found********
for (int k = 0; k < 3; k++)
//*********Found********
c[i][j] += a[i][k]*b[k][j];
System.out.print(c[i][j] + " ");
}
System.out.println();
}
}
}
考查对JavaSwing的理解
题目：
解析：
- 题目要求判断输入结果，1为通过2为不通过，输入结果为input，所以第一空填写"input"。
- 提示框用showMessageDialog即可展现在Panel中，所以第二空填写"showMessageDialog"。
- 最后需要退出程序，所以第三空填写"exit"。
import javax.swing.JOptionPane;
public class Java_1 {
public static void main( String args[] ){
//变量初始化
int passes = 0, //考生通过的数目
failures = 0, //考生不通过的数目
student = 1, //学生计数器
result; //一门考生结果
String input, //用户输入的值
output; //输出字符串
//处理10名学生,用计数器控制循环
while ( student <= 10 ) {
input = JOptionPane.showInputDialog(
"输入结果(1=通过,2=不通过)" );
//*********Found**********
result = Integer.parseInt( input );
if ( result == 1 )
passes = passes + 1;
else
failures = failures + 1;
student = student + 1;
}
//结果处理
output = "通过: " + passes +
"\n不通过: " + failures;
if( passes > 8 )
output = output + "\n提高学费";
//*********Found**********
JOptionPane.showMessageDialog( null, output,
"对考试结果的分析示例",
JOptionPane.INFORMATION_MESSAGE );
//*********Found**********
System.exit( 0 );
}
}
考查变量初始化
题目：
计算并打印1,3,5,7的阶乘以及这些阶乘的和。完成程序，使程序输出结果如下:
1!=1
3!=6
5!=120
7!=5040
sum=5167
解析：
- Long sum;这段代码中，并没有给sum赋值，而后面的代码中却将sum进行了计算，这样一来则会报错，所以第一空填写"sum = 0"。
- 本例中要求的是阶乘，第一层循环中定义了b = 1，第二层循环中定义了j小于等于i，所以第二空填空"i"
- b为阶乘结果，所以第三空填写"b = b *j"。
public class Java_1
{
public static void main(String[] args)
{
long sum;
//*********Found**********
sum=0;
for(int i=1;i<8;i+=2){
long b=1;
//*********Found**********
for(int j=1; j<=i; j++)
//*********Found**********
b=b*j;
System.out.println( i + "!= " + b);
sum+=b;
}
System.out.println("sum=" + sum);
}
}
考查JavaSwing
题目：
解析：
- 由代码上下文可知，outputTextArea是一个JTextArea对象，所以第一空填写“JTextArea”。
- precisionTwo是具体数值，根据题目要求保留两位小数，所以第二空填写“format”。
- 最终程序需要以窗口形式展示，所以第三空填写“showMessageDialog”。
//Interest.java
//计算复杂利息
import java.text.DecimalFormat;
import javax.swing.JOptionPane;
import javax.swing.JTextArea;
public class Java_1{
public static void main( String args[] ){
double amount, principal = 1000.0, rate = .05;
DecimalFormat precisionTwo = new DecimalFormat( "0.00" );
//*********Found**********
JTextArea outputTextArea = new JTextArea( 11, 20 );
outputTextArea.append( "年\t存款总计\n" );
for ( int year = 1; year <= 10; year++ ) {
amount = principal * Math.pow( 1.0 + rate, year );
outputTextArea.append( year + "\t" +
//*********Found**********
precisionTwo.format( amount ) + "\n" );
}
//*********Found**********
JOptionPane.showMessageDialog(
null, outputTextArea, "复合利息",
JOptionPane.INFORMATION_MESSAGE );
System.exit( 0 );
}
}
扫一扫
2247
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
