Java 练习题 含答案

Java 练习题

一、 填空题

（1）Java语言具有许多优点和特点，下列选项中，哪个反映了Java程序并行机制的特点？（ B ）

A)安全性 B)多线性 C)跨平台 D)可移植

（2）下列哪个类声明是正确的？( D )。

A)abstract final class HI{···｝ B)abstract private move(){···} C)protected private number; D)public abstract class Car{···} （3）下列关于for循环和while循环的说法中哪个是正确的？( A )。 A)while循环能实现的操作，for循环也都能实现

B)while循环判断条件一般是程序结果，for循环判断条件一般是非程序结果 C)两种循环任何时候都可替换

D)两种循环结构中都必须有循环体，循环体不能为空 （4）异常包含下列那些内容？( C )。 A)程序中的语法错误 B)程序的编译错误

C)程序执行过程中遇到的事先没有预料到的情况 D)程序事先定义好的可能出现的意外情况 （5）Character流与Byte流的区别是 ( C )。 A)每次读入的字节数不同 B)前者带有缓冲，后者没有

C)前者是块读写，后者是字节读写 D)二者没有区别，可以互换使用 （6）监听事件和处理事件 ( B )。

A)都由Listener完成 B)都由相应事件Listener处登记过的构件完成 C)由Listener和构件分别完成 D)由Listener和窗口分别完成 （7）Applet可以做下列那些操作？ ( A )。 A)读取客户端文件 B)在客户端主机上创建新文件 C)在客户端装载程序库 D)读取客户端部分系统变量 （8）下列哪个属于容器的构件？ ( A )。 A)JFrame B)JButton C)JPnel D)JApplet

(9)如果希望所有的控件在界面上均匀排列，应使用下列那种布局管理器？ A)BoxLayout B)GridLayout C)BorderLayout D)FlowLouLayout

(10)为实现多线程之间的通信，需要使用下列那种流才合适？( D )。 A)Filter stream B)File stream C)Random access stream D)Pipde stream

（11）编译Java Application 源程序文件将产生相应的字节码文件，这些字节码文件的扩展名为( B )。

A..java B..class C. .html D. .exe

(12)设 x = 1 , y = 2 , z = 3，则表达式 y＋＝z－－/＋＋x 的值是( 啊 )。 A. 3 B. 3. 5 C. 4 D. 5

(13)在Java Applet程序用户自定义的Applet子类中，一般需要重载父类的( D )方法来完成一些画图操作。

A. start( ) B. stop( ) C. init( ) D. paint( ) (14)不允许作为类及类成员的访问控制符的是( C )。

A. public B. private C. static D. protected

(15)为AB类的一个无形式参数无返回值的方法method书写方法头，使得使用类名AB作为前缀就可以调用它，该方法头的形式为( A )。

A. static void method( ) B. public void method( ) C. final void method( ) D. abstract void method( ) （16）在Java中，所有类的根类是( A )。

A．java.lang.Object B．java.lang.Class C．java.applet.Applet D．java.awt.Frame （17）在Java中，用Package语句说明一个包时，该包的层次结构必须是( B )。 A．与文件的结构相同 B．与文件目录的层次相同 C．与文件类型相同D．与文件大小相同 （18）在读字符文件Employee.dat时，使用该文件作为参数的类是( D )。 A．BufferReader B．DataInputStreamC．DataOutoutStream D．FileInputStream （19）下列构造方法的调用方式中，正确的是 ( C )。

A．按照一般方法调用 B．由用户直接调用 C．只能通过new自动调用 D．被系统调用 （20）类Panel默认的布局管理器是 ( C )。

A．GridLayout B．BorderLayout C．FlowLayout D．CardLayout （21）在Java中，能实现多重继承效果的方式是( C )。 A．内部类 B．适配器 C．接口 D．同步 （22）char类型的取值范围是 ( A )。

A．-2^7 ~2^7 -1 B．0~216-1 C．-215 ~215 -1 D．0~28-1 （23）能够支持javadoc命令的注释语句是 ( D )。 A．/**...// B．/*...*/ C．// D．/**...*/

（24）十进制数16的16进制表示格式是 ( A )。 A．0x10 B．0x16 C．0xA D．16

（25）int型public成员变量MAX_LENGTH，该值保持为常数100，则定义这个变量的语句是( D )。

A．public int MAX_LENGTH=100 B．final int MAX_LENGTH=100

C．public const int MAX_LENGTH=100 D．public final int MAX_LENGTH=100

（27）下列方法中可以用来创建一个新线程的是 ( C )。 A．实现java.lang.Runnable接口并重写start()方法 B．实现java.lang.Runnable接口并重写run()方法 C．实现java.lang.Thread类并重写run()方法 D．实现java.lang.Thread类并重写start()方法

（28）下列关于Java Application与Applet的说法中，正确的是( C )。 A．都包含main()方法

B．都通过“appletviewer”命令执行 C．都通过“javac”命令编译 D．都嵌入在HTML文件中执行

（29）当启动Applet程序时，首先调用的方法是( B )。 A．stop()B．init()C．start()D．destroy()

（30）下列关于线程优先级的说法中，正确的是( D )。 A．线程的优先级是不能改变的

B．线程的优先级是在创建线程时设置的 C．在创建线程后的任何时候都可以设置 D．B和C

（31）当浏览器重新返回Applet所在页面时，将调用Applet类的方法是 ( C )。

A．start() B．init() C．stop() D．destroy()

