一、单选择题
- 编译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。 （ ）
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) { }
- 下列哪个叙述是不正确的？
- 一个应用程序中最多只能有一个窗口。
- Jframe创建的窗口默认是不可见的。
- 不可以向Jframe窗口中添加Jframe窗口。
- 窗口可以调用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 for(int j=0; j sum+=b[i][j]; } } System.out.println("sum="+sum); int[] x = {125,21,5,168,98}; int min = x[0]; for (int i=1; i if(x[i] < min) min = x[i]; } System.out.println(min); int b[][]={{1}, {2,2}, {2,2,2}}; int sum=0; for(int i=0;i for(int j=0;j sum*=b[i][j]; } } System.out.println("sum="+sum); int[] x={125,21,5,168,98}; int max=x[0]; for(int i=1;i if(x[i]> max) max =x[i]; } System.out.println(max); 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)); } } 11 110 public class E1 { public static void main(String[] args) { char c=' '; 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 120 -100 20 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 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 map = (HashMap 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; } } 设计一程序按行读取该文件内容，并在该行的后面尾加上该英语句子中含有的单词书目，然后再将该行写入到一个名字为englishCountt.txt的文件中，并将该文件输出如下： englishCount.txt内容: The arrow missed the target. 句子中单词个数:5 They rejected the union demand. 句子中单词个数:5 Where does this road go to? 句子中单词个数:6 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 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分) 例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)); } }六．编程题
