java复习题

发表于 2023-06-01 更新于 2023-06-03 分类于杂事

=w=随随便便考啦

考完试发现都没有考到,老师没有放完所有题库o(╥﹏╥)o，考试还有填空题，还有English.

java判断题

1.设类B是类C的父类，语句B x1=new C( ); 是正确的。T

2.设类B是类C的父类，语句Ｃ x1=new Ｂ( ); 是正确的。F

3.Java中的包是专门用来存放类的，通常功能相近的类存放在相同的包中。T

4.Java中的String类型是一种基本数据类型。F

5.在Java中，含有抽象方法的类一定是抽象类。T

6.private修饰的成员变量不能被子类继承，因此在子类中也不为该类型变量分配空间。F

7.String对象和StringBuffer对象都是字符串类型，创建后的对象都可以在原地进行修改。F

8.在JAVA的集合框架中，Map接口是自Collection接口继承而来。F

9.在FileInputStream类的对象中,利用read(byte[] bytes)和read(byte[] bytes,int off,int len)方法读取一次数据后，bytes数组中的所有数据都是本次读取的数据。F

10.多线程是指将CPU资源按时间片分配到多个任务上，看似并行工作，实质上在同一时刻只有一个线程在工作；在一段时间之内，是多个线程在同时工作。T

11.在Java中，输出格式字符串时，也可以利用printf方法进行格式控制。T

12.利于Scanner类的对象进行输入字符串时，使用next()或者nextLine()方法都能取得字符串，二者没有什么差别。F

13.我们编写出程序之后，在必要的时候，可以通过DEBUG模式来调试程序，单步执行程序，观察变量的值的变化，从而尽快发现程序的逻辑错误。T

14.不含公共类的JAVA源文件名称可以随便命名，不受任何限制。T

15.在Windows操作系统和Linux操作系统运行的JAVA虚拟机没有什么差别。（）F

16.运行类路径下的HelloWorld.class文件，使用的命令是：java HelloWorld.class 。F

17.使用集成开发工具Eclipse来开发程序，可以省去源程序的编译步骤，直接运行程序。F

18.编译当前路径下的HelloWorld.java文件，使用的命令是：javac HelloWorld.java 。T

19.Java源程序中的字母大小写敏感，而在源文件命名时字母大小写不敏感。F

20.不含公共类的JAVA源文件名称可以随便命名，不受任何限制。T

21.运行类路径下的HelloWorld.class文件，使用的命令是：java HelloWorld.class 。F

22.Java语言和C语言一样，是面向过程的语言。F

23.1991年JDK1.0版本发布。F

24.James Gosling是Java语言的创始人之一。T

25.Java虚拟机可以将类文件（.class）在不同的操作系统上运行，从而实现跨平台特性。T

26.Java源程序中的字母大小写敏感，源文件名字母大小写不敏感。F

27.一个Java源文件的名称可以随便取，不受任何限制。F

28.java.lang包的Character类的isJavaIdentifierStart()方法的功能是用来判断某个字符串是否为合法Java标识符。F

29.java.lang包的Character类的isJavaIdentifierStart()方法的功能是用来判断某个字符是否为合法Java标识符首字符。T

**30.**java.util.Arrays类提供了诸多对数组进行操作的方法。使用其toString()方法可以对一维数组和二维数组展示其元素数值，equals()方法对一维数组和二维数组的两个数组比较其元素内容数值是否对应相等。F

31.两个数组对象利用“==”运算符比较若相等，则两数组的各个元素值一定对应相等；反过来说，两个数组的元素值都对应相等，则两个数组一定相等（==）。F

32和C语言相似，Java中的局部变量在声明后不赋初值，可以打印其变量的值。.F

33.同一作用域内的局部变量可以重复命名。F

34.Java中，某个四则运算表达式中的数值都是int数据类型，则计算之后的数值一定是int类型。T

35.Java中，某个四则运算表达式中的数值有一个是double类型，则计算之后的数值一定是double类型。T

36.Java基本数据类型都有对应的封装类。封装类能保留其数值，其他方面也没有太大的作用。F

37.在Java中，10/3这个表达式计算的结果是3.333333… 。F

38.在Java中，&&、||和 &、|都表示逻辑的与、或运算，二者使用起来没有什么差异。F

39.Java中break语句可用于循环结构或者switch-case结构，作用是终止当前循环或者分支语句。T

40.Java中continue语句的作用是结束本次循环，开始下一次循环。T

41.Java中的switch-case分支结构的特点是等值判断。它能用if分支结构进行改写。T

42.Java中的switch-case分支结构中，一旦控制表达式的计算结果与某个case值匹配成功，就执行完该case对应的语句块，即结束switch-case语句。F

43.Java中的while循环和do-while循环结构的区别是后者至少执行一次循环，而前者可能一次也不执行。T

44.continue; 语句只用于循环语句中，它的作用是跳出循环。F

45.对于基本数据类型和引用型数据类型来说，运算符“==”在比较两个变量是否相同时，含义没有什么差别。F

46.数组a的下标取值，取值范围为：从0到a.length。F

47.数组作为一个引用型的数据类型。对于数组a来说，a.length是数组a对象的一个属性。T

48.Java中，比较两个二维数组对象是否相同，就是比较这两个数组的每一个元素是否相同。F

49.Java中二维数组既可以表示m行n列的规则数据，也可以表示多行数据，每一行的列数不相同的不规则数组。T

50.Java中的类是一种数据类型，可以用来声明该类类型的变量。T

51.世界万物皆对象，从具有共同特征的对象中抽取出来静态属性和动态行为的共同特征，用类来进行描述。因此，对象是具体的，类是抽象的。T

52.在方法中使用不定长度参数时，声明的不定长参数必须在参数的最后一个。T

53.在如下代码中，两个变量str和i都是基本数据类型的变量。

1 2	String str="sdutcs”; int i =100;

54.局部变量可以与成员变量重名。T

55.类变量属于类和所有的对象所共享。利用类来引用类变量，对类变量的值做了改变，再利用对象来引用类变量，它们的值是相等的。T

56.实例变量是属于对象的。一个类的多个对象对实例变量可以设置不同的值。T

57.Java中的每个类都至少有一个构造方法，一个类如果没有显式地定义构造方法，系统会自动为这个类创建一个默认的无参的构造方法。T

58.有如下类的定义：

public class Rectangle {   
 public Rectangle(int l) {  //构造方法1
  if (l > 0) {
   w = l;
   h = l;
  }
 }
 public Rectangle(int w1, int h1) {  //构造方法2
  if (w1 > 0 && h1 > 0) {
   w = w1;
   h = h1;
  }
 }
}

下面使用Rectangle类创建一个对象，是否正确？

1	Rectangle rect=new Rectangle();

59 .枚举类型定义了具有删除功能的方法。F

60.-5%3的运算结果是2。F

61.在JDK1.8及以后的版本中，使用如下语句是否正确？

String str="*******";
  switch(str)
  {
     case "abc":
       //...
        break;
     case "def":
       //.....
       break;
   }

62.定义一个类时，无论有没有显示地给出构造方法的定义，系统都会提供一个默认的、无参的构造方法。F

63.构造方法返回值类型可以用void进行声明。F

64.定义类的方法时，形式参数是基本数据类型，为值传递；形式参数是一个引用数据类型，为地址传递。T

65.静态方法中能直接调用非静态方法和非静态成员变量。F

66.非静态的成员变量（实例变量）能被静态方法（类方法）和非静态方法（实例方法）所直接使用。F

67.静态的成员（类变量和类方法）能被静态方法（类方法）和非静态方法（实例方法）所直接调用。T

68.静态的成员变量（类变量）能被静态方法（类方法）和非静态方法（实例方法）所直接使用。T

69.default package包中的类也能被其他包中的类所引用。F

70.创建一个类的时候，如果未指定包名，处于无名包（default packge）中。其他包中的类无法引用该类。T

71.在JDK提供的系统类库中，使用java.lang包中的类时，可以直接使用，不必使用import来进行导入。T

72.private不能修饰构造方法。F

73.在定义一个类的时候，如果类的成员被private所修饰，该成员不能在类的外部被直接访问。T

74.Abstract method cannot be static. 抽象方法不能是静态方法。T