（32）按照Java的标识符命名规范，下列表示一个类的标识符正确的是 ( A )。A．Helloworld B．HelloWorld C．helloworld D．helloWorld （33）下列代码中，将引起一个编译错误的行是 ( D )。 1）public class Test{ 2） int m,n;

3） public Test() {}

4） public Test(int a) {m=a;}

5） public static void main(String args[]){ 6） Test t1,t2; 7） int j,k; 8） j=0;k=0;

9） t1=new Test(); 10） t2=new Test(j,k); 11） } 12）} A．第3行 B．第5行 C．第6行 D．第10行 （34）下列程序的功能是在监控台上每隔一秒钟显示一个字符串“Hello”,能够填写在程序中下划线位置，使程序完整并能正确运行的语句是 ( D )。 public class Test implements Runnable{ public static void main(String args[]){ Test t=new Test();

Thread tt=new Thread(t); tt.start(); }

public void run(){ for(;;){ try{ ;

}catch( e){}

System.put.println(\} } }

A． sleep(1000)

InterruptedException B． sleep(1000)

InterruptedException C． Thread.sleep(1000) RuntimeException

D． Thread.sleep(1000)

InterruptedException （35）阅读下列代码后 public class Person{ int arr[]=new int[10];

public static void main(String args[]){ System.out.println(arr[1]); } }

正确的说法是( A )。

A． 编译时将产生错误 B． 编译时正确，运行时将产生错误 C． 输出零 D． 输出空

（36）在Java中，负责对字节代码解释执行的是（ B ）。 A．垃圾回收器 B．虚拟机 C．编译器 D．多线程机制 （37）下列叙述中，正确的是( A )。 A．Java语言的标识符是区分大小写的 B．源文件名与public类名可以不相同 C．源文件扩展名为.jar

D．源文件中public类的数目不限

（38）下列属于合法的Java标识符是( A )。 A．_cat B．5books C．+static D．-3.14159 （14）在Java中，表示换行符的转义字符是( A )。 A．\\n B．\\f C．'n' D．\\dd （39）在Java中，由Java编译器自动导入，而无需在程序中用import导入的包是( D )。A．java.applet B．java.awt C．java.util D．java.lang

40、给定java代码如下，运行时，会产生（ B ）类型的异常。 String s＝null； s.concat（“abc”）；

A.ArithmeticException B.NullPointerException C.IOException D.EOFException

41、在Java中，在包com.db下定义一个类，要让包com.util下的所有类都可以访问这个类，这个类必须定义为（ C ）。

A．protected B．private C．public D．friendly 42、给定如下java代码，编译运行之后，将会输出（ D ）。 public class Test{

public staticvoid main（String args[]）{ int a=5;

System.out.println( (a%2==1) ? (a+1)/2 : a/2 ) ； } }

A．1 B．2 C．2.5 D．3

43、以下Java语句中，String str = “123456789”;str =str.subString(1,3);执行后str中的值为。（ A ）

A． “23” B． “123” C．“12” D．“234”

44、在使用interface声明一个接口时，只可以使用（ D ）修饰符修饰该接口。

A．private B．protected C．private protected D．public 45、如要抛出异常，应用下列哪种子句？（ B ）

A．catch B．throws C．try D．finally 46、给定如下java代码，编译时会在（ D ）出现错误。 class Parent{ }

class Child extends Parent{

public static void main（String args[]）{ Parent p1=new Child() ；//第一行 Parent p2=new Parent () ；//第二行 Child c1=new Child() ；//第三行 Child c2=new Parent () ；//第四行 } }

A． 第一行 B． 第二行 C．第三行 D． 第四行 47、为了使包sos在当前程序中可见，可以使用的语句是( A )。

A.import sos.*; B.package sos.*; C.sos import; D.sos package; 48、给定如下java代码，以下（ D ）代码行编译会报错。 class MyClass{

void myMethod（final int p）{ final int il; final int i2=p; i1=20; i2=20; } }

A. il=20; B. final int il; C.final int i2=p D. i2=20; 49、在java中，在尝试对null 对象操作时，会产生（ B ）类型的异常。 A. ArithmeticException B. NullPointerException C. IOException D. EOFException

50、在使用interface声明一个接口时，只可以使用___D _修饰符修饰该接口。

A．private B．protected C．private protected D．public

51、编写和运行Java applet程序与编写和运行Java application程序不同的步骤是( B )。

A.编写源代码 B.编写HTML文件调用该小程序，以.html为扩展名存入相同文件夹 C.编译过程 D.解释执行

二、填空题

（1）对象串行化可以很容易地扩展成支持Java对象的(持续存储或持久存储 )，它提供了对象从流中重建的补充方式.

（2）Vector类的对象是通过capacity和capacityIncrement两个值来改变集

合的容量，其中capacity表示集合最多能容纳的( 元素个数 )，capacityIncrement表示每次增加多少容量，不是一个一个增加. （3）下列程序的功能是判断某一年是否为闰年.请在横线处填入适当内容，使程序能够正确运行. import java.io.*;

public class LeapYear{

public static void main(String arge[])throws IOException{ InputStreamReader ir; BufferdeReadwe in;

ir=new InputStreamReader(System.in); in=new BufferedReader(ir);

System.out.println(“输入年份是：”）； ？？？？String s= ( in.readLine() ); int year=Integer.parseInt(s);

if （year % 4 = = 0 && year % 100! = 0 // year % 400 = = 0) {

System.out.println(\年是闰年.\} else {

System.out.println(\年不是闰年..\} } }

（4）下面程序对数组中每个元素赋值，然后按逆序输出.请在横线处填入适当内容，使程序能正常运行. import java.io.*;

public class ArrayTest{

public static void main(String args[]){ int i;

int a[] = new int[5]; for(i=0;i<5;i++) a[i]=i;

？？？？for(( i=a.length-1 ) ;i>=0;i- -) System.out.println(\} }

（5） 下列程序的功能是：输入一个姓名，程序运行后，输出“姓名Welcome you!”.例如，输入“张三Welcome you !”.请在下面横线处填入正确的方法名，使程序可以正确运行. import java,awt,*;

import java.awt.event.*; public class welcomenYou{

public static void main(String args[]) {

new FrameInOut(); } }

class FrameInOut extends Frame implements ActionListener {

Label prompt;

TextField input,output; Button btnn; void FramInOut() {

prompt=new Label(\input=new TextField(10); output=new TextField(25); btnn=new Button(\

？？？？( setLayout ) (new FlowLayout()); add(prompt); add(input); add(output); add(btnn);

input.addActionListener(this); btnn.addActionListener(this); setSize(300.200); show(); }

public void actionperformed(ActionEvent e) {

if(e.getSource() = = input)

output.setText(input.getText()+\else {

dispose();

system.exit(0); } } }

(6)开发与运行Java程序需要经过的三个主要步骤为( 编辑源程序 )、( 编译生成字节码 ) 和( 解释运行字节码)。

(7)如果一个Java Applet源程序文件只定义有一个类，该类的类名为MyApplet，则类

MyApplet必须是( Applet )类的子类并且存储该源程序文件的文件名为( MyApplet ) 。

(8)如果一个Java Applet程序文件中定义有3个类，则使用Sun公司的JDK编译器( java.exe )编译该源程序文件将产生( 3 )个文件名与类名相同而扩展名为( .class ) 的字节码文件。 (9)在Java的基本数据类型中，char型采用Unicode编码方案，每个Unicode码占用( 2 )字节内存空间，这样，无论是中文字符还是英文字符，都是占用( 2 )字节内存空间。 (10)设 x = 2 ，则表达式 ( x + + )／3 的值是( 0 )。 (11)若x = 5，y = 10，则x < y和x >= y的逻辑值分别为( true )和 ( false ) 。 (12) ( 抽象（abstract) )方法是一种仅有方法头，没有具体方法体和操作实现的方法，该方法必须在抽象类之中定义。( 最终（final) )方法是不能被当前类的子类重新定义的方法。

(13)创建一个名为 MyPackage 的包的语句是( package MyPackage; )，该语句应该放在程序的位置为：( 整个程序的第一行 )。

(14)设有数组定义：int MyIntArray[ ] = { 10 , 20 , 30 , 40 , 50 , 60 , 70}; 则执行以下几个语句后的输出结果是( 120 ) 。 int s = 0 ;

for ( int i = 0 ; i < MyIntArray.length ; i + + )

if ( i % 2 = = 1 ) s += MyIntArray[i] ; System.out.println( s );

(15)在Java程序中，通过类的定义只能实现( 单 )重继承，但通过接口的定义可以实现( 多 )重继承关系。

(16) Java源文件中最多只能有一个( public或公共 )类，其它类的个数不限。 (17)在Java中所实现的多维数组，实际上是由一维数组构成的( 数组 或 Array 或 数组的数组)。

(18)StringBuffer类提供( 可变 )字符串对象的表示。 (19)每个Applet程序必须有一个类是 ( Applet )类的子类。 (20)线程在生命期中要经历5种状态，分别是新建状态、可运行状态、运行状态、( 阻塞 )状态和终止状态。

(21)FileInputStream是字节流；BufferedWriter是字符流；ObjectOutputStream是( 对象流)。

(22)break语句最常见的用法是在switch语句中，通过break语句退出switch语句，使程序从整个switch 语句后面的 ( 第一行语句 ) 开始执行。

(23)请阅读下列程序代码，然后将程序的执行结果补充完整。 public class throwsException { static void Proc(int sel)

throws ArithmeticException,ArrayIndexOutOfBoundsException{ System.out.println(\if(sel==0){

System.out.println(\return;

}else if(sel==1){

int iArray[]=new int[4]; iArray[1]=3;

} }

public static void main(String args[]){ try{ Proc(0); Proc(1);

}catch(ArrayIndexOutOfBoundsException e){ System.out.println(\}finally{

System.out.println(\} }

执行结果：

In Situation0 no Exception caught In Situation1 in Proc finally

(24)当使用Thread t=new Thread(r)创建一个线程时，表达式：r instanceof Thread的值为( false ) 。

25. 当用户在TextField中输入一行文字后，按回车，实现（ 接听器（ActionListioner ）接口可实现对事件的响应。

26.（ final(最终） ）方法是不能被当前类的子类重新定义的方法。

27.顺序执行以下两个语句的输出结果是（ 10 ）。 String s=”我喜欢学习Java!”; System.out.println(s.length());

28．恰当的注释增强了程序的可读性与( 可维护性 )。 29、Java语言中，String str=“123456789”；System.out.println(str.indexOf(“5”)),输出结果为（ 4 ）。

30、包含Swing构件的Applet（小应用程序）应该是( Applet )类的子类。 31、以下方法 m 的功能是求两参数之积的整数部分。 int m ( float x, float y )

{ ( retrne int(x*y); ); }

32、声明并创建类MyClass的一个对象，其名称为obj，可通过以下语句实现：（ ）。

三、判断题

T 1.Java中的的字符使用的是 16 位的Unicode 编码。 T 2.类是同种对象的集合和抽象。 F 3.Java 仅支持类间的单重继承。

T 4.接口是由常量和抽象方法组成的特殊类。 F 5.构造函数的方法名可由编程人员任意命名。 F 6.使用静态属性必须以类名做前缀。

F 7.类的私有属性和私有方法可以被其子类访问。

F 8.abstract 是抽象修饰符，可以用来修饰类及其属性和方法。 T 9.Java 支持多线程机制。

F 10.一个 Java 源程序中允许有多个公共类。

F 11.Java 程序可以划分为两大类: Application 和 Applet。 F 12.for 语句中的循环体不能是空的。 T 13.子类不能继承父类的构造函数。

F 14.重载的方法可以通过它们的返回值类型的不同来区分。 T 15.数组一定占用连续的内存空间。

F 16.Java 和 c++都是面向对象的程序设计语言。( ) F 17.字符串 \的长度是5。( )

T 18. 同一个类中定义多个参数列表不同的同名方法,叫做方法的重载。( ) ?F 19. 一个类的定义包括定义类头和定义类体两个部分。( ) F 20.一个程序里可以有多个父类，也可以有多个主类。( )

T 21. 一个子类可以重新定义从父类那里继承来的同名方法，而且允许它们有不同的返回 值。( )

T 22.抽象方法只能存在于抽象类中。( )

F 23. 在父类中声明为 final 的方法，也可以在其子类中被重新定义(覆盖)。( ) T 24. 接口中所有方法均为抽象方法。( ) F 25. False 是合法的 Java 标识符。( )

F 26. 子类的类成员变量不能与其父类的类成员变量同名。( ) F 27. static 变量不能是 private 变量。( ) T 28. 保留字 this 代表当前对象。( )

T 29. 类的构造函数名必须和类名相同。( ) T 30. 子类的对象能直接向其父类对象赋值。( )

T 31.一个子类可以重新定义从父类那里继承来的同名方法，而且允许它们有不同的返回值。 F 32.类头定义包含的四个部分分别为：访问控制修饰符、类名说明、父类名说明和接口名的说明，它们中的任何一个都是不能缺少的。（ F ）

T 33.面向对象的软件开发方法用类把数据和基于数据的操作封装在一起，并且类之间可以 存在继承关系。（ ）

四、简答题

1、String是最基本的数据类型吗?

答：基本数据类型包括byte、int、char、long、float、double、boolean和short。 java.lang.String类是final类型的，因此不可以继承这个类、不能修改这个类。为了提高效率节省空间，我们应该用StringBuffer类。 2、面向对象的特征有哪些方面？简述每个特征。 3、int 和 Integer 有什么区别？

答：Java 提供两种不同的类型：引用类型和原始类型（或内置类型）。Int是java的原始数据类型，Integer是java为int提供的封装类。Java为每个原始类型提供了封装类。引用类型和原始类型的行为完全不同，并且它们具有不同的语义。引用类型和原始类型具有不同的特征和用法，它们包括：大小和速度问题，这种类型以哪种类型的数据结构存储，当引用类型和原始类型用作某个类的实例数据时所指定的缺省值。对象引用实例变量的缺省值为 null，而原始类型实例变量的缺省值与它们的类型有关。 4、String 和StringBuffer的区别？

答：JAVA平台提供了两个类：String和StringBuffer，它们可以储存和操作字符串，即包含多个字符的字符数据。这个String类提供了数值不可改变的字符串。而这个StringBuffer

类提供的字符串进行修改。当你知道字符数据要改变的时候你就可以使用StringBuffer。典型地，你可以使用StringBuffers来动态构造字符数据。 5、运行时异常与一般异常有何异同？ 答：异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误。java编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要求必须声明抛出未被捕获的运行时异常。 6、final, finally, finalize的区别？

答：final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。 finally是异常处理语句结构的一部分，表示总是执行。

finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。 7、sleep() 和 wait() 有什么区别?

答：sleep是线程类（Thread）的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用sleep不会释放对象锁。

wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。

8、Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型? 答：方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。 9、abstract class和interface有什么区别?

答：声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。不能创建abstract 类的实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。不能有抽象构造函数或抽象静态方法。Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类为。取而代之，在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法。

接口（interface）是抽象类的变体。在接口中，所有方法都是抽象的。多继承性可通过实现这样的接口而获得。接口中的所有方法都是抽象的，没有一个有程序体。接口只可以定义static final成员变量。接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。当类实现特殊接口时，它定义（即将程序体给予）所有这种接口的方法。然后，它可以在实现了该接口的类的任何对象上调用接口的方法。由于有抽象类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。引用可以转换到接口类型或从接口类型转换，instanceof 运算符可以用来决定某对象的类是否实现了接口。 10、启动一个线程是用run()还是start()?

答：启动一个线程是调用start()方法，使线程所代表的虚拟处理机处于可运行状态，这意味着它可以由JVM调度并执行。这并不意味着线程就会立即运行。run()方法可以产生必须退出的标志来停止一个线程。 11、接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承实体类(concrete class)?

答：接口可以继承接口。抽象类可以实现(implements)接口，抽象类是否可继承实体类，但前提是实体类必须有明确的构造函数。

12、数组有没有length()这个方法? String有没有length()这个方法？

答：数组没有length()这个方法，有length的属性。String有有length()这个方法。 13、构造器Constructor是否可被override? 答：构造器Constructor不能被继承，因此不能重写Overriding，但可以被重载Overloading。 14、是否可以继承String类?

答：String类是final类故不可以继承。

15、swtich是否能作用在byte上，是否能作用在long上，是否能作用在String上? 答：switch（expr1）中，expr1是一个整数表达式。因此传递给 switch 和 case 语句的参数应该是 int、 short、 char 或者 byte。long,string 都不能作用于swtich。

16、try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后? 答：会执行，在return前执行。

17、简述Java多态性的概念，隐藏、覆盖和重载的概念及使用时应注意的问题。 答：多态性：在一个类中可以定义多个同名方法，有静态多态性和动态多态性。 隐藏：子类重新定义了父类中的同名成员变量。被隐藏的父类成员变量在子类中仍然占有存储空间。

覆盖：子类重新定义了父类的同名成员方法，要求方法名、参数和返回类型都相同。与隐藏不同，此时子类方法将替换掉同名的父类方法，清除父类方法在子类中占有的空间。 重载：在同一个类中定义多个同名但参数不同的方法，参数不同是指个数、类型或顺序不同。 注意事项：

不能覆盖父类的static方法和final方法。

可以隐藏父类的static方法，即在子类中声明同名static方法。 非Static方法不能隐藏，只能覆盖。 子类必须覆盖父类的abstract方法。

18、什么是事件、事件源和事件监听器？简述使用事件监听器进行事件处理的过程。 答：事件：对界面的某种操作，如按键、单击鼠标、鼠标移动等。 事件源：事件的产生者，通常是某一组件，如按钮等。

事件监听器：是某些事件的接口，其中定义了被监听的事件发生时系统要调用的方法。 事件处理过程由下面3步组成：

①为类声明需要的事件监听器接口。 ②给事件源注册一个事件监听器。 ③实现接口声明中事件处理方法。

19、简述Java中构造方法的概念及特点。

答：构造方法：构造方法是一种特殊的方法，用于初始化对象。 特点：①构造方法与类同名，可以有参数 ，也可无参数。

②构造方法没有返回值，在方法前也不需要写void。 ③创建对象时，系统自动调用构造方法。

④用户在程序中不能直接调用构造方法，只能通过new操作符调用。

⑤一个类可以有多个同名构造方法，但参数必须不同。所谓参数不同是指： ⑥类中可以不定义构造方法，此时Java提供一个默认的无参数构造方法 20、简述Java中接口的概念及接口的性质？

答：Java语言规定，类只能实现单继承，但接口可以实现多重继承。接口中定义的方法都是

抽象方法，定义的所有域都是常量。

因此接口可以看作是没有实现的方法和常量的集合。使用接口主要是解决Java语言不支持多重继承的问题。

性质：①接口不提供代码重用性。因为接口中的方法都是没有实现的方法，因此所有的方法体都要自己编写。

②接口可以通过多继承进行扩展。

③接口不能升级，即提供给用户的接口不能再改变。

五、阅读程序写结果

1、class V1{ int a=1;

void m1(){ System.out.println(a); } }

class E1 extends V1{ int a=2,b=3,c;

void m2(){ System.out.println(a); } }

class H{

public static void main(String[] s){ E1 e1=new E1();

e1.m1(); e1.m2(); } }

答案：

1 2

2、class V1{ public int x=2;

V1(){ System.out.println(\ }

class V2 extends V1{ public int x=3;

V2(){ System.out.println(\ }

class H{

public static void main(String[] s){ V1 e1=new V2();

System.out.println(e1.x); } } 答案：

V1 V2 2

3、import java.io.*; public class abc

{ public static void main(String args[ ]) { AB s = new AB(\ System.out.println(s.toString( )); } }

class AB { String s1; String s2;

AB( String str1 , String str2 ) { s1 = str1; s2 = str2; } public String toString( ) { return s1+s2;} }

把定义对象实例化参数再加个要不编译出错 改后答案： 某某+Hello

4、 import java.io.* ; public class abc {

public static void main(String args[ ]) { int i , s = 0 ;

int a[ ] = { 10 , 20 , 30 , 40 , 50 , 60 , 70 , 80 , 90 }; for ( i = 0 ; i < a.length ; i ++ ) if ( a[i]%3 = = 0 ) s += a[i] ; System.out.println(\}

} 答案： S=180

5、 class V1{ public int x=4;

V1(){ System.out.println(\}

class V2 extends V1{ public int x=7;

V2(){ System.out.println(\}

class H{

public static void main(String[] s){ V1 e1=new V2();

System.out.println(e1.x); } } 答案：

V1

V2 4

6、class V1{ int a=3;

void m1(){ System.out.println(a); } }

class E1 extends V1{ int a=5,b=3,c;

void m2(){ System.out.println(a); } }

class H{

public static void main(String[] s){ E1 e1=new E1();

e1.m1(); e1.m2(); } }

答案：

3 5

7、import java.awt.*; import java.applet.*;

public class test2 extends Applet {

float[ ] x = {1.2f, 3.4f, 5.6f, 7.8f}; public void paint(Graphics g) {

int s=0;

for( int i = 0; i < x.length; i++ ) s += (int)x[i];

g.drawString(\} }

答案：

8、class Parent { void printMe() {

System.out.println(\} }

class Child extends Parent{ void printMe(){

System.out.println(\}

void printall() { super.printMe(); this.printMe(); printMe(); } }

public class Test_this {

public static void main(String args[]) { Child myC=new Child(); myC.printall(); } }

答案：

parent child child

六、阅读程序，给出程序的功能

1、public class H{

public static void main(String args[]){ Fact N=new Fact(4);

System.out.print(N.fact()); } }

class Fact{ int n;

Fact(int nn) {n=nn;} int fact(){ int i,f=1;

for(i=1;i<=n;i++) f=f*i; return f; } } 答案： 求n的阶层

2、public class H{

public static void main(String args[]){ int i,Max,Min;

int a[]={12,67,8,98,23,56,124,55,99,100}; Max=a[0];Min=a[0]; for(i=1; iMax) Max=a[i]; }

System.out.print(Max+\} } 答案：

输出给定数组最大 最小值 import java.io.*; public class abc

{ public static void main(String args[]) { SubClass sb = new SubClass( ); System.out.println(sb.max( )); } }

class SuperClass

{ int a = 10 , b = 20 ; }

class SubClass extends SuperClass

{ int max( ) { return ((a>b)?a:b); } } 答案：

输出a b的最大值 3、import java.io.* ; public class abc {

public static void main(String args[ ])

{ int i , n = 10 , max = 0 , min = 0 , temp = 0;

try {

BufferedReader br = new BufferedReader(

new InputStreamReader(System.in)); max = min = Integer.parseInt(br.readLine( )); } catch ( IOException e ) { } ; for ( i = 2 ; i <= n ; i ++ ) { try {

BufferedReader br = new BufferedReader(

new InputStreamReader(System.in)); temp = Integer.parseInt(br.readLine( )); if (temp > max ) max=temp; if (temp < min) min=temp;

} catch ( IOException e ) { } ; }

System.out.println(\ } }

答案：

在键盘依次输入10个数最后输出 最大数和最小的数 4、import java.awt.*; public class abc

{ public static void main(String args[]) { new FrameOut(); } }

class FrameOut extends Frame { Button btn; FrameOut( )

{ super(\

btn = new Button(\

setLayout(new FlowLayout( )); add(btn);

setSize(300,200); show( ); } } 答案：

实现在框架中加入一个名为click的按钮 5、public class Sum

{ public static void main( String args[ ]) { double sum = 0.0 ;

for ( int i = 1 ; i <= 100 ; i + + ) sum += 1.0/(double) i ;

System.out.println( \ }

答案：

1.0与double(1……..100)的商相加 6、import java.io.* ; public class Reverse

{ public static void main(String args[ ]) { int i , n =10 ;

int a[ ] = new int[10]; for ( i = 0 ; i < n ; i ++ ) try {

BufferedReader br = new BufferedReader( new InputStreamReader(System.in));

a[i] = Integer.parseInt(br.readLine( )); // 输入一个整数 } catch ( IOException e ) { } ; for ( i = n－1 ; i >= 0 ; i ―― ) System.out.print(a[i]+\\ System.out.println( ); } } 答案：

依次输入十个数再逆序输出 7、public class test {

public static void main(String[] args) { int count = 0;

for(int i=101; i<200; i+=2) { boolean b = false;

for(int j=2; j<=Math.sqrt(i); j++) {

if(i % j == 0)

{ b = false; break; }

else

{ b = true; }

}

if(b == true)

{count ++;

System.out.println(i );}

}

System.out.println( \个数是: \ } }

答案：

输出101到200之间所有素数和个数

七、程序填空

1.下面是一个类的定义:

public class __ Myclass __________ {

int x, y;

Myclass ( int i, ___intj____) // 构造函数 { x=i; y=j; } }

2.下面是用户程序对 Applet 类中方法 paint( ) 的重新定义。 public void paint(Graphics a ) { int i=689;

a.drawString ( “ ”+ i ,20,60); }

3.下面是一个Java Application 的主类的定义，其功能是输出所有命令行参数。 import java.io.*; public class MyClass {

public static void main(String args[ ]) {

if( args.length !=null)

for(int i=0; i < args.length; i++) System.out.println(args[i]);

else System.out.println(\没有命令行参数\} }

4.下面是一个小程序的主类myprogram的定义, 其中A、B是该主类所在源程序中已定义的另两个类的类名: import java awt.*； import java applet.*；

public class myprogram extends Applet//定义小程序的主类 {

A a; B b;

public void init( )

{ a=new A( )； b=new B( ); } }

5.下面程序的功能是输出数组各元素的和。 import java.awt.Graphics; import java.applet.Applet;

public class SumArray extends Applet {

float[] a; a= new a[6]; float sum=0.0f;

public void init( ) {

for ( int j = 0; j < a.length; j++ ) a[j] = j+1;

for ( int i = 0 ; i < a.length; i++ ) sum+= a[i]; }

public void paint( Graphics g ) {

g.drawString( \} }

6.下面是一个java应用程序（Application），它的功能是在屏幕上输出26个英文字母，其中每个字母相隔一个制表符,请完成程序。 public _____ Class1 {

public static void main( String args[] ) {

char c='a';

for (int i=1;i<=26;i++) {

System.out.print(c+” ”); c++; } } }

7.下面程序的功能为计算数组各元素的和，请完成程序。 import java.awt.Graphics; import java.applet.Applet;

public class SumOfArray __extends_____ Applet {

public void paint( Graphics g ) {

int a[] = { 1, 3, 5, 7, 9, 10 }; int total=0;

for ( int i = 0; i < a.length; i++ ) total+=___a[i]__________;

g.drawString( \} }

8. 下面的java小应用程序实现的功能是从文本域中输入你的名字\回车后在 Applet中显示\你好!\，请完成程序。

import java.awt.*; import java.applet.*; import java.awt.event.*;

public class Applet1 extends Applet implements ActionListener {

Label aa; TextField t1; String s=\public void init() {

aa=new Label(\请输入你的名字：\add(aa);

t1=new TextField(****);

add(t1);

t1.addActionListener(this); }

public void paint(Graphics g) {

g.drawString(s,20,100); }

public void actionPerformed(ActionEvent e) {

s= t1.getText+”你好”; repaint(); } }

9. 下面是求阶乘的递归算法，方法的返回值类型为long, 请完成程序。 long Factorial(long n) {

if(n<=1) return 1; else

return n*factorial(n-1); }

10.下面程序的功能是通过调用方法max（）求给定的三个数的最大值，请将程序补充完 整。

import java.io.*; public class Class1 {

public static void main( String args[] ) {

int i1=1234,i2=456,i3=-987; int MaxValue;

MaxValue=max(i1,i2,i3);;

System.out.println(\三个数的最大值：\}

public __static ____ int max(int x,int y,int z) {

int temp1,max_value; temp1=x>y?x:y;

max_value=temp1>z?temp1:z; return max_value; } }

八、程序设计

1、设计类A和A的派生类B，要求：

1）A有两个数据成员a和b（都为int型）；B中继承了A中的a和b，又定义了自己的数据成员c（int型）。

2）为A添加含有两个参数的构造方法，对a和b初始化。 3）为B添加含有一个参数的构造方法，对c初始化。

4）完成主控方法，在主控方法中用B e1=new B(5)创建对象，把a、b、c分别初始化成3、4、5，最后输出它们的和。 答案： class A{

public int a; public int b; A(int _a, int _b) { a = _a; b = _b; } }

public class B extends A{ private int c; B(int _c)

{ super(3,4); c = _c; }

int qiuhe() { return a+b+c; }

public static void main(String args[]) { B e1=new B(5); System.out.println(e1.qiuhe());

} }

2、编写一个字符界面的Java Application程序，要求如下：

1）使用字符输入流类的readLine()方法，接收键盘输入的10个整数。 2）用起泡法进行非递减排序，排序结果显示在字符界面上。 答案：

import java.io.*; import java.util.*;

public class java {

public static void main(String[] args) throws Exception{

int arr[]=new int[10];

for(int a=0;a

System.out.print(\请输入:\); arr[a]= reader.nextInt(); }

Scanner reader = new Scanner(System.in);

for (int i = 0; i < arr.length; i++) { for (int j = 0; j < arr.length-i-1; j++) { if (arr[j]>arr[j+1]) { int temp=arr[j]; arr[j]=arr[j+1]; arr[j+1]=temp; } } }

for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); } } }

3、编写一个图形界面的Applet应用程序（HTML文件可以略去），要求如下： 1）在Applet界面上添加三个TextField组件、两个Label组件和一个Button组件。

2）在两个TextField组件中输入两个整数，鼠标左键单击Button组件，在第三个TextField组件中显示它们的和。 答案：

import java.awt.*; import java.awt.event.*;

import javax.swing.*; import java.applet.Applet;

public class jav extends JApplet implements ActionListener{

private JTextField jiasu; private JTextField beijiasu; private JTextField jieguo; private JButton jisuan;

public void init()

{ this.setLayout(new FlowLayout()); }

public void actionPerformed(ActionEvent e) {

if((e.getSource()==jisuan)); int

jiasu = new JTextField(\,8); this.add(jiasu);

this.add(new JLabel(\)); beijiasu = new JTextField(\,8); this.add(beijiasu);

jieguo = new JTextField(\结果\,14); this.add(jieguo);

jisuan = new JButton(\计算\); this.add(jisuan);

jisuan.addActionListener(this);

x=Integer.parseInt(jiasu.getText())+Integer.parseInt(beijiasu.getText());

}

jieguo.setText(\+x);

}

4、编写一个程序，判断输入的年是否为闰年。 答案：

import java.io.*; public class java {

private static int zuixiao = 1582;

public static boolean isLeapYear(int year) { return year >= zuixiao?

((year%4 == 0) && ((year0 != 0) || (year@0 == 0))) : (year%4 == 0); }

public static void main(String[] args) throws IOException { System.out.print(\请输入4位数的年份：\);

BufferedInputStream input = new BufferedInputStream(System.in); DataInputStream reader = new DataInputStream(input);

byte[] b = new byte[4]; reader.read(b);

String yearTemp = new String(b,\); int year = 0;

String bStr = \; try {

year = Integer.parseInt(yearTemp);

bStr = isLeapYear(year) ? \是\ : \不是\;

System.out.println(yearTemp + bStr + \闰年！\); } catch (Exception e) {

System.out.println(\您输入的年份不是数字或不是四位数：\ ); }

reader.close(); input.close(); } }

5、编写一个程序，对数组中每个元素赋值，然后按逆序输出。

答案：

import java.io.*; public class java{

public static void main(String args[]){ int i;

int a[] = new int[5]; for(i=0;i<5;i++) a[i]=i;

for( i=a.length-1;i>=0;i--)

System.out.println(\+i+\+a[i]); }}

6、输入一个姓名，程序运行后，输出“姓名Welcome you!”.例如，输入张三，则结果为“张三Welcome you !”. 答案：

import java.io.*;

public class java{

public static void main(String[] args) throws IOException {

InputStreamReader reader = new InputStreamReader(System.in); BufferedReader input = new BufferedReader(reader); System.out.print(\); String name = input.readLine();

System.out.println(\ + name + \);

} }

7、一个Applet程序，其功能是接收用户输入的两个整数，比较它们的大小，并在用户按下“比较”按钮后，将Applet中显示的“请先输入两个待比较的整数”，改为“两个整数中最大值是：x”，x是两个数中的最大值.

import java.awt.*; import java.awt.event.*; import javax.swing.*; import java.applet.Applet;

public class java extends JApplet implements ActionListener{

private JTextField bijiao; private JTextField beibijiao; private JLabel jieguo; private JButton bibi;

public void init()

{ this.setLayout(new FlowLayout());

bijiao = new JTextField(\,8); this.add(bijiao);

beibijiao = new JTextField(\,8); this.add(beibijiao); bibi=new JButton(\比较\);

jieguo= new JLabel(\请先输入两个待比较的整数\); this.add(bibi);

bibi.addActionListener(this); }

public void actionPerformed(ActionEvent e) { }

if((e.getSource()==bibi));

int x=Integer.parseInt(bijiao.getText()); int y=Integer.parseInt(beibijiao.getText()); if(x > y)

jieguo.setText(\+x);else

jieguo.setText(\+y);

this.add(jieguo);

}

8、设计类A和A的派生类B，要求：

1）A有两个数据成员a和b（都为int型）；B中继承了A中的a和b，又定义了自己的数据成员c（int型）。

2）为A添加含有两个参数的构造方法，对a和b初始化。 3）为B添加含有一个参数的构造方法，对c初始化。

4）完成主控方法，在主控方法中用B e1=new B(5)创建对象，把a、b、c分别初始化成

3、4、5，最后输出它们的和。 答案： class A{

public int a; public int b; A(int _a, int _b) { a = _a; b = _b; } }

public class B extends A{ private int c; B(int _c)

{ super(3,4); c = _c; }

int qiuhe() { return a+b+c; }

public static void main(String args[]) { B e1=new B(5); System.out.println(e1.qiuhe()); } } 9、编写一个完整的Java Applet 程序使用复数类Complex验证两个复数 1+2i 和3+4i 相加产生一个新的复数 4+6i 。

复数类Complex必须满足如下要求： (1) 复数类Complex 的属性有：

RealPart : int型，代表复数的实数部分 ImaginPart : int型，代表复数的虚数部分 (2) 复数类Complex 的方法有：

Complex( ) : 构造函数，将复数的实部和虚部都置0

Complex( int r , int i ) : 构造函数，形参 r 为实部的初值，i为虚部的初值。 Complex complexAdd(Complex a) : 将当前复数对象与形参复数对象相加，所得的结果仍是一个复数值，返回给此方法的调用者。

String ToString( ) : 把当前复数对象的实部、虚部组合成 a+bi 的字符串形式，其中a 和 b分别为实部和虚部的数据。 答案：

import java.applet.Applet;

public class java extends Applet{ private int realPart; private int imagePart; public java(){

realPart = imagePart = 0; }

public java(int r, int i){ realPart = r; imagePart = i; }

public java complexAdd(java a){ this.realPart += a.realPart; this.imagePart += a.imagePart; return this; }

public String toString(){

String str = realPart + (imagePart >= 0?\:\) +imagePart + \; return str; }

public static void main(String[] args){

java a = new java(); java b = new java(1,2);

System.out.println(\ + a); System.out.println(\ + b);

System.out.println(\ + a.complexAdd(b)); } }

10、编写一个如下可视化窗体，要求实现其界面显示功能。 运行界面如下：

import java.awt.*; import java.awt.event.*;

public class java extends Frame implements ActionListener { Button btn1, btn2; TextField f,tf1,tf2; TextArea Area; java() {

super(\添加组件的窗口\);

addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } });

setSize(350,250); //设置窗口大小 setLocation(200,200);//设置窗口显示位置

setFont(new Font(\,Font.PLAIN,12)); //设置字体 setLayout(new FlowLayout()); Area=new TextArea (6,40);

tf1=new TextField(10); tf2=new TextField(10); btn1=new Button(\显示\); btn2=new Button(\退出\); f=new TextField(20);

add(Area); add(new Label(\用户名\)); add(tf1); add(new Label(\电话\));

add(tf2); add(f); add(btn1); add(btn2);

tf1.addActionListener(this); tf2.addActionListener(this); btn1.addActionListener(this); btn2.addActionListener(this); show(); }

public static void main(String args[]) { new java(); }

public void actionPerformed(ActionEvent e) { if (e.getSource()==btn1)

f.setText(\你按下了“\ + e.getActionCommand() + \按钮\); if (e.getSource()==tf1)

Area.append(\用户名：\+tf1.getText()+\); if (e.getSource()==tf2)

Area.append(\电 话：\+tf2.getText()+\); if (e.getSource()==btn2) { for (int i=0; i<100000000; i++); dispose();//只关闭当前窗口,注销该对象 } } }

本文来源：https://www.bwwdw.com/article/tjjr.html