JAVA练习题·期末

最新推荐文章于 2024-05-16 20:54:32 发布

chentao326

最新推荐文章于 2024-05-16 20:54:32 发布

阅读量3.6k

点赞数 3

分类专栏： JAVA 文章标签： java

本文链接：https://blog.csdn.net/chentao326/article/details/122442600

版权

JAVA 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

一、单选择题

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

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

设 x = 1 , y = 2 , z = 3，则表达式 y＋＝z－－/＋＋x 的值是( A )。

A. 3 B. 3. 5 C. 4 D. 5

不允许作为类及类成员的访问控制符的是( C )。

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

以下关于继承的叙述正确的是（ A ）。

A、在Java中类只允许单一继承

B、在Java中一个类只能实现一个接口

C、在Java中一个类不能同时继承一个类和实现一个接口

D、在Java中接口只允许单一继承

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

A. static void method( ) B. public void method( )

C. final void method( ) D. abstract void method( )

Java application中的主类需包含main方法，以下哪项是main方法的正确形参？（ B ）

A、 String args B、String args[]

C、Char arg D、StringBuffer args[]

已知如下定义：String s = "story"; 下面哪个语句不是合法的？ ( )

A、s += "books"; B、s = s + 100;

C、int len = s.length; D、String t = s + “abc”;

int len = s.length(),String 使用的是length方法，而数组使用的是length属性

下列哪些语句关于Java内存回收的说明是正确的? （）

A、程序员必须创建一个线程来释放内存

B、内存回收程序负责释放无用内存

内存释放由程序自动

C、内存回收程序允许程序员直接释放内存

D、内存回收程序可以在指定的时间释放内存对象

有以下程序片段，下列哪个选项不能插入到行1。（）

2 .public class Interesting{

3. //do sth

4.}

A、import java.awt.*; B、package mypackage;

C、class OtherClass{ } D、public class MyClass{ }

每个编译单元(文件)只能有一个public类。这么做的意思是，每个编译单元只能有一个公开的接口，而这个接口就由其public类来表示

设有下面两个赋值语句：

a = Integer.parseInt(“12”);

b = Integer.valueOf(“12”).intValue();此方法返回该对象转换为int类型后表示的数值。

Integer.parseInt（）返回一个原子类型INT。
Integer.valueOf（），返回的是封装的整数对象。

下述说法正确的是（）。

A、a是整数类型变量，b是整数类对象。

B、a是整数类对象，b是整数类型变量。

C、a和b都是整数类对象并且值相等。

D、a和b都是整数类型变量并且值相等。

17．在使用interface声明一个接口时，只可以使用下面哪个修饰符修饰该接口。（）

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

void的含义：　　（　　）

A．方法没有返回值　　 B．方法体为空

C．没有意义 D.　定义方法时必须使用

return语句：　　（　　）

A．只能让方法返回数值　 B．方法都必须含有

C．方法中可以有多句return 　 D．不能用来返回对象

处在if中就可以有

关于对象成员占用内存的说法哪个正确？　　（　　）

A．同一个类的对象共用同一段内存

B、同一个类的对象使用不同的内存段，但静态成员共享相同的内存空间

C．对象的方法不占用内存

D．以上都不对

下列说法哪个正确？

A．不需要定义类，就能创建对象

B．对象中必须有属性和方法

C．属性可以是简单变量，也可以是一个对象

D、属性必须是简单变量

java中属性的定义规则，是指set/get方法名去掉set/get后，将剩余部分首字母小写后，得到的字符串就是这个类的属性。

关于方法main（）的说法哪个正确？（　　）

A．方法main（）只能放在公共类中

B main()的头定义可以根据情况任意更改

C．一个类中可以没有main()方法

D．所有对象的创建都必须放在main()方法中

构造函数何时被调用？　　（　　）

A、创建对象时　 B、类定义时

C、使用对象的方法时　　 D、使用对象的属性时

其是应该说是实例化对象时被调用，一个类的创建会默认有一个无参构造方法，当你实例化的时候（new Object（））会被调用

抽象方法：　　（　　）

A、可以有方法体

B、可以出现在非抽象类中

C、是没有方法体的方法

D、抽象类中的方法都是抽象方法　

关于构造函数的说法哪个正确？　　（　　）

A、一个类只能有一个构造函数

B、一个类可以有多个不同名的构造函数

C、构造函数与类同名

D、构造函数必须自己定义，不能使用父类的构造函数

构造函数必须与类同名，而且不能有返回类型。

重写与重载的关系是　　（　　）

A、重写只有发生在父类与子类之间，而重载可以发生在同一个类中

B．重写方法可以不同名，而重载方法必须同名

C．final修饰的方法可以被重写，但不能被重载

D．重写与重载是同一回事

重载

类里面的方法名相同，参数和返回类型不同

参数：不同

返回类型：可以相同

异常: 可以修改

访问限制：可以修改

重写

继承父类之后重写父类的方法

参数：相同

返回类型：相同

异常: 可以减少，不可以增加

访问限制：可以降低，不可以上升

异常包含下列哪些内容？　　（　　）

A．程序执行过程中遇到的事先没有预料到的情况

B．程序中的语法错误　　

C．程序的编译错误

D．以上都是

以下哪个不是Java的原始数据类型（）

A、int B、Boolean C、float D、char

java原始数据类型有short、byte、int、long、boolean、char、float、double

而大写开头的是一种引用类型

若需要定义一个类方法，应使用哪种修饰符？（）

A、static B、package C、private D、public

给出下面代码，关于该程序以下哪个说法是正确的？（）

public class Person{

static int arr[] = new int[5];

public static void main(String args[])

{

　　System.out.println(arr[0]);　}

}

A、编译时将产生错误 B、编译时正确，运行时将产生错误

