首页 > 编程语言> 文章详细

JAVA练习题·期末

2022-01-11 22:02:40 阅读：149 来源： 互联网

标签：练习题 JAVA String int void 期末 new public out

一、单选择题

编译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

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

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

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

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

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

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

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

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

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

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

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

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”;

下列哪些语句关于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{ }

设有下面两个赋值语句：

a = Integer.parseInt(“12”);

b = Integer.valueOf(“12”).intValue();

下述说法正确的是（）。

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．不能用来返回对象

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

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

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

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

D．以上都不对

下列说法哪个正确？

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

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

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

D、属性必须是简单变量

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

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

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

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

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

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

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

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

抽象方法：　　（　　）

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

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

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

void的含义：　　（　　）

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

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

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

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

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

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

D．以上都不对

下列说法哪个正确？

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

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

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

D、属性必须是简单变量

下列说法哪个正确？　　（　　）

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

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

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

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. 每次读写的字节数不同

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

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

欲构造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)

下列代码的执行结果是： ( 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));

}

A、true,false B、true,true

C、false,true D、false,false

已知如下代码：

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异常

关于异常的含义，下列描述中最正确的一个是（ 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){ ... }

以下有关类的继承的说明中正确的是：( 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

以下由 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

关于以下程序段的说明正确的是（ 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()

用于定义类成员的访问控制权的一组关键字是( 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、所有的变量在使用之前必须初始化

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

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

下列代码执行之后，输出的结果为( 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

下列程序执行之后，将会输出( 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的最后一个元素，下面正确的代码是( B )。

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

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

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方法中有以下语句，则输出的结果是 sum=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方法中有以下语句，则输出的结果是 sum=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));

}

标签：练习题,JAVA,String,int,void,期末,new,public,out
来源： https://blog.csdn.net/chentao326/article/details/122442600

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

JAVA练习题·期末

一、单选择题

二．程序阅读题

六．编程题