75.抽象类能实例化一个对象。如：

1	abstract class A(){}

可以调用如下语句创建对象a:

1	A a=new A();

76.JAVA抽象类中一定含有抽象方法。F

77.含有抽象方法的类一定是抽象类，抽象类中一定含有抽象方法。F

78.任何一种类类型，都可以使用new关键字来创建对象。F

79.用final关键字修饰的成员变量和局部变量是常量，常量的赋值次数只有一次。T

80.使用类的继承，目的是把多种对象间的共同的属性和共同行为抽取到父类中，因此子类对象和父类的关系表示是is-a的关系。T

81.有如下的父类和子类的定义，语法上是否正确?（）

class A{
 int a;
 public A(int a)
 {
  this.a=a;
 }
}
public class B extends A{
}

82.Java中被final关键字修饰的变量，若在声明时指定了初值，不能被重新赋值。T

83.当成员变量（属性）的访问权限不足时，可以通过增加公开的set方法和get方法对属性进行设置值或获取值来进行访问。T

84.使用上转型对象调用子类重写的成员变量时表现出多态性。F

85.使用上转型对象调用子类重写的方法时表现出多态性。T

86.抽象方法必须定义在抽象类中，所以抽象类中的方法都是抽象方法。F

87.Java类可以同时有2个直接父类。F

88.一个类如果实现一个接口，那么它就需要实现接口中定义的全部方法，否则该类必须定义成抽象类。T

89.接口和类不同，不具有单继承性，它可以继承多个接口。T

90.一个类的定义，可以继承一个父类的同时，再实现多个接口。T

91.Throwable 有两个重要的子类：Exception（异常）和 Error（错误）。异常是应用程序中可能的可预测、可恢复问题。大多数异常表示中度到轻度的问题；错误表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操作无关，而表示代码运行时 JVM（Java 虚拟机）出现的问题。T

92.程序中异常对象的产生方式有两种形式：1、系统执行过程中，产生异常对象；2、程序用throw关键字人为抛出异常对象。T

93.若异常发生时，它没有捕获，后续的程序不受任何影响，依然能正常执行。F

94.一个异常处理中 finally语句块可以不出现，也可以出现一次。T

95.Java语言中的所有异常类都是java.lang.Throwable的子类。T

96.非运行时异常（受检异常或编译异常），指的是RuntimeException以外的异常，如：IOException、SQLException等以及用户自定义的Exception异常，类型上属于Exception类及其子类。从语法上是必须进行处理的异常，需要使用try-catch（try-catch-finally）结构进行处理或者利用throws向上层抛出。如果不处理，程序就不能编译通过。T

97.String类提供了丰富的方法，其中包含许多与正则表达式相关的方法。如：split、replaceFirst、replaceAll、matches等等，可用于对与正则表达式相匹配的字符串进行分割、替换、判断是否匹配操作。T

98.String对象和StringBuffer对象都是字符串类型，创建后的对象都可以原地修改。F

99.字符串缓冲区类允许在当前对象上进行追加、增加、删除、修改字符的操作。而字符串对象不具备这一特点，只要改变就生成一个新的对象。T

100.System类中的currentTimeMills()方法，返回一个long类型的、当前时刻距离标准时间GMT之间的毫秒值。T

101.由Date到String的转换需要用到SimpleDateFormat类对象的format方法。T

102.由String到Date的转换需要用到SimpleDateFormat类对象的parse方法。T

103.java.math.BigInteger类可以表示比long类型更大的整数，还提供了诸多方法，用于对两个大整数对象的加、减、乘、除、取余、求幂、求最大公约数等等数学运算。T

104.java.lang.Math类是一个最终类。其中包含许多用来进行科学计算的类方法和常量，它们都是Math类的静态成员。T

105.对于泛型类或泛型接口，在编译过程中检查泛型类型的合法性，在对象进入和离开方法的边界处添加类型检查和类型转换的机制，并且泛型信息会保持到运行时阶段。F

106.在Collection集合中元素类型必须是相同的。F

107.在java.util.List接口的实现类java.util.ArrayList所表示的集合中，元素是有序的并且可以重复。该数据结构底层由数组来实现，能够精确地控制每个元素的插入位置，或者删除某个位置的元素，对元素的随机访问速度特别快。T

108.Set集合是有序的，不可以包含重复的对象。F

109.List集合是有序的，可以包含重复的对象。T

110.集合Set是通过键-值对的方式来存储对象的。F

111.在java.util.Set接口的实现类java.util.HashSet所表示的集合中，元素是无序的并且不允许重复，因此不能利用索引位置访问元素。T

112由于编码方式不同，表达同样的信息产生的数据量大小不同。.T

113.如果一个File表示的目录对象下有文件或者子目录，调用delete()方法也可以将它们删除。F

114.通过File类可对文件属性进行修改。T

115.在FileReader类的对象中，利用read(char[] buf)和read(char[] buf,int off,int len)方法读取数据后，buf数组中全部存放的是本次读取的数据。F

116.InputStream类中的close()方法是用于关闭流并且释放流所占的系统资源。T

117.BufferedInputStream和BufferedOutputStream不是字节缓冲流。F

118.在程序代码中，java.io.IOException异常必须被捕获或抛出，不能置之不理。T

119.Java系统的标准输入对象是System.in，标准输出对象有两个，分别是标准输出System.out和标准错误输出System.err。T

120.Serializable接口是个空接口，它只是一个表示对象可以串行化的特殊标记。T

121.对象串行化（序列化）机制是指将程序中对象的状态转化为一个字节流，存储在文件中。T

122.对象序列化是指将一个Java对象转换成一个I/O流中的字节序列的过程。T

123.文件缓冲流的作用是提高文件的读/写效率。T

124.通过IP地址可以连接到网络上指定计算机，端口号定位计算机中的某个应用程序，因此通过IP地址和端口号，就可以定位到网络上某主机上的应用程序。T

125.在网络通信中，对数据传输格式、传输速率、传输步骤等作了统一规定，只有通信双方共同遵守这个规定才能完成数据的交互，这种规定称为网络传输协议。T

126.TCP协议的特点是面向连接，即在传输数据前先在服务器端和客户端建立逻辑连接。T

127.使用TCP协议通信时，通信的两端以I/O流的方式进行数据的交互。T

128.利用TCP协议进行通信，客户端和服务器端建立起连接，形成传输数据的通道之后，进行大数据量的传输，是可靠的传输协议。T

129.在TCP协议通信时，客户端和服务器端建立起连接，通过Socket套接字的getInputStream()返回此套接字的输入流，getOutputStream()返回套接字的输出流。通信的双方通过输入、输出流读写数据。T

130.Socket类的方法 shutdownInput和shutdownOutput的作用是关闭相应的输入、输出流，不关闭网络连接。它将输入、输出流移动到末尾，再没有数据可以读写了，将以后发过来的数据忽略掉。T

131.由于UDP是面向无连接的协议，可以保证数据的完整性，因此在传输重要数据时建议使用UDP协议。F

132.Thread.sleep ()方法执行后，在指定时间内所有线程都会暂停，进入休眠状态。F

133.当调用一个正在进行线程的stop()方法时，该线程便会进入休眠状态。F

134.如果线程死亡，它就不能运行。T

135.在java程序中，只能使用英文的分号;，否则编译器会报告错误信息。T

136.Java语言在定义类时，可以将class写成Class。F

137.标识符可以为关键字。F

138常量就是程序中常常变化的数据。.F

139.在为double类型的变量赋值时，后面可以加字母D或d，也可以不添加。T

140.在进行自增（++）和自减（–）运算时，如果运算符++或–放在操作数的前面，则先进行自增或自减运算，再进行其他运算。T

141.运算符“&”和“&&”都表示“与”操作。T

142.while、do…while、for循环语句都可以进行嵌套，并且它们之间也可以互相嵌套。T

143.break语句可以在循环语句或者switch条件语句中使用。T

144.在switch语句中，每个case关键字后面必须有break。F

145.浮点数常量指的是数学中的小数。T

146.在Java中，小数会被默认是double类型的值。T

147.Java允许在一个程序中定义多个同名的方法，但是参数的类型或个数必须不同，这就是方法的重载。T

148.代码int[][] arr = new int[3][4]可以正确的定义一个二维数组。T