C、输出零 D、输出空

在使用interface声明一个接口时，只可以使用下面哪个修饰符修饰该接口。（ ）

A、private B、protected C、private D、public

如下哪个是Java中的标识符( )

A、fieldname B、super C、3number D、#number

关于选择结构下列哪个说法正确？　（　　）

A．if语句和 else语句必须成对出现

B．if语句可以没有else语句对应

C．switch结构中每个case语句中必须用break语句

D．switch结构中必须有default语句

while循环和 do…while循环的区别是：　　（　　）

A．没有区别，这两个结构任何情况下效果一样

B．while循环比 do…while循环执行效率高

C．while循环是先循环后判断，所以循环体至少被执行一次

D．do…while循环是先循环后判断，所以循环体至少被执行一次

下列修饰符中与访问控制无关的是　（　　）

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

修饰类

当用final修饰一个类时，表明这个类不能被继承。也就是说，如果一个类你永远不会让他被继承，就可以用final进行修饰。final类中的成员变量可以根据需要设为final，但是要注意final类中的所有成员方法都会被隐式地指定为final方法。

修饰方法

使用final方法的原因有两个。第一个原因是把方法锁定，以防任何继承类修改它的含义；第二个原因是效率。在早期的Java实现版本中，会将final方法转为内嵌调用。但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升。在最近的Java版本中，不需要使用final方法进行这些优化了。

修饰变量

对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。

void的含义：　　（　　）

A．方法没有返回值　　 B． 方法体为空

C．没有意义　　　　 D.　定义方法时必须使用

关于对象成员占用内存的说法哪个正确？　　（　　）

A．同一个类的对象共用同一段内存

B、同一个类的对象使用不同的内存段，但静态成员共享相同的内存空间

C．对象的方法不占用内存

D．以上都不对

下列说法哪个正确？

A．不需要定义类，就能创建对象

B．对象中必须有属性和方法

C．属性可以是简单变量，也可以是一个对象

D、属性必须是简单变量

下列说法哪个正确？　　（　　）

A、一个程序可以包含多个源文件

B、一个源文件中只能有一个类

C、一个源文件中可以有多个公共类(1个)

D、一个源文件只能供一个程序使用

关于继承的说法正确的是：　　（　　）

A、子类将继承父类所有的属性和方法。

B、子类将继承父类的非私有属性和方法。

C、子类只继承父类public方法和属性

D、子类只继承父类的方法，而不继承属性

关于构造函数的说法哪个正确？　　（　　）

A、一个类只能有一个构造函数

B、一个类可以有多个不同名的构造函数

C、构造函数与类同名

D、构造函数必须自己定义，不能使用父类的构造函数

关于接口哪个正确？　　（　　）

A、实现一个接口必须实现接口的所有方法

B．一个类只能实现一个接口

C．接口间不能有继承关系

D．接口和抽象类是同一回事

对于已经被定义过可能抛出异常的语句，在编程时：　　（　　）

A、必须使用try／catch语句处理异常，或用throw将其抛出

B．如果程序错误，必须使用 try／catch语句处理异常

C．可以置之不理

D．只能使用try／catch语句处理

字符流与字节流的区别在于（　　）

A．前者带有缓冲，后者没有

B．前者是块读写，后者是字节读写

C. 二者没有区别，可以互换使用

D. 每次读写的字节数不同

字节流操作的基本单元为字节；字符流操作的基本单元为Unicode码元。

字节流默认不使用缓冲区；字符流使用缓冲区。

字节流通常用于处理二进制数据，实际上它可以处理任意类型的数据，但它不支持直接写入或读取Unicode码元；字符流通常处理文本数据，它支持写入及读取Unicode码元

下列流中哪个不属于字节流　　（　　）

A．FileInputStream

B．BufferedInputStream

C. FilterInputStream

D. InputStreamReader

下列哪个是JDK提供的编译器？

A．java.exe B．javac.exe C．javaap.exe D．javaw.exe

下列描述中不正确的一项是 ( )

A、import语句告诉Java用户需要哪个包(package!)中的类

B、所有的类必须实例化，才能调用它的数据成员和方法

C、package语句用于将源文件存入所指定的包中

D、System类不可能实例化，它的所有方法都是通过类变量来调用的

不用实例化也能调用

下面哪个函数是public void example( ){...}的重载函数？（）

A、public void example( ){...} B、public void example( int m ){...}

C、public void example2( ){...} D、public int example ( ){...}

重载方法名不变，其他的都可以改

为了区分重载多态中同名的不同方法，要求 ( )

A、形式参数个数或者类型不同 B、返回值类型不同

C、调用时用类名或对象名做前缀 D、形式参数名称不同（自己定义）

设 h、m、n 为类 x 中定义的 int 型变量，下列类 x 的构造函数中不正确的是( )。

A、 x( int m){ ... } B、 void x( int m){ ... }

C、 x( int m, int n){ ... } D、 x( int h,int m,int n){ ... }

下列说法中，正确的一个是 ( )

A、类成员变量在使用之前可以不初始化 B、局部变最在使用之前可以不初始化

C、参数变量在使用之前必须初始化 D、所有的变量在使用之前必须初始化

下列哪个叙述是错误的？

接口中不能声明变量。
接口中不能定义非抽象方法。
接口中的常量可以不指定初值。
可以在接口中只声明常量，不声明抽象方法。

接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象

下列哪个叙述是正确的？

A．创建File对象可能发生异常。

B．BufferedReader流可以指向FileInputStream流。

C．BufferedWrite流可以指向FileWrite。

D．RandomAccessFile流一旦指向文件，就会刷新该文件。

为了向文件hello.txt尾加数据，下列哪个是正确创建指向hello.txt的流？