149.数组的最大下标的值比它的长度小1。T

150.Java中的每个类都至少有一个构造方法，一个类中如果没有定义构造方法，系统会自动为这个类创建一个默认的构造方法。T

151.构造方法不可以被继承。T

152.类中static修饰的变量或方法，可以使用类名或对象的引用变量访问。T

153.在静态方法内可以调用非静态方法。F

154静态代码块会随着类对象的创建而创建。F

155.不存在继承关系的情况下，也可以实现重写。F

156.Java中被final关键字修饰的变量，不能被重新赋值。T

157.抽象方法必须定义在抽象类中，所以抽象类中的方法都是抽象方法。F

158.Java中，子类可以覆盖父类中的任意方法。F

159.如果一个类继承了一个抽象类，但是没有完全复写父类的所有的抽象方法那么这个类也是抽象类。T

160.super调用父类构造方法的代码必须位于子类构造方法的第一行。T

161.循环嵌套是指在一个循环语句的循环体中再定义一个循环语句的语法结构。while、do…while、for循环语句都可以进行嵌套，并且它们之间也可以互相嵌套。T

162.break语句只用于循环语句中，它的作用是跳出循环。F

163.私有属性只能在它所在类中被访问，为了能让外界访问私有属性，需要提供一些使用public修饰的公有方法。T

164.子类重写的方法可以拥有比父类方法更加严格的访问权限。F

165.protected访问权限比默认访问权限严格。F

166.如将一个int类型的数转为byte类型，不会造成数据精度的丢失。F

167.同一个类的不同对象是完全独立的个体，它们分别拥有各自的属性。T

168.类中定义了一个有参的构造方法，系统还会再提供无参的构造方法。F

169.静态属性不能使用对象名直接访问。F

170.所谓方法重写，就是在同一个作用域内方法名相同但参数个数或者参数类型不同的方法。F

171.目标类型取值范围小于源类型时，需要进行强制类型转换。T

172.JAVA中常量名所有字母都大写，单词之间用下划线连接。T

173.在给变量起名时，computer和Computer是一样的。F

174.this关键字可以用来访问父类的成员变量和成员方法。F

175.JAVA中，一个接口允许继承多个接口。T

176.在Java中，含有抽象方法的类一定是抽象类。T

177.Java中continue语句的作用是结束本次迭代，开始下一次迭代。T

178.String是Java中定义的基本数据类型.F

179.Java语言不区分大小写.F

180.在Java中，变量的数据类型分为两种，即基本数据和引用数据类型。T

181.构造方法可以是静态的。F

182.在实例方法或构造器中，this用来引用当前对象，通过使用this可引用当前对象的任何成员。T

183.引用一个类的属性或调用其方法，必须以这个类的对象为前缀。F

184.You can always successfully cast an instance of a superclass to a subclass.F

185.A protected datum or method can be accessed by its subclasses in any package.T

答案

1-20TFTFT FFFFT TFTTF FTTFT

21-40 FFFTT FFFTF FFTTT FFFTT

41-60 TFTFF FTFTT TTFTT TTFFF

61-80 TFFTF FTTFT TFTTF FFFTT

80-100 FTTFT FFTTT TTFTT TTFTT

101-120 TTTTF FTFTF TTFTF TFTTT

121-140 TTTTT TTTTT FFFTT FFFTT

141-160 TTTFT TTTTT TTFFF TFFTT

160-180 TFTFF FTFFF TTFFT TTFFT

java选择

下列哪个叙述是正确的？B

A.一个类最多可以实现两个接口

B.允许接口中只有一个抽象方法

C.如果一个抽象类实现某个接口，那么它必须要重写接口中的全部方法

D.如果一个非抽象类实现某个接口，那么它可以只重写接口中的部分方法

关于对字符串缓冲区类的操作，如下代码执行结果是（）。B

1 2	StringBuffer buffer=new StringBuffer(); System.out.println(buffer.length()+" "+buffer.capacity());

A.0 0

B.0 16

C.16 16

D.16 0

下列程序代码运行结果是：（）。B

import java.util.*;    
public class Test {     
    public int hashCode() {        
         return 1;     
    }     
    public boolean equals(Object b) {        
        return true;    
   }    
    public static void main(String args[]) {        
        Set set = new HashSet();        
        set.add(new Test());        
        set.add(new String("ABC"));        
        set.add(new Test());        
        System.out.println(set.size());     
    }
}

A.1

B.2

C.3

D.4

正确配置classpath环境变量的方式是：（）。D

A.在系统环境变量classpath原有的字符串基础上，加上点符号和分号“.;”，然后再加上JDK安装路径下的bin目录

B.新建系统环境变量classpath，其值为：点符号和分号“.;”，然后再连上JDK安装路径下的bin目录

C.在系统环境变量classpath原有的字符串基础上，加上点符号和分号“.;”，然后再加上JDK安装路径下的lib目录

D.新建系统环境变量classpath，其值为：点符号和分号“.;”，然后再连上JDK安装路径下的lib目录

下面哪些元素不能作为Java标识符的首字符？（）B

A.字母

B.数字

C.下划线_

D.$

有如下一维数组的定义：
1
int[] arr1=new int[10];
arr1数组元素批量赋值（预设值为：100）的方式中，错误的有：B

A.Arrays.fill(arr1,100);

B.arr1.fill(100);

C.
1
2
for(int i=0;i<arr1.length;i++)
{ arr1[i]=100; }
D.
1
2
3
4
5
int i;
for(i=0;i<10;i++)
{
arr[i]=100;
}
JAVA中，下面哪个赋值表达式正确：（）D

A.float f=1.3;

B.char c=”a”;

C.byte b=257;

D.int i=10;
下面说法错误的是：D

A.int i=1,j=1;

System.out.print(i==j);

输出结果为true。

B.int i=100,j=100;

System.out.print(i==j);

输出结果为true。

C.Integer i=100,j=100;

System.out.print(i==j);

输出结果为true。

D.Integer i=1000,j=1000;

System.out.print(i==j);

输出结果为true。
执行完以下代码int[ ] x = new int[25]；后，以下哪项说明是正确的（）。A

A.x[24]为0

B.x[25]为0

C.x[0]为空

D.x[24]未定义

有如下程序代码，程序运行的结果是（）。A

1
2
3

StringBuffer buffer=new StringBuffer(); 
buffer.append("abc").append("123"); 
System.out.println(buffer);

A.abc123

B.abc

C.123

D.空行

关于类和对象的关系，下列说法哪种说法是错误的？A

A.类和对象都是具体的。

B.类是抽象的，对象是具体的。

C.一般情况下，在定义类之后，能创建无数个对象，可以说，类能化身千万。

D.类是引用型数据类型。

有如下程序代码，程序运行的结果是（）。D

String s1 = "sdut";
String s2 = "I love " + s1;
String s3 = "I love " + s1;
System.out.print(s2 == s3);
Sytem.out.println(" "+s2.equals(s3));

A.true false

B.true true

C.false false

D.false true

有如下代码，程序执行的结果是（）。B
1
2
3
String str1 = "sdut@sdut.edu.cn";
String[] strings = str1.split("u");
System.out.println(Arrays.toString(strings));
A. sd, t@sd, t.ed, .cn

B. [sd, t@sd, t.ed, .cn]

C. [sdu, t@sdu, t.edu, .cn]

D. sdu, t@sdu, t.edu, .cn
有如下代码，程序执行的结果是（）。A
1
2
3
int i= 110;
String str2="lucky"+i+2;
System.out.println(str2);
A.lucky1102

B.lucky112

C.1102lucky

D.112lucky
关于枚举类型，说法错误的是：（）。D

A.实质是类类型

B.可以定义若干个常量，如颜色、星期、月份等。

C.可利用类型名称.values()方法列出所有常量

D.其定义的位置可以在main方法中

如下程序代码输出的结果是：（）。A

public class Main {
    public static void main(String[] args) {
       int a=023;
       int b=0x10;
       System.out.println(a+" "+b);
    }
}

A.19 16

B.23 16

C.23 10

D.19 10

关于构造方法定义与作用，下列说法错误的是：（）。C

A.用来创建类的实例时调用的方法

B.调用该方法时，对实例变量赋值

C.定义时，方法名称与类名相同，返回值类型可以不写，也可以写成void