A．try{ OutputStream out=new FileOutputStream(“hello.txt”);}

catch(IOException e) { }

B．try{ OutputStream out=new FileOutputStream(“hello.txt”,true);}

catch(IOException e) { }

C．try{ OutputStream out=new FileOutputStream(“hello.txt”,false);}

catch(IOException e) { }

D．try{ OutputStream out=new OutputStream(“hello.txt”,true);}

catch(IOException e) { }

下列哪个叙述是不正确的？
1. 一个应用程序中最多只能有一个窗口。
2. JFrame创建的窗口默认是不可见的。
3. 不可以向JFrame窗口中添加JFrame窗口。
4. 窗口可以调用setTitle（String s）方法设置窗口的标题。
下列哪个叙述是正确的？

接口中不能声明变量。
接口中不能定义非抽象方法。
接口中的常量可以不指定初值。
可以在接口中只声明常量，不声明抽象方法。

下列哪个叙述是正确的？

一个类最多可以实现2个接口。
如果一个抽象类实现某个接口，那么它必须要重写接口中的全部方法。
如果一个非抽象类实现某个接口，那么它可以只重写接口中的部分方法。
允许接口中只有一个抽象方法。

Java用标识符(identifier) 表示变量名、类名和方法名，以下关于标识符错误的是（ C ）

标识符可以由字母、数字和下划线(_)、美元符号($)组合而成
标识符可以由编程者自由指定
转义符也是标识符的一种，用来表示一些有特殊含义的字符
标识符必须以字母、下划线或美元符号开头，不能以数字开头

标识符是赋予变量，类和方法等的名称。标识符由编程者自己制定，但是要遵守一定的语法规范

转义符是指一些特殊含义的，很难用一般方式表达的字符，如回车，换行符

下列不是Java关键字的是( C )。

A、 final B、 finally C、null D、sizeof

下面哪个语句正确地声明一个整型的二维数组？ ( D )

A、 int a[][] = new int[][]; 没大小

B、 int a[100][100] = new int[][]; 实例化反了

C、 int []a[] = new int[100][100]; 语法错误

D、 int a[][] = new int[100][100];

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

A、abstract void method( ) B、final void method( )

C、public void method( ) D、static void method( )

给出如下代码:

class Test{

private int m;

　　public static void fun() {

　　　　// some code...

　　}

如何使成员变量m 被函数fun()直接访问? ( C )

A、将private int m 改为protected int m

B、将private int m 改为public int m

C、将private int m 改为 static int m

D、将private int m 改为 int m

由于 m现在是私有变量不可被访问，需要将他变成友好或者公共的，加上需要直接访问，则需要将其变为静态

欲构造ArrayList类的一个实例，此类继承了List接口，下列哪个方法是正确的？( B )

A、 ArrayList myList=new Object( ); B、 List myList=new ArrayList( );

C、 ArrayList myList=new List( ); D、 List myList=new List( );

上转型变量

下面（ B ）函数是public void example( ){...}的重载函数？

A、public void example( ){...}

B、public void example( int m ){...}

C、public void example2( ){...}

D、public int example ( ){...}

有程序片段如下，以下表示式的结果为true的是（ B ）。

Float s=new Float(0.1f);

Float t=new Float(0.1f);

Double u=new Double(0.1);

A、s==t B、s.equals(t)

C、u.equals(s) D、t.equals(u)

Java中==和equal的区别为:

1、== 表示判断2个变量或对象实例是否指向同一个内存空间，equals()表示判断2个变量或对象实例所指向的内存空间的值是否相同。

2、== 表示对内存地址进行比较，equals()表示对字符串的内容进行比较。

3、== 表示引用是否相同，equals() 表示值是否相同。

下列代码的执行结果是： ( C )。

public class Test5{

public static void main(String args[]){

String s1=new String("hello");

String s2="hello";

System.out.print(s1==s2);

System.out.print(",");

System.out.println(s1.equals(s2));

}

String s1=new String("hello");指向的是堆地址，而str2指向的是字符串常量地址

如下图

A、true,false B、true,true

C、false,true D、false,false

str指向在常量池中的字符串"hello"，在编译期就已经确定；str2指向堆上的对象，是在运行期创建，而堆中实际存放的字符串还是常量池中"hello"，即value属性还是指向常量池中的字符串；

String str2 = new String(“hello”);首先会在堆内存中申请一块内存存储对象内容,同时还会检查字符串常量池中是否含有"hello"字符串,若没有则添加"hello"到字符串常量池中，同时把常量池中的地址放到堆内存中；若有，则直接去常量池中的字符串内存地址即可；然后在栈中创建一个引用str2指向其堆内存块对象。（此过程中可能会创建两个对象，也可能就一个）

Java中 String str = new String("hello");的底层实现_黄亚的博客-CSDN博客_java new string

已知如下代码：

public class Test{

public static void main ( String arg[] )

{

long a[] = new long[6];

System.out.println ( a[6] );

}

请问哪个语句是正确的？（ D ）

A、程序输出 null B、程序输出 0

C、因为long[]数组声明不正确，程序不能被编译

D、程序被编译，但在运行时将抛出一个ArrayIndexOutOfBoundsException异常

在Java中打印Array数组的方法，这里主要总结了有四种：

（1）通过循环打印数组

（2）使用 Arrays.toString() 打印

（3）使用 JDK 8 的 java.util.Arrays.stream() 打印

（4）使用 Arrays.deepToString() 方法打印。如果数组中有其它数组，即多维数组，也会用同样的方法深度显示

关于异常的含义，下列描述中最正确的一个是（ C ）。

A、程序编译错误　　 B、程序语法错误

C、程序运行时的错误　　 D、程序编译和运行时发生的错误

以下有关构造函数的说法，正确的是：（ A ）。

A、一个类的构造函数可以有多个

B、构造函数在类定义时被调用

C、构造函数只能由对象中的其它方法调用

D、构造函数可以和类同名，也可以和类名不同

设 i、j、k 为类 x 中定义的 int 型变量，下列类 x 的构造函数中不正确的是( B )。

A、 x( int m){ ... } B、 void x( int m){ ... }

C、 x( int m, int n){ ... } D、 x( int h,int m,int n){ ... }

构造函数代表的函数子函数可能会有返回值，一个构造方法一旦加了void,那么这个就不是构造方法了，变成了一个普通的方法。

以下有关类的继承的说明中正确的是：( D )

A、子类能直接继承父类所有的非私有属性，也可通过接口继承父类的私有属性

B、子类只能继承父类的方法，不能继承父类的属性

C、子类只能继承父类的非私有属性，不能继承父类的方法

D、子类不能继承父类的私有属性

关于构造方法，下列说法错误的是（A ）

A、构造方法不可以进行方法重载	B、构造方法用来初始化该类的一个新的对象
C、构造方法具有和类名相同的名称	D、构造方法不返回任何数据类型

下列语句序列执行后，i 的值是( D )。

int i=8, j=16;

if( i-1 > j ) i--; else j--;

A、 15

B、 16

C、 7

D、 8

不满足if的条件就没有i--

以下由 for 语句构成的循环执行的次数是( B )。

for ( int i = 0; true ; i++) ;

A、有语法错，不能执行	B、无限次
C、执行1次	D、一次也不执行

下列数组定义及赋值，错误的是（C ）

A. int Array[];	B. int a[]={1,2,3,4,5};
C. int Array=new int[3];	D. int[][] a=new int[2][];
int Array[1]=1;	a[0]=new int[3];
int Array[2]=2;	a[1]=new int[3];
int Array[3]=3;

下列程序输出结果为：（ C ）

public class test {

public static void main(String args[]) {

int a = 0;

outer: for (int i = 0; i < 2; i++) {

for (int j = 0; j < 2; j++) {

if (j > i) continue outer;

a++;

}

System.out.println(a);

}

A、0 B、2 C、3 D、4

一般的Java源程序文件由以下三部分组成，下列哪个选项不是（ B ）

A、package语句(0句或1句) B、接口定义语句（1个或多个接口定义）

C、import语句(0句或多句) D、类定义(1个或多个类定义)

定义类头时能使用的修饰符是( C )。

A、private

B、 static

C、abstract

D、 protected

下列语句序列执行后，k 的值是( C )。

int i=10, j=18, k=30;

switch( j - i )

{ case 8 : k++;

case 9 : k+=2;

case 10: k+=3;

default : k/=j;

}

A、 31 B、32 C、2 D、33

没有break直接全部执行

关于以下程序段的说明正确的是（ C ）

	public class ArrayTest {
	public static void main(String args[]) {
	try {
	int x[]=new int[-5];
	System.out.println("此行将无法被执行!");
	} catch(NegativeArraySizeException e) {
	System.out.println("exception: 数组下标不能为负数。");
	}
	}
	}
A、编译通过，输出：		B、编译通过，输出：
此行将无法被执行!		此行将无法被执行!
		exception: 数组下标不能为负数。
C、编译通过，输出：		D、编译不能通过
exception: 数组下标不能为负数。

在浏览器中执行applet 程序，以下选项中的（ A ）方法将被最先执行。

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

下面哪个方法与applet的显示无关? （ B ）

update() B、draw() C、repaint() D、paint()

它一般运行在支持 Java 的 Web 浏览器内。因为它有完整的 Java API支持,所以Applet 是一个全功能的 Java 应用程序。

用于定义类成员的访问控制权的一组关键字是( D )。

A、 class, float, double, public B、 float, boolean, int, long

C、 char, extends, float, double D、 public, private, protected

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

A、private B、protected

C、private protected D、public

一个类要具备( C )才可以序列化。

A、继承ObjectStream类 B、具有带参数构造方法

C、实现Serializable接口 D、定义了WriteObject方法

指出下列程序运行的结果 ( B )

public class Example{

　　String str=new String("good");

　　char[] ch={'a','b','c'};

　　public static void main(String args[]){

　　　　Example ex=new Example();

　　　　ex.change(ex.str,ex.ch);

　　　　System.out.print(ex.str+" and ");

　　　　Sytem.out.print(ex.ch);

　　}

　　public void change(String str, char ch[]){

　　　　str="test ok";

　　　　ch[0]='g';

　　}

good and abc B、 good and gbc C、test ok and abc D、 test ok and gbc
给出如下初始化语句

String s1=new String(“Hello”);

String s2=new String(“there”);

String s3=new String();

以下哪种操作是合法的? ( A )

A、 s3=s1+s2; B、 s3=s1-s2;

C、 s3=s1&s2; D、 s3=s1&&s2;

MAX_LENGTH是int型public成员变量, 变量值保持为常量100，用简短语句定义这个变量。（D ）

A、 public int MAX_LENGTH=100;

B、 final int MAX_LENGTH=100;

C、 final public int MAX_LENGTH=100;

D、 public final int MAX_LENGTH=100;

下列方法中可以用来创建一个新线程的是( C )。

A、实现java.lang.Runnable 接口并重写 start()方法

B、实现java.lang.Runnable 接口并重写 run()方法

C、继承java.lang.Thread 类并重写 run()方法

D、实现java.lang.Thread 类并实现 start()方法

解析：接口Runnable定义了run()方法；而Thread类本身也实现了Runnable接口，故创建线程有两种方法：

1、用实现Runnable接口的类的实例作参数生成Thread类的实例

2、编写继承Thread类的类，并重写（override）run()方法

故答案为C。

给出下面代码段

1)	public class Test {
2)	int m, n;
3)	public Test() {}
4)	public Test(int a) { m=a; }
5)	public static void main(String arg[]) {
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)	}

哪行将引起一个编译时错误？（D ）

A、 line 3 B、 line 5 C、 line 6 D、 line 10

只能传一个值

哪个关键字可以抛出异常？（ C ）

A、 transient B、 finally C、throw D、 static

在Java语言中执行如下语句 int i=10;int j=++i; ，i和j的值分别为（A ）

A、 11和11 B、 10和10

C、 10和11 D、 11和10

Java语言和c++语言相比，哪一项是Java有的，而c++没有?（ D ）

A、面向对象 B、动态链接 C、有类库 D、跨平台

阅读下列代码段，选出该代码段的所在文件的正确文件名( D )。

class A{

void methodl(){

System．out．println(”methodl in class A”)：

}

public class B{

void method2(){

System.out.println(”method2 in class B”)：

}

public static void main(String args[]){

System.out.println(”main()in class B”)：

}

A、A .java B、A.class C、B.class D、B.java

下列描述中不正确的一项是( B )。

A、import语句告诉Java用户需要哪个包(package!)中的类

B、所有的类必须实例化，才能调用它的数据成员和方法

C、package语句用于将源文件存入所指定的包中

D、System类不可能实例化，它的所有方法都是通过类变量来调用的

为了区分重载多态中同名的不同方法，要求( A )。

A、形式参数个数或者类型不同 B、返回值类型不同

C、调用时用类名或对象名做前缀 D、形式参数名称不同（自己定义）

下列关于 long类型的说法中，正确的一项是( C )。

A、long类型占存储空间和int类型一样大 B、long类型能表示的数值范围和int类型一样

C、long类型不能自动转换为int类型 D、常数Long.MIN_VALUE代表整型的最小值

下列说法中，正确的一个是( D )。

A、类成员变量在使用之前可以不初始化 B、局部变最在使用之前可以不初始化

C、参数变量在使用之前必须初始化 D、所有的变量在使用之前必须初始化

Java 语言是强类型（Strongly Typed）语言，强类型包含以下两方面的含义：

所有的变量必须先声明、后使用。

指定类型的变量只能接受类型与之匹配的值。

执行下列代码段之后，输出的结果为( )。

public class exl8{

public static void main(String[]args){

int x=5,y=5; double c=10;

c%=(++x)*y；

System.out.println(c)；

}

A、15.0 B、10.0 C、5.0 D、10.0

运算符 / ：除法运算符，并且运算结果遵从向下取整。

运算符 % ：模运算，

　　　　　　（1）、当运算符左边小于右边，结果就等于左边；

　　　　　　（2）、当运算符左边大于右边，就和算术中的取余是一样的效果。

下列代码执行之后，输出的结果为( C )。

public class exl9{

public static void main(String[] args) {

int x=12,y=13,m=11;

int temp=x>y?x:y;

temp=temp>m?temp:m;

System.out.println(temp);

}

A、11 B、12 C、13 D、1

算术表达式10*10/6*6的值为( D )。

A、3 B、2 C、60 D、96

执行下列代码段后，输出的结果为(D )。(注意：215=32768)

public class ex34{

public static void main(String[]args){

int mm = 32767;

short tt = (short) (++mm);

System.out.println(tt);

}

A、32767 B、32768 C、-32767 D、-32768

基本类型：byte 二进制位数：8bit(1字节)
基本类型：short 二进制位数：16 bit(2字节)

最小值：Short.MIN_VALUE=-32768
最大值：Short.MAX_VALUE=32767

基本类型：int 二进制位数：32 bit(4字节)
基本类型：long 二进制位数：64 bit(8字节)
基本类型：float 二进制位数：32 bit(4字节)
基本类型：double 二进制位数：64 bit(8字节)
基本类型：char 二进制位数：16 bit(2字节)

下列程序执行之后，将会输出( D )。

public class ex4{

public static void main(String[ ]args){

int j = 0;

for (int i = 3; i > 0; i--) {

j += i;

System.out.print(j);

}

A、4 B、6 C、34 D、356

下列语句序列执行后，j的值是( C )。

public class Main {

public static void main(String[] args) {

int j = 2, i = 5;

while (j < i--)

j++;

System.out.println(j);

}

A、2 B、3 C、4 D、5

下列程序中的循环体将会被执行( D )。

public class Main {

public static void main(String[] args) {

int x = 3;

do {

System.out.println("Hello!");

x--;

} while (x >= 0);

}

A、1次 B、2次 C、3次 D、4次

下面哪一项的方法调用能填入程序中的横线处?（ C ）

public class Main {

public static void main(String[] args) {

Main e = new Main();

e.method();

}

public void method() {

CC9 c1 = new CC9();

CC9_1 c2 = new CC9_1();

}

class CC9 {

static void method() {

System.out.println("in CC9");

}

class CC9_1 {

void method() {

System.out.println("in CC9_1");

}

A、 c1.method( ); B、CC9.method( ); C、CC9.method( ); D、c1．method( );

c2.method( ); CC9_1.method( ); c2.method( ); CC9_l.method( );

已知定义：int a[ ]={1,2,3,4,5,6,7,8,9,10}; ，为了打印输出数组a的最后一个元素，下面正确的代码是( )。

A、System.out.println(a[10]);

B、System.out.println(a(9));

C、System.out.println(a[a.1ength]);

D、System.Out.println(a[a.1ength-1]);

编译并运行下面程序（命令：java exl0 1），关于运行结果的描述以下哪个选项是正确的?（ D ）

public class exl0 {

public static void main(String[] args) {

int i = 0;

try {

i = Integer.parseInt(args[0]);

} catch (Exception e) {

}

switch (i) {

case 0:

System.out.print("0");

case 1:

System.out.print("1");

default:

System.out.print("default");

}

A、打印"0" B、打印出"1"

C、打印出"default" D、打印出"1default"

下列关于抛出异常的描述中，错误的一项是( D )。

A、任何从Throwable派生的类都可以用throw语句抛出

B、 Exception和Error是Throwable的直接派生类

C、异常抛出点后的代码在抛出异常后不再执行

D、Exception代表系统严重错误，一般程序不处理这类错误

下列关于抛出异常的描述中，错误的一项是(C )。

A、异常可以由try代码段中的语句抛出

B、异常可以从被try代码段中调用的方法中抛出

C、异常的抛出并不影响代码段的执行顺序

D、异常还可能产生于数组下标越界及Java虚拟机内部的错误等

关于对下列代码段的描述，正确的一项是( D )。

catch(Exception e){

System.out.println(“An exception was thrown”)；

throw e；

}

程序终止

B、编译出错 C、该异常不会被处理

D、该异常会继续被上层处理

下列描述中，正确的一项是( D )。

A、异常机制可以用于流程控制

B、finally代码段在发生异常时不一定必须执行

C、在catch代码段中可以使用return语句来返回到异常抛出点

D、可以把catch到的异常对象再次抛出，使上层try—catch结构继续处理该异常事件

下说法中错误的一项是（）。

A、线程一旦创建，则立即自动进行

B、程创建后需要调用start()方法，将线程置于可运行状态

C、调用线程的start()方法后，线程也不一定能立即执行

D、线程处于可运行状态，意味着它可以被调度

线程开始运行时，是从下列哪一个方法开始执行的( )

A、main() B、start() C、run() D、init()

下列程序的执行结果是( B )

public class ex {

public static void main(String[] args) {

T1 t = new T1();

t.start();

}

class T1 extends Thread {

public void run() {

int a = 0;

do {

System.out.print(a + " ");

a++;

} while (a < 3);

}

A、 1 2 3 B、0 1 2 C、0 0 0 D、1 1 1

下列关于线程优先级的说法中，错误的一项是( )。

A、MIN_PRIORITY代表最低优先级 B、MAX_PRIORITY代表最高优先级

C、NOR_PRIORITY代表普通优先级 D、代表优先级的常数值越大优先级越低

下列哪一项不属于Swing布局管理器?（）

A、GridLayout B、CardLayout C、BorderLayout D、BoxLayout

下列说法中，错误的一项是( )。

A、在Java中，若要处理某类事件，必须定义相关的事件处理类

B、在对事件源实例化之后，要注册相应事件的监听器

C、事件处理类必须实现与该类事件相对应的监听器接口

D、事件源通常是一个构件，也称做监听器

如果有一个对象 myListener ( 其中 myListener 对象实现了 ActionListener 接口 ), 下列( C )语句使得 myListener 对象能够接受处理来自于 smallButton 按钮对象的动作事件 ?

A. smallButton.add(myListener);

B. smallButton.addListener(myListener);

C. smallButton.addActionListener(myListener);

D. smallButton.addItem(myListener);

二．程序阅读题

以下程序的输出结果为________相等_________。

class StringTest1

{

public static void main(String args[])

{

String s1="hello";

String s2=new String("hello");

if(s1.equals(s2)){

System.out.println("相等");

}else{

System.out.println("不相等");

} } }

应用程序的main方法中有以下语句，则输出的结果是 10 。

int b[][]={{1, 1, 1}, {2,2}, {3}};

int sum=0;

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

for(int j=0; j<b[i].length; j++) {

sum+=b[i][j];

} }

System.out.println("sum="+sum);

应用程序的main方法中有以下语句，则执行后输出的结果是 5 。

int[] x = {125,21,5,168,98};

int min = x[0];

for (int i=1; i<x.length; i++){

if(x[i] < min)

min = x[i];

}

System.out.println(min);

应用程序的main方法中有以下语句，则输出的结果是 0 。

int b[][]={{1}, {2,2}, {2,2,2}};

int sum=0;

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

for(int j=0;j<b[i].length;j++) {

sum*=b[i][j];

} }

System.out.println("sum="+sum);

应用程序的main方法中有以下语句，则执行后输出的结果是_______168________。

int[] x={125,21,5,168,98};

int max=x[0];

for(int i=1;i<x.length;i++){

if(x[i]> max)

max =x[i];

}

System.out.println(max);

程序Test.java编译运行后输出的结果是_________java2________。

public class Test {

String s1="java";

public static void main(String args[]) {

int z=2;

Test t=new Test();

System.out.println(t.s1+z);

}

阅读以下程序，写出输出结果_____ Animal ______ Dog______________。

class Animal {

Animal() {

System.out.print ("Animal "); }

}

public

class Dog extends Animal {

Dog() {

System.out.print ("Dog "); }

public static void main(String[] args) {

Dog snoppy= new Dog(); }

}

class A4{

public int getNumber(int a){

return a+1;

}

public class ABC extends A4{

public int getNumber(int a){

return a+100;

}

public static void main(String[] args) {

A4 a=new A4();

System.out.println(a.getNumber(10));

a=new ABC();

System.out.println(a.getNumber(10));

}

110

public class E1 {

public static void main(String[] args) {

char c='\0';

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

switch(i){

case 1: c='J';

System.out.print(c);

case 2:c='e';

System.out.print(c);

break;

case 3:c='p';

System.out.print(c);

default:System.out.print("好");

}

} }

}

Jeep好好

class B {

int x=100,y=200;

public void setX(int x){

x=x;

}

public void setY(int y){

this.y=y;

}

public int getXYSum(){

return x+y;

}}

public class A1{

public static void main(String args[]){

B b=new B();

b.setX(-100);

b.setY(-200);

System.out.print("sum="+b.getXYSum());

}}

sum=-100

public class E {

public static void main(String[] args) {

char x='你',y='e',z='吃';

if(x>'A'){

y='苹';

z='果';

}

else

y='酸';

z='甜';

System.out.print(x+"'"+y+"'"+z);

}

你'苹'甜

import java.io.IOException;

public class E {

public static void main(String args[]){

try{methodA();

}

catch (IOException e){

System.out.print("你好");

return;

}

finally{

System.out.print("fine thanks");

}

public static void methodA() throws IOException{

throw new IOException();

}}

你好fine thanks

class A5{

int m;

int getM(){

return m;

}

int seeM(){

return m;

}

class B4 extends A5{

int m;

int getM(){

return m+100;

}

public class E {

public static void main(String args[]){

B4 b=new B4();

b.m=20;

System.out.println(b.getM());

A5 a=b;

a.m=-100;

System.out.println(a.getM());

System.out.println(b.seeM());

System.out.println(b.m);

}

120

-100

class E4 {

double f(int x,double y){

return x+y;

}

int f(int x,int y){

return x*y;

}

public class E5{

public static void main(String args[]){

E4 b=new E4();

System.out.println(b.f(10,10));

System.out.println(b.f(10,10.0));

}

100

20.0

六．编程题

创建一注册窗口类，运行结果图如下，并写一监视器类，使用对象输出流将注册的用户对象写入磁盘文件，并创建对象输入流读入磁盘文件对象，在控制台输出。

例1：

package com.company;

import javax.swing.*;

import java.awt.*;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.io.*;

import java.util.HashMap;

//上面可以不背

//1. 创建一注册窗口类，运行结果图如下，并写一监视器类，使用对象输出流将注册的用户对象写入磁盘文件，

// 并创建对象输入流读入磁盘文件对象，在控制台输出。

public class Demo1 extends JFrame {

public static void main(String[]args){

Demo1 demo1= new Demo1();

demo1.init();

}

JLabel j1 = new JLabel("用户名");

JLabel j2 = new JLabel("密码");

JTextField jf1 = new JTextField();

JTextField jf2 = new JTextField();

JButton button1 = new JButton("保存");

JButton button2 = new JButton("取消");

void init() {

setLayout(new FlowLayout());

Box vbox = Box.createVerticalBox();

Box box1 = Box.createHorizontalBox();

box1.add(j1);

box1.add(jf1);

Box box2 = Box.createHorizontalBox();

box2.add(j2);

box2.add(jf2);

Box box3 = Box.createHorizontalBox();

box3.add(button1);

box3.add(button2);

vbox.add(box1);

vbox.add(box2);

vbox.add(box3);

this.add(vbox);

MyListener myListener = new MyListener();

button1.addActionListener(myListener);

this.setVisible(true);

this.pack();

}

class MyListener implements ActionListener {

public void actionPerformed(ActionEvent e) {

String user = jf1.getText();

String password = jf2.getText();

Person person = new Person();

person.setName(user);

person.setPassword(password);

try {

HashMap<String,String> map = new HashMap<String,String>();

map.put(user, password);

FileOutputStream outStream = new FileOutputStream("info.txt");

ObjectOutputStream objectOutputStream = new ObjectOutputStream(outStream);

objectOutputStream.writeObject(map);

outStream.close();

System.out.println("successful");

} catch (Exception w) {

w.getMessage();

}

try {

FileInputStream freader = new FileInputStream("info.txt");

ObjectInputStream objectInputStream = new ObjectInputStream(freader);

HashMap<String,String> map;

map = (HashMap<String, String>) objectInputStream.readObject();

System.out.println("用户名：" + user);

System.out.println("密码：" + map.get(user)); //通过用户名在哈希表中查询密码

} catch (Exception h) {

h.printStackTrace();

}

class Person{

String name;

String password;

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public String getPassword() {

return password;

}

public void setPassword(String password) {

this.password = password;

}

设有一文本文件english.txt的内容如下：

设计一程序按行读取该文件内容，并在该行的后面尾加上该英语句子中含有的单词书目，然后再将该行写入到一个名字为englishCountt.txt的文件中，并将该文件输出如下：

englishCount.txt内容:

The arrow missed the target. 句子中单词个数:5

They rejected the union demand. 句子中单词个数:5

Where does this road go to? 句子中单词个数:6

例2：

package com.company;

import java.io.*;

import java.util.ArrayList;

import java.util.List;

import java.util.Scanner;

import java.util.StringTokenizer;

// 通过Scanner类按行读出内容并写入可变长数组中

// 并创建字节流写入enlishCountt.txt中

public class Demo2 {

public static void main(String[] args) {

File file = new File("src\\english.txt");

Scanner sc = null;

List<String> array = new ArrayList<>();

try {

sc = new Scanner(file);

while (sc.hasNextLine()) {

array.add(sc.nextLine());

}

} catch (FileNotFoundException e) {

System.out.println("error:" + e);

}

String sum = "";

for (int i = 0; i < array.size(); i++) {

String str = array.get(i);

StringTokenizer anaylsis = new StringTokenizer(str, " ?.");

int number = anaylsis.countTokens();

sum = sum + str + " 句子中单词个数: " + number + "\n";

}

file = new File("src\\englishCountt.txt");

try {

FileOutputStream out = new FileOutputStream(file);

out.write(sum.getBytes());

out.close();

}catch (IOException e){

System.out.println("error"+e);

}

4. 编写GUI程序。首先编写一个封装学生信息的类，然后再编写一个窗口。

要求窗口使用三文本框和一个文本区为学生对象中的数据提供视图，其中三个文本框用来显示和更新学生对象的姓名、数学成绩和英语；文本区对象用来显示学生的姓名和总成绩。

窗口中有一个按钮，用户单击该按钮后，程序用3个文本框中的数据分别作为学生对象的姓名、数学成绩底和英语成绩，并将学生的姓名和总成绩显示在文本区中。

例4：

package com.company;

import javax.swing.*;

import java.awt.*;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

public class Demo4 {

public static void main(String[] args) {

Demo4_1 demo = new Demo4_1(300,200,500,300);

}

class Student {

String name;

int mathGrade;

int englishGrade;

int sumGrade;

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getMathGrade() {

return mathGrade;

}

public void setMathGrade(int mathGrade) {

this.mathGrade = mathGrade;

}

public int getEnglishGrade() {

return englishGrade;

}

public void setEnglishGrade(int englishGrade) {

this.englishGrade = englishGrade;

}

public int getSumGrade() {

sumGrade = mathGrade + englishGrade;

return sumGrade;

}

class Demo4_1 extends JFrame {

JTextField tName;

JTextField tMath;

JTextField tEnglish;

JTextArea textArea;

JButton btn;

MyListener myListener = new MyListener();

public Demo4_1(int x,int y,int width,int height){

init();

setBounds(x,y,width,height);

setVisible(true);

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

}

public void init(){

tName = new JTextField(10);

tMath = new JTextField(10);

tEnglish = new JTextField(10);

textArea = new JTextArea(5,20);

btn = new JButton("确定");

setLayout(new FlowLayout());

Box box1 = Box.createHorizontalBox();

box1.add(new JLabel("姓名："));

box1.add(tName);

Box box2 = Box.createHorizontalBox();

box2.add(new JLabel("数学成绩："));

box2.add(tMath);

Box box3 = Box.createHorizontalBox();

box3.add(new JLabel("英语成绩："));

box3.add(tEnglish);

Box vBox = Box.createVerticalBox();

vBox.add(box1);

vBox.add(box2);

vBox.add(box3);

vBox.add(textArea);

textArea.setEnabled(false);

vBox.add(btn);

add(vBox);

myListener.setView(this);

btn.addActionListener(myListener);

}

class MyListener implements ActionListener {

Demo4_1 view;

public void setView(Demo4_1 view) {

this.view = view;

}

@Override

public void actionPerformed(ActionEvent e) {

String name = view.tName.getText();

String math = view.tMath.getText();

String eng = view.tEnglish.getText();

String regex = "[^0-9]*";

if (name.equals("")||math.matches(regex)||eng.matches(regex)) {

view.textArea.setText("error");

return;

}

Student student = new Student();

student.setName(name);

student.setMathGrade(Integer.parseInt(math));

student.setEnglishGrade(Integer.parseInt(eng));

view.textArea.setText("");

view.textArea.append("姓名："+student.getName()+"\n");

view.textArea.append("总成绩："+student.getSumGrade()+"\n");

}

5. 使用Scanner类的实例解析一个文件中的价格数据，并计算平均价格，比如该文件的内容如下：

商品列表：

电视机,2567元/台

洗衣机,3562元/台

冰箱,6573元/台

例5：

package com.company;

import java.io.File;

import java.io.FileNotFoundException;

import java.util.Scanner;

public class Demo5 {

public static void main(String[] args) {

File file = new File("src\\goods.txt");

Scanner sc = null;

String regex = "[^0-9.]+";

int count = 0;

double sum = 0;

try {

double price = 0;

sc = new Scanner(file);

sc.useDelimiter(regex);

while(sc.hasNextDouble()) {

price = sc.nextDouble();

count++;

sum += price;

System.out.println(price);

}

double aver = sum / count;

System.out.println("平均价格：" + aver);

} catch (FileNotFoundException e) {

System.out.println("error:" + e);

}

6. 设计程序计算两个非零正整数的最大公约数和最小公倍数，要求两个非零正整数从键盘输入。(15分)

写一个类A，该类有一个方法public int f(int a, int b)，该方法返回a和b的最大公约数；
然后编写一个该类的子类B，要求子类重写方法f，而且重写的方法将返回a和b的最小公倍数。要求在重写的方法的方法体中首先调用被隐藏的方法返回a和b的最大公约数m，然后将乘积(a*b)/m返回。
在应用程序的主类中创建一个父类的对象，例如a，该对象a调用方法f返回最大公约数，然后a作为子类对象的上转型对象调用方法f返回最小公倍数。

例6：

package com.company;

class A {

//输入两个int类型a，b

//输出a和b的最大公约数

public int f(int a, int b) {

if (a < b) {

int c = a;

a = b;

b = c;

}

int r = a % b;

while (r != 0) {

a = b;

b = r;

r = a % b;

}

return b;

}

class B extends A {

//输入两个int类型a，b

//输出a和b的最小公倍数

@Override

public int f(int a,int b){

int m = super.f(a, b);

return a*b / m;

}

public class Demo6 {

public static void main(String[] args) {

//创建一个父类对象a，调用方法f返回最大公约数

A a = new A();

System.out.println(a.f(27, 18));

//a作为子类对象的上转型对象，调用方法f返回最小公倍数

a = new B();

System.out.println(a.f(27, 18));

}

chentao326

关注

3
点赞
踩
45

收藏

觉得还不错? 一键收藏
0
评论
JAVA练习题·期末

一、单选择题编译Java Application 源程序文件将产生相应的字节码文件，这些字节码文件的扩展名为( )。 A. java B. .class C. html D. .exe设 x = 1 , y = 2 , z = 3，则表达式 y＋＝z－－/＋＋x 的值是( )。 A. 3 B. 3. 5 C. 4 D. 5...
复制链接

扫一扫