D.一个类的构造方法可以定义多个，多个构造方法的参数有明显区别。
假设定义了类 Test ,正确创建对象的格式是( ）。B

A.Test t = 1 ;

B.Test t = new Test() ;

C.Test t = new Test ;

D.Test t = Test() ;
下列选项中，( ) 发生时将调用类的构造方法。B

A.调用对象方法

B.创建对象

C.使用对象变量

D.类定义
以下有关构造方法的说法，正确的是： ____。A

A.一个类的构造方法可以有多个

B.构造方法在类定义时被调用

C.构造方法只能由对象的其它方法调用

D.构造方法可以和类同名，也可以和类名不同
JAVA中，void 的含义：（）。C

A.方法体为空

B.定义的方法没有形参

C.定义的方法没有返回值

D.方法的返回值不能参加算术运算
为了区分方法重载中同名的不同方法，要求（）。A

A.形式参数个数不同或者类型不同

B.返回值类型不同

C.调用时用类名或对象名做前缀

D.形式参数名称不同
在Java中，一个类可同时定义许多同名的方法，这些方法的形式参数的个数、类型或顺序各不相同，传回的值也可以不相同，这种面向对象程序特性称为（）。D

A.封装

B.继承

C.覆盖

D.重载

在下面的代码中，程序执行的结果将是：（）。D

public class Test {
  public static void main(String[] args) {
         String str = "123";
         System.out.println(str);
         change(str);
         System.out.println(str);
     }
    public static void change(String str){
      str = "456";
    }
}

1
2

456
123

1
2

456
456

1
2

123
456

1
2

123
123

关于以下代码的说明，正确的是（）。C

class Main {
    static int x = 10;
    static {
        x += 5;
        System.out.println("x=" + x);
    }
    public static void main(String args[ ])
    {
        System.out.println("x=" + x);
    }
    static {
        x /= 3;
        System.out.println("x=" + x);
    }
}

A.不能通过编译，因为缺少方法名和返回类型

B.不能通过编译，因为只能有一个静态初始化器

C.编译通过，执行结果为：

1
2
3

x=15
x=5
x=5

D.编译通过，执行结果为：

1
2
3

x=3
x=8
x=8

类中的一个成员方法被下面哪个修饰符修饰，该方法只能在本类被访问？（）C

A.pubic

B.protected

C.private

D.默认
哪种访问权限修饰的成员，在任何包、任何类中都可以进行访问?（）D

A.private

B.默认

C.protected

D.public
在Java中，针对类和成员提供了4种访问级别，以下控制级别由小到大的顺序是：（）。A

A.private< 默认 < protected < public

B.默认 < private< protected < public

C.protected < 默认 < private < public

D.protected < private< 默认 < public
在成员方法的访问控制修饰符中，规定访问权限只包含该类自身作用域和同包作用域的修饰符是（）。C

A.protected

B.public

C.默认

D.private
构造方法中调用其他构造方法时，this(,,…)须放在代码的第（）行。B

A.可以不出现

B.1

C.末

D.无限制
某个类的方法中，在成员变量和局部变量重名的情况下，（）变量优先使用。

如果要使用（）变量，必须使用关键字（）进行限定。A

A.局部成员 this

B.成员局部 this

C.类实例 this

D.实例类 this
下列关于修饰符使用的说法，错误的是（）。D

A.abstract不能与final并列修饰同一个类

B.abstract类中可以有private的成员

C.abstract方法必须在abstract类中

D.static方法中能访问非static的属性
在非静态成员方法中，可以使用关键字（）指代当前对象，访问类的其他非静态成员。A

A.this

B.super

C.static

D.public
Java关于方法的重写，哪个说法是错误的？（）C

A.对一个方法的重写必须发生在具有继承关系的两个类中，即子类对父类方法的重写。

B.方法的重写在一般意义上要求：两个方法的参数个数和类型以及返回值类型都一致。

C.方法的重写是一个类的两个方法，方法的名称相同，但参数不同。

D.子类对象调用子类重写了父类的方法时，优先调用子类的方法。
已知类的继承关系如下：
1
2
3
class Employee{}
class Manager extends Employee{}
class Director extends Employee{}
则下列语句通过编译的有哪些？（）A

A.Employee e=new Manager();

B.Director d= new Manager();

C.Director d= new Employee();

D.Manager m=new Director();
以下有关类的继承的叙述中，正确的是：（）。A

A.子类能直继承父类所有的私有属性和私有方法，但是没有访问权限

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

C.子类能继承父类的成员变量和变员方法，访问没有任何限制

D.子类不能继承父类的私有属性和私有方法
在Java中，要想让一个类继承另一个类，可以使用以下哪个关键字？（）C

A.inherits

B.implements

C.extends

D.modifies

如下代码，程序的输出结果将是：（）。D

class A {
    int a = 11;
    int b = 12;

    public void print() {
        System.out.println(a + " " + b);
    }
}

class B extends A {
    int a = 20;

    public void print() {
        System.out.println(a + " " + b);
    }
}

public class Main {
    public static void main(String[] args) {
        A aObj = new A();
        aObj.print();
        B bObj = new B();
        bObj.print();
    }
}

1 2	11 12 20 0

1 2	20 12 20 12

1 2	11 12 11 12

1 2	11 12 20 12

定义一个Java类时，如果前面使用关键字（）修饰，它是最终类，该类不可以被继承。B

A.private

B.final

C.static

D.public

关于关键字instanceof的说法不正确的是：（）。C

A.它不能作为标识符名称出现

B.它用来表示某变量所指向的对象是否是另一种类型的实例

1
2
3

Scanner sc=new Scanner(System.in);
boolean b=sc instanceof String;
//这种用法是正确的

1
2
3

Scanner sc=new Scanner(System.in);
boolean b=sc instanceof Object;
//这种用法是正确的

下面程序的输出结果为：（）。A

class A {
 double f(double x, double y) {
  return x * y;
 }
}

class B extends A {
 double f(double x, double y) {
  return x + y;
 }
}

public class Test {
 public static void main(String args[]) {
  A obj = new B();
  System.out.println(obj.f(4, 6));
 }
}

A.10.0

B.24.0

C.2.0

D.11.0

有如下程序代码，哪处出现编译错误？（）D

class Father {
 int a = 100;    // A
 final public void print() { // B
  System.out.println(a);
 }
}

class Child extends Father { 
 int a = 200;                // C
 public void print() {       // D
  System.out.println(a);  
 }
}

A.A处

B.B处

C.C处

D.D处

有如下程序代码，哪处出现编译错误？（）B

final class Father{           //A
 int a=100;
}
 class Child  extends Father{  //B
  int b=200;
 }
 public class B{              //C
  public static void main(String[] args) {
   Child child=new Child();   //D  
 }  
 }

A.A处

B.B处

C.C处

D.D处

有如下程序代码：

class Dog{ }
class Cat { }
public class Test{
 public static void main(String[] args) {
  Dog dog=new Dog();
  Cat cat=new Cat();
  System.out.println(cat instanceof Dog);    //A
  System.out.println(dog instanceof Dog);   //B
 }  
 }

关于A、B两段代码，下列哪种说法是正确的？（）A

A.输出：

1 2	false true

B.输出：

1
2

true
true

C.输出：

1 2	false false

D.出现语法编译错误，程序不能执行

在下面的代码中，若要在子child类中对父类的addvalue方法进行重写，下面对于child类中的addvalue方法的声明哪个是正确的：（）。A
1
2
3
4
5
6
7
8
9
10
class father {
public int addvalue(int a, int b) {
int s = a + b;
return s;
}
}

class child extends father {

}
A.public int addvalue(int i,int j)

B.void addvalue(int a,int b)

C.void addvalue(double i)

D.int addvalue(int a)

有如下程序代码，编译(执行)的结果为：C

class A {
 int v1 = 10;
 int v2 = 10;

 public void m1() {
  System.out.println("A m1");
 }

 public void m2() {
  System.out.println("A m2");
 }
}

class B extends A {
 int v2 = 20;
 int v3 = 20;

 public void m2() {
  System.out.println("B m2");
 }

 public void m3() {
  System.out.println("B m3");
 }
}

public class Main {
 public static void main(String[] args) {
  A a = new B();
  a.m1();
  a.m2();
  a.m3();
  System.out.println(a.v1);
  System.out.println(a.v2);
  System.out.println(a.v3);
 }
}

A m1
B m2
A m3
10
10
10

A m1
B m2
B m3
10
10
20

1 2	a.m3(); 编译错误 System.out.println(a.v3); 编译错误

1	a.m3(); 编译错误

有如下代码，程序执行的结果是：（）。A

class A {
 int v1 = 10;
 int v2 = 10;

 public void m1() {
  System.out.println("A m1");
 }

 public void m2() {
  System.out.println("A m2");
 }
}

class B extends A {
 int v2 = 20;
 int v3 = 20;

 public void m2() {
  System.out.println("B m2");
 }

 public void m3() {
  System.out.println("B m3");
 }
}

public class Main {
 public static void main(String[] args) {
  A a = new B();
  a.m1();
  a.m2();
  System.out.println(a.v1);
  System.out.println(a.v2);
 }
}

A m1
B m2
10
10

B m1
B m2
20
20

A m1
A m2
10
10

A m1
B m2
10
20

有如下程序代码，程序编译(执行)的结果为：B

class A {
 int v1 = 10;
 int v2 = 10;
 public A() {
 }
 public void m1() {
  System.out.println("A m1");
 }
 public void m2() {
  System.out.println("A m2");
 }
}

class B extends A {
 int v2 = 20;
 int v3 = 20;
 public B() {
 }
 public void m2() {
  System.out.println("B m2");
 }
 public void m3() {
  System.out.println("B m3");
 }
}
public class Main {
 public static void main(String[] args) {
  B b = new B();
  b.m1();
  b.m2();
  b.m3();
  System.out.println(b.v1);
  System.out.println(b.v2);
  System.out.println(b.v3);
 }
}

B m1
B m2
B m3
20
20
20

A m1
B m2
B m3
10
20
20

A m1
B m2
B m3
20
20
20

A m1
B m2
B m3
20
10
20

有如下程序代码，编译(执行)的结果为：C

class A {
 int v1 = 10;
 int v2 = 10;
 public A() {
 }
 public void m1() {
  System.out.println("A m1");
 }
 public void m2() {
  System.out.println("A m2");
 }
}

class B extends A {
 int v2 = 20;
 int v3 = 20;
 public B() {
 }
 public void m2() {
  System.out.println("B m2");
 }
 public void m3() {
  System.out.println("B m3");
 }
}
public class Main {
 public static void main(String[] args) {
  A a = new B();
  a.m1();
  a.m2();
  a.m3();
  System.out.println(a.v1);
  System.out.println(a.v2);
  System.out.println(a.v3);
 }
}

A m1
B m2
B m3
10
20
20

A m1
B m2
B m3
10
10
20

1 2	a.m3(); 编译错误 System.out.println(a.v3); 编译错误

1	a.m3(); 编译错误

有如下程序代码，编译(执行)的结果为：D

class A {
 int v1 = 10;
 int v2 = 10;
 public A() {
 }
 public void m1() {
  System.out.println("A m1");
 }
 public void m2() {
  System.out.println("A m2");
 }
}

class B extends A {
 int v2 = 20;
 int v3 = 20;
 public B() {
 }
 public void m2() {
  System.out.println("B m2");
 }
 public void m3() {
  System.out.println("B m3");
 }
}
public class Main {
 public static void main(String[] args) {
  A a = new B();
  a.m1();
  a.m2();

  System.out.println(a.v1);
  System.out.println(a.v2);
 }
}

A m1
A m1
10
10

B m2
B m2
10
20

A m1
B m2
10
20

A m1
B m2
10
10

有如下程序代码，执行的结果为：D

class Base {
    void test() {
        System.out.println("Base.test()");
    }
}

class Child extends Base {
    void test() {
        System.out.println("Child.test()");
    }
}

public class Main {
    public static void main(String[] a) {
        Child anObj = new Child();
        Base baseObj = anObj;
        baseObj.test();
    }
}

1 2	Child.test() Base.test()

1 2	Base.test() Child.test()

1	Base.test()

1	Child.test()

有如下程序代码，程序执行的结果是：（）。A

class Base {
 static void test() {
  System.out.println("Base.test()");
 }
}

 class Child extends Base {
 static void test() {
  System.out.println("Child.test()");
  Base.test();     // Call the parent method
 }
}

public class Main {
    public static void main(String[] a) {
        Child.test();
    }
}

1 2	Child.test() Base.test()

1 2	Base.test() Base.test()

1 2	Base.test() Child.test()

1	Runtime error. Cannot override a static method by an instance method

有如下程序代码，程序编译(执行)的结果是（）。D

class Father {
    int a = 100;
    int b = 200;

    public void print() {
        System.out.println(a + " " + b);
    }
}

class Child extends Father {
    int b = 300;
    int c = 400;

    public void print() {
        System.out.println(a + " " + b + " " + c);
    }

    public void printExtend() {
        System.out.println(c);
    }

}

public class Main {
    public static void main(String[] a) {
        Father obj = new Child();
        System.out.println(obj.a);   / AA语句
        System.out.println(obj.b);   // BB语句
        obj.print();       // CC语句
        obj.printExtend(); // DD语句
    }
}

100
200
100 300 400
400

100
300
100 300 400
400

100
300
100 200 400
400

DD处有编译错误

有如下程序代码，执行的结果是（）。D

class Father {
    int a = 100;
    int b = 200;

    public void print() {
        System.out.println(a + " " + b);
    }
}

class Child extends Father {
    int b = 300;
    int c = 400;

    public void print() {
        System.out.println(a + " " + b + " " + c);
    }

    public void printExtend() {
        System.out.println(c);
    }

}

public class Main {
    public static void main(String[] a) {
          Father obj=new Child();
          System.out.println(obj.a+" "+obj.b);   
          obj.print();  
    }
}

1 2	100 200 100 200 400

1 2	100 300 100 300 400

1 2	100 300 100 200 400

1 2	100 200 100 300 400

有如下父类、子类及测试类的定义，程序执行后，输出结果是true的语句为：（）。C

class Father {
}
class Child extends Father {
}

public class Main {
    public static void main(String[] a) {

          Father f1=new Father();
          System.out.println(f1 instanceof Father);  //AA语句
          System.out.println(f1 instanceof Child);   //BB语句
          
          Father obj=new Child();
          System.out.println(obj instanceof Father);  //CC语句
          System.out.println(obj instanceof Child);   //DD语句
          
          Child c1=new Child();
          System.out.println(c1 instanceof Father);   //EE语句
          System.out.println(c1 instanceof Child);    //FF语句
    
    }
}

A.AA、BB、CC、DD、EE、FF

B.AA、BB、CC、DD、EE

C.AA、CC、DD、EE、FF

D.AA、BB、DD、FF

有如下父类、子类及测试类的定义，程序执行结果是：（）。D

class Father {
 int a =100;
 public void print() {
  System.out.println(a);
 }
}
class Child1 extends Father {
 int a =200;
 public void print() {
  System.out.println(a);
 }
}
class Child2 extends Father {
 int a =300;
 public void print() {
  System.out.println(a);
 }
}
public class Main {
    public static void main(String[] a) {
        Father obj1;
          obj1=new Child1();
          System.out.println(obj1.a);
          obj1.print(); 
          
          obj1=new Child2();
          System.out.println(obj1.a);
          obj1.print(); 
    }
}

有如下代码，程序执行结果是：（）。C

abstract class Person {
 public abstract void eat();
}
public class Main {
    public static void main(String[] a) {

          Person p = new Person() {
           public void eat() {
            System.out.println("eat something");
           }
          };
          p.eat();
    }
}

空字符串

编译错误

eat something

运行错误

有如下代码，程序的执行结果是（）。C

interface Person {
 public void eat();
}

public class Main {
    public static void main(String[] a) {

          Person p = new Person() {
           public void eat() {
            System.out.println("eat something");
           }
          };
          p.eat();
    }
}

空字符串

编译错误

eat something

运行时错误

下面关于JAVA面向对象的理解，说法中不正确的是：（）。A

A.Java中，一个类只允许实现一个接口

B.抽象类中允许有非抽象方法的存在

C.静态的成员变量可以直接用类名调用

D.通过super可以调用父类的构造函数
以下关于继承的叙述正确的是（）。A

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

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

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

D.在Java中，接口也具有单继承性
判断两个对象的引用是否相同，使用（）方式进行判断。D

A.equals()

B.hashcode()

C.toString()

D.==
程序代码中包含产生CheckedException受检异常（非运行时异常）的语句时，（）。B

A.如果程序错误，就使用try-catch语句处理异常；否则，不必处理

B.必须进行处理，或使用try-catch语句处理异常，或在调用方法上使用throws将其抛出

C.只能使用try-catch语句处理

D.可以置之不理
关于Java中异常的叙述，正确的是：（）。D

A.异常是程序编写过程中代码的语法错误

B.异常是程序编写过程中代码的逻辑错误

C.异常出现后程序的运行马上中止

D.异常是可以捕获和处理的
关于异常，下列说法正确的是 ( )。A

A.程序运行过程中，若产生异常，它是某种异常类型的对象

B.一旦程序运行，异常对象将被创建

C.为了保证程序运行速度，要尽量避免异常控制

D.以上说法都不对
Java中用来抛出异常的关键字是：（）。C

A.try

B.catch

C.throw和throws

D.finally
在异常处理时，将可能发生异常的代码放在（）语句块中，后面紧跟着一个或多个（）语句块，还可以再跟零个或一个（）语句块。B

A.catch、try、finally

B.try、catch、finally

C.try、finally、exception

D.exception、try、finally
关于try语句对应的多个catch子句中，若捕获的异常类型有父子类关系时，它们的排列下列哪种是正确的( ) 。B

A.异常父类在先，异常子类在后

B.异常子类在先，异常父类在后

C.有继承关系的异常不能同时出现在同一个try程序段之后

D.先后顺序无所谓
在异常处理中，如释放资源、关闭文件、关闭数据库等由（）来完成。C

A.try子句

B.catch子句

C.finally子句

D.throw子句

关于字符串的方法，如下代码执行结果是（）。C

1 2	String fileName = "sdut@sdut.edu.cn"; System.out.println(fileName.lastIndexOf("."));

A.9

B.10

C.13

D.12

关于字符串的方法，如下代码执行结果是 ____ 。A

String fileName = “sdut@sdut.edu.cn“;
System.out.println(fileName.substring(1,4));

A.dut

B.sdut

C.sdu

D.dut@

关于字符串的方法，如下代码执行结果是（）。B

1 2	String fileName = "中国China"; System.out.println(fileName.indexOf("国"));

A.0

B.1

C.2

D.3

关于字符串的方法，如下代码执行结果是（）。A
1
2
String fileName = "中国China";
System.out.println(fileName.length());
A.7

B.9

C.11

D.13

关于字符串的比较，如下代码执行结果是（）。B

String s1 = "imooc";
String s2 = "I love " + s1;
String s3="I love imooc";
System.out.println(s2 == s3);

A.true

B.false

C.0

D.1

关于字符串的构造方法，如下代码执行结果是（）。B

1
2
3

String str="ABCDEFG";
char[] chars=str.toCharArray(); 
System.out.println(new String(chars,1,3));

A.ABC

B.BCD

C.AB

D.BC

关于字符串的构造方法，下面代码执行结果是（）。D(题有问题)
1
2
3
String str="中国123";
byte[] bytes=str.getBytes();
System.out.println(new String(bytes,2,3));
A.123

B.国

C.国12

D.国1
关于字符串的方法，如下代码执行结果是（）。C(应该是10才对题有问题这里可能是GBK编码)
1
2
String str="中国GOOD";
System.out.println(str.getBytes().length);
A.6

B.7

C.8

D.9
关于字符串的方法，如下代码执行结果是（）。A
1
2
String str="中国GOOD";
System.out.println(str.toCharArray().length);
A.6

B.7

C.8

D.9

关于字符串的相关使用，如下代码执行结果是（）。B

String str1 = "110"; 
int i=Integer.parseInt(str1,2);
int i1=i+2;
System.out.println(i1);

A.112

B.8

C.110

D.10

关于字符串的方法，如下代码执行结果是（）。D

1
2
3

String str1 = "sdut@sdut.edu.cn";   
System.out.println(str1.toUpperCase());
System.out.println(str1);

1 2	sdut@sdut.edu.cn SDUT@SDUT.EDU.CN

1 2	sdut@sdut.edu.cn sdut@sdut.edu.cn

1 2	SDUT@SDUT.EDU.CN SDUT@SDUT.EDU.CN

1 2	SDUT@SDUT.EDU.CN sdut@sdut.edu.cn

关于字符串的方法，如下代码执行结果是（）。A

String str1 = "sdut@sdut.edu.cn";
String str2 = str1.toLowerCase();
System.out.println(str2);
System.out.println(str1);
System.out.println(str1 == str2);

1
2
3

sdut@sdut.edu.cn
sdut@sdut.edu.cn
true

1
2
3

sdut@sdut.edu.cn
sdut@sdut.edu.cn
false

1
2
3

sdut@sdut.edu.cn
SDUT@SDUT.EDU.CN
true

1
2
3

sdut@sdut.edu.cn
SDUT@SDUT.EDU.CN
false

关于字符串的方法，如下代码执行结果是（）。B

1
2
3

String str1 = "abcd"; 
String str2="sdut";
System.out.println(str1.compareTo(str2)>0);

A.true

B.false

C.1

D.-1

关于字符串的方法，如下代码执行结果是（）。A

1
2
3

String str1 = "sdut12"; 
String str2="sDut12";
System.out.println(str1.equalsIgnoreCase(str2));

A.true

B.false

C.0

D.1

String类的equals方法，其作用是：（）D

A.比较2个字符串对象是否为同一个对象

B.比较2个字符串对象的字符长度是否相同

C.比较2个字符串对象的首地址是否相同

D.比较2个字符串对象的字符序列是否相同

关于字符串的方法，如下代码执行结果是（）。A

String str = "    abcd123";
  str.toUpperCase();
  str.trim();
  System.out.println(str);

abcd123

abcd123

ABCD123

ABCD123

关于字符串的相关操作，如下代码执行后输出的结果是：（）。A

String str1="abc";
String str2=str1.toUpperCase();
String str3=str1.toLowerCase();
System.out.println(str1==str2);
 System.out.println(str1==str3);

1 2	false true

1 2	false false

1
2

true
true

1 2	true false

下列关于字符串对象的叙述中，错误的是（）。B

A.字符串常量是对象

B.String 对象存储字符串的效率比 StringBuilder 高

C.字符串对象具有不变性

D.String类提供了许多用来操作字符串的方法：连接、提取、查询等，一旦返回的结果与原字符串不同，就生成一个新对象，而不是在原字符串进行修改
已知: String s="abcdedcba”; 则 s.substring(3,4) 返回的字符串是哪个?（）C

A.cd

B.de

C.d

D.dedc
关于字符串对象的比较，==用于比较字符串对象的（）是否相同；equals()方法用于比较字符串对象的（）是否相同。A

A.存储地址字符序列

B.存储地址存储地址

C.字符序列存储地址

D.字符序列字符序列
执行如下两行代码之后，则内存中存在几个字符串对象?（）C
1
2
String str="abc";
str+="def";
A.1

B.2

C.3

D.4

关于对StringBuffer类对象的操作，下面代码执行后，输出结果是（）。A

1
2
3

StringBuffer buffer=new StringBuffer();
StringBuffer buffer2=buffer.append("abc").append("123");
System.out.println(buffer==buffer2);

A.true

B.false

C.0

D.1

StringBuffer类对象与String类对象相比，它的优势在于其可以在原来对象基础上进行字符的更改，但它在（）方面不如String类提供的功能丰富。D

A.插入、追加

B.删除

C.修改

D.查询、检索
StringBuffer类维护字符的容量和长度的概念。有该类的对象buf1，其容量与长度的关系是：（）。A

A.buf1.capacity()>=buf1.length()

B.buf1.capacity()<=buf1.length()

C.buf1.size()>buf1.=length()

D.buf1.size()<buf1.=length()
关于StringBuffer对象的操作，有如下程序代码，程序运行的结果是（）。B
1
2
3
4
5
StringBuffer buf1=new StringBuffer("abcd");
StringBuffer buf2=buf1.append("def");
System.out.print(buf1+" ");
System.out.print(buf2+" ");
System.out.println(buf1==buf2);
A.abcd abcddef false

B.abcddef abcddef true

C.abcd abcddef true

D.abcddef abcddef false

有如下程序代码，程序运行的结果是（）。A

1
2
3

StringBuffer buf=new StringBuffer("Beijing2008");
buf.insert(7, "@");
System.out.println(buf);

1	Beijing@2008

1	Beijing2008@

1	@Beijing2008

1	Beijing#2008

关于对StringBuffer对象的操作，有如下程序代码，程序运行的结果是（）。B
1
2
3
StringBuffer buf=new StringBuffer("abcde");
buf.reverse();
System.out.println(buf);
A.abcde

B.edcba

C.abcd

D.edcb
阅读下面的程序段，以下表达式的值为true的是哪个?（）B
1
2
3
4
String str1=new String("java");
String str2=new String("java");
StringBuffer str3=new StringBuffer("java");
StringBuffer str4=new StringBuffer("java");
A.str1==str2

B.str1.equals(str2)

C.str3==str4

D.str3.equals(str4)

E.str1==str3

F.str1.equals(str4)
Java中对日期数据按照国家和地区的使用习惯进行格式化字符串及日期格式转换，要使用到java.text.SimpleDateFormat类。C

把日期转换成符合格式的字符串，调用（）方法；把某格式的字符串转换成日期对象，调用（）方法。

A.parse format

B.parse dateFormat

C.format parse

D.format parseDate
利用java.util.Date类创建对象，欲得到系统当前时间的语句为：（）。A

A.new Date();

B.new Date(0);

C.new Date(NOW);

D.new Date(-1);
关于基本类型的数据与其封装类对象之间的转换，下面说法错误的是( )。C

A.Integer类型的对象可以通过拆箱，可以自动转化为int基本类型的数值。

B.int类型的数据通过装箱操作，可以自动转换成Integer类型的对象。

C.int类型的数值通过装箱操作，可以自动封装为Long 类型对象

D.long类型的数据通过装箱操作，可以自动封装为Long类型对象

下列程序代码运行结果是：（）。C

import java.util.ArrayList;
    import java.util.List;
public class Test {
     public static void main(String args[]) {
        List list = new ArrayList();
        list.add(new Test());
        list.add(new String(""ABC""));
        list.add(new Test());
        System.out.println(list.size());
     }
    }

A.1

B.2

C.3

D.4

返回Collection 中的元素数量的方法是（）。C

A.length()

B.capacity()

C.size()

D.count()
Java的集合框架中重要的接口java.util.Collection定义了许多方法。选项中哪个方法不是Collection接口所定义的？( )C

A.int size()

B.boolean containsAll(Collection c)

C.compareTo(Object obj)

D.boolean remove(Object obj)
向Collection中增加数据的方法是（）。B

A.insert

B.add

C.append

D.concat
欲构造ArrayList类的一个实例，此类实现了List接口，下列哪个写法是正确的？B

A.ArrayList myList=new Object()；

B.List myList=new ArrayList()；

C.ArrayList myList=new List()；

D.List myList=new List();
字符串“山东理工”使用UTF-8编码格式得到字节数组bytes，下面哪条语句能够还原为原字符串信息?B

A.new String(bytes)

B.new String(bytes, “UTF-8”)

C.new String(bytes, “GBK”)

D.bytes.toString()
File类中以字符串形式返回文件绝对路径的方法是哪一项？（）C

A.getParent()

B.getName()

C.getAbsolutePath()

D.getPath()
想得到文件（目录）的名称，如：
1
2
File file1=new File(""F:\\abc\\""); //--> abc
File file2=new File(""F:\\abc.txt""); //--> abc.txt
需要使用java.io.File类的对象调用（）方法。B

A.toString()

B.getName()

C.getAbsolutePath()

D.getParent()

要从“file.dat”文件中读出第10个字节到变量c中，下列哪个方法适合? （）C

1 2	FileInputStream in=new FileInputStream("file.dat"); int c=in.read();

1
2
3

RandomAccessFile in=new RandomAccessFile("file.dat"); 
in.skip(9); 
int c=in.readByte();

1
2
3

FileInputStream in=new FileInputStream("file.dat"); 
in.skip(9); 
int c=in.read();

1
2
3

FileInputStream in=new FileInputStream("file.dat"); 
in.skip(10); 
int c=in.read();

在编写Java程序时，若需要使用到标准输入输出流的若干个类，导入包时宜在程序的开头写上（）语句。C

A.import java.awt.* ;

B.import java.applet.Applet;

C.import java.io.*;

D.import java.awt.Graphics;
在输入流的read方法返回哪个值，表示读取结束？C

A.0

B.1

C.-1

D.null
利用FileInputStream和FileOutputStream读写文件，哪个方法不抛出IOException?( )A

A.两个类的构造方法

B.read

C.write

D.close
desc tablename; 命令的作用是：C

A.连接数据库

B.创建数据库

C.查看表结构的详细信息

D.删除数据库
关于Java，以下描述错误的是：A

A.Java编译成字节代码，字节代码可以在任何操作系统下直接运行。

B.java的源代码后缀名是 java，编译后的字节代码后知名是 class。

C.使用 Javac 对源代码进行编译，java是虚拟机。

D..class 文件需要在java虚拟机上运行。
关于Java文件的描述，错误的是：D

A.Java文件中定义的类名和文件名保持一致。

B.一个Java文件中可以定义多个class。

C.一个Java文件中只能定义一个public class

D.main函数不一定定义成static
Java编程中，常见的错误类型不包括：A

A.System Errors

B.Syntax Errors

C.Runtime Errors

D.Logic Errors
关于Java代码，描述错误的是B

A.在Eclipse中，所有的Java源文件应该都保存在src这个目录中。

B.package edu.cuit.screen; 这个包申明表示该Java源文件的目录对应：edu/cuit.screen.java

C.public static void main(String[] args)
{
…
}

作为一个程序的主函数入口，String[] args这个参数不能省略。

D.主函数的申明是固定的，如：
public static void main(String[] args)
且返回值一定是void
关于Scanner,错误的描述是：C

A.Scanner 在使用前必须使用new 创建一个实体，且赋值给一个Scanner类型的变量，如下：
Scanner input = new Scanner(System.in);

B.Scanner 可以读取整数、double、浮点、字符串、字符等基本数据类型。

C.每次读取一个数据必须新建立一个Scanner对象，如下述代码。
Scanner input1 = new Scanner(System.in);
int v1 = input1.nextInt();
Scanner input2 = new Scanner(System.in);
int v2 = input2.nextInt();

D.Scanner可以从不同的输入源读取数据，不单是控制台。
关于Scanner,错误的描述是：C

A.Scanner 在使用前必须使用new 创建一个实体，且赋值给一个Scanner类型的变量，如下：
Scanner input = new Scanner(System.in);

B.Scanner 可以读取整数、double、浮点、字符串、字符等基本数据类型。

C.每次读取一个数据必须新建立一个Scanner对象，如下述代码。
Scanner input1 = new Scanner(System.in);
int v1 = input1.nextInt();
Scanner input2 = new Scanner(System.in);
int v2 = input2.nextInt();

D.Scanner可以从不同的输入源读取数据，不单是控制台。
Java属于以下哪种语言（）C

A.机器语言

B.汇编语言

C.高级语言

D.以上都不对
下列选项中，哪一个是多行注释符号（）D

A.//**//

B./*/*

C.//

D./**/
下列关于变量作用域的说法中，正确的是（）C

A.在main()方法中任何位置定义的变量，其作用域为整个main()方法。

B.代码块中定义的变量，在代码块外也是可以使用的。

C.变量的作用域为：从定义处开始，到变量所在代码块结束的位置。

D.变量的作用域不受代码块的限制。
以下标识符中，不合法的是（）C

A.use

B.$inner

C.class

D.login_1
下列选项中，不属于Java中关键字的是（）C

A.if

B.float

C.Final

D.try
下列选项中，属于布尔常量的是（）C

A.198

B.2e3f

C.true

D.null
以下关于变量的定义，正确的是（）A

A.int a=10;

B.

b=2；

C.int =20；

D.int a；b=a+10；
下列选项中，哪一个不能通过编译（）C

A.byte a=1;

B.short b=100;

C.int c=’a’;

D.long d=8888888888888888;
下列浮点数的定义中，正确的是（）A

A.

float f = 1F;

B.

float f = 1.0;

C.

float f = ‘1’;

D.

float f = “1”;
关于变量类型转换的描述中，正确的是（）D

A.只有数据类型相同的数据才能进行运算。

B.byte类型和short类型的数据是不能一起运算的。

C.两个byte类型数据一起运算时会把先自动提升到int类型再运算。

D.两个整型在一起运算时，结果一定是int。
若int a = 7;a %= 2;则执行后，变量a的值是（）B

A.7

B.1

C.2

D.3
下列选项中，不属于赋值运算符的是（）C

A.-=

B.=

C.==

D.*=
下列选项中，不属于比较运算符的是（）A

A.=

B.==

C.<

D.<=
下列关于条件语句的描述中，错误的是（）C

A.if语句中的条件表达式是一个布尔值。

B.选择语句分为if条件语句和switch条件语句。

C.switch语句中的表达式只能是布尔类型的值。

D.switch语句只能针对某个表达式的值作出判断。

请阅读下面的程序

public class SwitchDemo3 {
    public static void main(String[] args) {
        char c = ‘B’;
        switch(c) {
            case ‘A’:System.out.println(“优”);break;
            case ‘B’:System.out.println(“良”);break;
            case ‘C’:System.out.println(“差”);break;
        }
    }
}

下列选项中，哪一个才是程序的运行结果（）B

A.优

B.良

C.差

D.编译失败

while语句的循环体中不能包含的语句是（）B

A.while语句

B.方法定义语句

C.if语句

D.switch语句

请阅读下面的程序

public class Example  {                                                            
    public static void main(String[] args) {                                  
        int x = 1;                                                                            
        do {                                                                                   
            x++;                                                                        
        } while (x <= 4);      
        System.out.println("x = " + x);                                      
    }                                                                                   
}

程序的运行结果是（）C

A.3

B.4

C.5

D.6

请阅读下面的程序

public class Test {
    public static void main(String[] args) {
        for(int x =0;x<5;x++){
            if(x%2==0)
                break;
            System.out.println(x);
        }
    }
}

运行结果正确的是（）D

A.12345

B.024

C.13

D.不输出任何内容

int[] a={45,4,67,23,65,87,34,52,56}；数组中a[4]的值为（）C

A.23

B.45

C.65

D.87
请阅读下列示意代码
1
2
3
4
5
int a = 1;
int b = a++;
int c = ++a;
int d = ++a + ++a;
System.out.print(a + "," + b + "," + c + "," + d);
下面选项中，哪一个是程序的输出结果（）A

A.5,1,3,9

B.5,2,3,9

C.5,1,2,9

D.5,1,3,8
执行完以下代码int[ ] x = new int[25]；后，以下哪项说明是正确的（）。A

A.x[24]为0

B.x[25]为0

C.x[0]为空

D.x[24]未定义
以下有关构造方法的说法，正确的是： ____。A

A.一个类的构造方法可以有多个

B.构造方法在类定义时被调用

C.构造方法只能由对象的其它方法调用

D.构造方法可以和类同名，也可以和类名不同
以下关于继承的叙述正确的是（）。A

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

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

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

D.在Java中，接口也具有单继承性
Java源代码文件的扩展名为（）C

A..txt

B..class

C..java

D..doc
在控制台显示消息的语句正确的是（）C

A.System.out.println(我是一个Java程序员了！);

B.System.Out.println(“我是一个Java程序员了！”);

C.System.out.println(“我是一个Java程序员了！”);

D.System.Out.Println(“我是一个Java程序员了！”)
下面选项中不是开发Java程序的步骤（）D

A.编译

B.编写源代码

C.运行

D.发布
如果希望某些属性被所有对象共享，就必须将其声明为（）属性。B

A.final

B.public

C.static

D.this
以下表达式中，（）不可作为循环条件。A

A.x = 10

B.y >= 80

C.inputPass == truePass

D.m !=3
下列变量定义中，符合Java命名规范的是（）C

A.3a

B.int-name

C.$number

D.field name
字节码文件经过Java编译器翻译成一种特殊的二进制文件，由JVM负责解释执行。该二进制文件扩展名为（）B

A..java

B..class

C..obj

D.bin

这个程序的输出是？B

public class Demo{
    public static void main(String[] args){
        boolean flag = false;
        System.out.println(flag?"hello":"word");
    }
}

A.hello

B.word

C.true

D.程序出错

使用以下方法test(),那一项是正确的？（）D
1
2
3
public int test(int num,String str){
return num+str;
}
A.test(“1”,2)

B.test()

C.test(1)

D.test(1,”2”)
请问以下哪个修饰符用于声明一个常量？请选择一个正确答案：B

A.static

B.final

C.abstract

D.public

设有下面两个类的定义，类 Person 和类 Student 的关系是（）。C

class Person {
    long id; // 身份证号
    String name; // 姓名
}
class Student extends Person {
    int score; // 入学总分
    int getScore(){
    return score;
    }
}

A.包含关系

B.实现关系

C.继承关系

D.没有关系

下面的代码段执行之后count的值是什么( )D

int count = 1;
for (int i = 1; i <= 5; i++) {
    count += i;
}
System.out.println(count);

A.5

B.1

C.15

D.16

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

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

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

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

D.do…while循环是先循环后判断，所以循环体至少被执行一次
关于继承的说法正确的是：（）B

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

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

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

D.子类只继承父类的方法，而不继承属性
以下关于构造函数的描述错误的是（）?A

A.构造函数的返回类型只能是void型

B.构造函数是类的一种特殊函数，它的方法名必须与类名相同

C.构造函数的主要作用是完成对类的对象的初始化工作

D.一般在创建新对象时，系统会自动调用构造函数
下列哪一个关键字用于实现接口？（）D

A.extends

B.interface

C.abstract

D.implements
如果局部变量和成员变量同名，如何在局部变量作用域引用成员变量？( )B

A.不能引用，必须改名，使它们的名称不相同

B.在成员变量前加this，使用this访问该成员变量

C.在成员变量前加super，使用super访问该成员变量

D.不影响，系统可以自己区分
在编写异常处理的Java程序中，catch语句块应该与( )语句块对应，使得用该语句块来启动Java的异常处理机制。A

A.try

B.switch

C.break

D.default
用关键字 private 修饰的成员变量，下列说法正确的是（）A

A.只能被该类自身所访问或修改

B.只能被同一包中的其它类访问

C.可以被其它包中的类访问

D.可以被其它包中该类的子类所访问

程序执行后，num的值应该是（）A

public  static  void  main(String[]  args){
    int i=0, j=0, num=0;
    for(i=0; i<4; i++){
        for(j=i; j<2;j++){
            num=num+j;      
        }
    }
    System.out.println(num);              
}

A.2

B.4

C.0

D.3

下面关于类的封装性的描述中，错误的是（ D）。

A.封装体包含属性和行为

B.被封装的某些信息在外不可见

C.封装提高了可重用性

D.封装体中的属性和行为的访问权限相同

答案

1-10 BBBDB BDDAA

11-20 ADBAD ACBBA

21-30 CADDC CDACB

31-40 ADACA DCDBC

41-50 ADBAA CABCD

51-60 DADDC DCCAA

61-70 DBDAC BBCCA

71-80 BABBD CABDA

81-90 BADAA BCACA

91-100 DABAB BCACC

101-110 CCBBB CBCCC

111-120 ACADA BCCCD

121-130 CCCCA CADBC

131-140 ACBBC DCAAA

141-150 ACCDB ACBBD

151-161 BCDDB ADBAAA

class Order{
 	public static 忘了=0;
    public int i=0;
    public String name;
    public double price;
    public Order(String name){
        this.name=name;
		忘了++;
    }
    public void getP什么来着(double price){
        if(price>0){
            this.price+=price;
            i++;
        }
    }
    public double 什么来着(){
        return price;
    }
    public String toString(){
        return String.format("%s 什么来着 %d, total:%.2f",name,i,price);
    }     
}