JAVA选择判断

一、判断题

Java的字符类型采用的是Unicode编码。 ( T )

Java应用程序的主类必须是public类。( F )

在一个源文件中只能有一个类。（ F ）

Java应用程序必须要有主类。( F )

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

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

James Gosling是Java语言的创始人之一。( T )

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

java语言中不用区分字母的大写小写。( F )

Java的字符类型采用的是Unicode编码，每个Unicode码占16个比特。( T )

数组也是对象。 ( T )

使用方法length( )可以获得字符串或数组的长度。( F )

一个Java源文件中可以有多个类，但只能有一个类是public的。( T )

boolean型数据的值只有true和false。( T )

Java中的常量用final关键字修饰，标识符一般大写，赋值机会只有一次，必须在定义的时候赋初值。( F )

Java中，通过强制类型转换实现高精度的数据类型向低精度的数据类型赋值时，其数值不变。( F )

Java基本数据类型的变量所占存储空间大小是固定的，与平台（操作系统）无关。这样方便程序的移植。 ( T )

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

-5%3的运算结果是2。( F )

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

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

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

"float height=1.0f;"是正确的float变量声明。( T?)

“byte amout=128;”是正确的byte型变量声明。( F )

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

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

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

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

?break语句只用于循环语句中，它的作用是跳出循环。( F )

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

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

在switch语句中必须要有default选项。( F )

while(表达式)...语句中的“表达式”的值必须是boolean型数据。( T )

局部变量没有默认值。 ( T )

类中的实例变量在用该类创建对象的时候才会被分配内存空间。( T )

类中的实例方法可以用类名直接调用。( F?)

成员变量的名字不可以和局部变量的相同。 ( F )

在子类中想使用被子类隐藏的实例成员变量或实例方法就需要使用关键字super。( T )

子类可以有多个父类。(?F )

如果在子类的构造方法中没有显式地写出super关键字来调用父类的某个构造方法，那么编译器默认有“super();”调用父类的无参数的构造方法，如果父类没有这样的构造方法，代码将出现编译错误。( T )

如果一个类的声明中没有使用extends关键字，这个类被系统默认为是继承Object类。( T )

构造方法可以调用本类中重载的构造方法和它的父类的构造方法。 ( T )

Java只支持单继承，也就是说子类只能有一个直接父类 。 ( T )

Object类是所有其它类的直接或间接父类.( T )

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

InputStream类和OutputStream类是所有二进制I/O的根类。( T )

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

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

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

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

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

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

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

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

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

二、单选题

（ ）方法是Java程序执行的入口，含有该方法的类叫做（ A ）。
A.main 主类
B.Main 主类
C.main 公共类
D.Main 公共类

对JDK描述错误的是（ C ）。
A.运行Java程序只要有JRE环境就可以，不一定需要全部JDK的功能
B.JDK中包括JVM、核心类库、Java开发工具（java，javac）等
C.JDK本身也是平台无关的，不同的操作系统安装的JDK是一样的
D.JDK的全称是 Java Development Kit

正确配置classpath环境变量的方式是：（ D ）。
A.在系统环境变量classpath原有的字符串基础上，加上点符号和分号“.;”，然后再加上JDK安装路径下的bin目录
B.新建系统环境变量classpath，其值为：点符号和分号“.;”，然后再连上JDK安装路径下的bin目录
C.在系统环境变量classpath原有的字符串基础上，加上点符号和分号“.;”，然后再加上JDK安装路径下的lib目录
D.新建系统环境变量classpath，其值为：点符号和分号“.;”，然后再连上JDK安装路径下的lib目录

正确配置path环境变量的方式是：（ A ）。
A.在系统环境变量path原有的字符串基础上，加上分号“;”，然后再加上JDK安装路径下的bin目录
B.新建系统环境变量path，其值为：分号“;”，然后再连上JDK安装路径下的bin目录
C.在系统环境变量path原有的字符串基础上，加上分号“;”，然后再加上JDK安装路径下的lib目录
D.新建系统环境变量path，其值为：分号“;”，然后再连上JDK安装路径下的lib目录

下面关于main方法声明正确的是（ B ）。
A.public main(String args[ ])
B.public static void main(String args[ ])
C.private static void main(String args[ ])
D.void main()

在public static void main(String[] args)方法中，如何为args赋值？ C
A.执行开启后，在控制台利用Scanner对象进行赋值
B.执行时作为虚拟机参数
C.执行时提供执行参数
D.以上都不对

在Java程序中，用关键字（）修饰的常量对象创建后就不能再修改了。A
A.final
B.static
C.abstract
D.const

Java的引用数据类型不包括（C）。
A.接口
B.数组
C.boolean
D.类

以下（ D ）字符串是 Java 中合法的标识符。
A.super
B.3number
C.#number
D.$number

下列代表八进制整数的是（ D ）。
A.0xA6
B.-1E3
C.2022
D.0144

属于 main() 方法的返回类型是（C）。
A.public
B.static
C.void
D.main

请问，为了使一个名为MyClass的public类成功编译，需要满足以下哪些条件？B
A.MyClass必须定义一个正确的main()方法
B.MyClass必须定义在MyClass.java源文件中
C.MyClass必须定义在MyClass包中
D.MyClass类必须被导入

以下（ B ）不是Java中有效的关键字。
A.const
B.NULL
C.false
D.this

下面（ B ）表达式可以得到x和y中的最大值。
A.x>y?y:x
B.x<y?y:x
C.x>y?(x+y):(x-y)
D.x==y?y:x

假设有如下程序：

public class Demo {

? ? ? ? ?public static void main(String args[]) {

? ? ? ? ? ? ? ? ? ? ? int num = 50 ;

? ? ? ? ? ? ? ? ? ? ? num = num ++ * 2 ;

? ? ? ? ? ? ? ? ? ? ? System.out.println(num) ; }

? ? ? ? ? ? ? ? ? ?}

最终的执行结果是什么？C
A.50.0
B.102.0
C.100.0
D.101.0

假设有如下程序：

public class Demo {
????????public static void main(String args[]) {
????????????????int num = 68 ;
????????????????char c = (char) num ;
????????????????System.out.println(c) ;
????????}
}
最终的执行结果是什么？C
A.B
B.C
C.D
D.a

以下语句输出的结果是?A

String str="123";
int x=4,y=5;
str = str + (x + y);
System.out.println(str);

A.1239
B.12345
C.会产生编译错误
D.123+4+5

一个表达式中有int、byte、long、double型的数据相加，其结果是（ D ）类型的值
A.int
B.long
C.byte
D.double

阅读下列Java程序，如果在命令窗口输入java cmdtest Welcome to Earth!来运行此程序，请写出程序运行时输出结果：D
class cmdtest {
???public static void main(String[] args){
??????for(int i=0;i＜args.length;i++){
?????????System.out.println("args["+i+"]="+args[i]);
??????}
???}
}

A.args[0]=java
args[1]=cmdtest
args[2]=Welcome
args[3]=to
args[4]=Earth!
B.args[0]=java
args[1]=cmdtest
args[2]=Welcome to Earth!

C.args[1]=Welcome
args[2]=to
args[3]=Earth!
D.args[0]=Welcome
args[1]=to
args[2]=Earth!

下列关于变量作用域的说法中，正确的是（C）
A.在main()方法中任何位置定义的变量，其作用域为整个main()方法。
B.代码块中定义的变量，在代码块外也是可以使用的。
C.变量的作用域为：从定义处开始，到变量所在代码块结束的位置。
D.变量的作用域不受代码块的限制。

以下标识符中，不合法的是（C ）
A.user
B.$inner
C.class
D.login_1

下列选项中，不属于赋值运算符的是（C ）
A.-=
B.=
C.==
D.*=

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

执行下列程序后，输出的正确结果是（B）。
public class Test {
????public static void main(String[] args) {
????????System.out.print(100%3);
????????System.out.print(",");
????????System.out.println(100%3.0);
????}
}
A.1,1
B.1,1.0
C.1.0,1
D.1.0,1.0

下列赋值语句中错误的是（D）。
A.float a=11.2f;
B.double b=5.3E10;
C.char c='\r;
D.byte d=433;

假设有以下整型变量赋初值语句：int i=1+1/2+1/4；请问该语句执行后变量i的值为：A
A.1
B.1.75
C.2.5
D.3

下面程序段：

boolean a = false;
boolean b = true;
boolean c = (a && b) && (!b);
boolean result = (a & b) & (!b);
执行完后，正确的结果是（A）。
A.c=false; result=false;
B.c=true; result=true;
C.c=true; result=false;
D.c=false; result=true;

下列选项中，（ B ）是正确的char型变量的声明。
A.char ch="R";
B.char ch='\\'
C.char ch='ABCD'
D.char ch="ABCD"

假设有如下程序：

public class Demo {
? ? ? ? public static void main(String args[]) {
? ? ? ? ? ? ? ? ?boolean flag = 10%2 == 1 && 10 / 3 == 0 && 1 / 0 == 0 ;
? ? ? ? ? ? ? ? ?System.out.println(flag ? "mldn" : "yootk") ;
? ? ? ? }
}
最终执行结果是什么？B

A.mldn
B.yootk
C.true
D.程序出错

编译运行以下程序后，关于输出结果的说明，正确的是（ C ）。

public class Main {
? ? public static void main(String[] args) {
? ? ? ? int x = 4;
? ? ? ? System.out.println("value is "+((x>4)?99.9:9));
? ? }
}

A.输出结果为： value is 99.99
B.输出结果为： value is 9
C.输出结果为： value is 9.0
D.编译错误

下面代码运行结果显示（ C ）。

double temperature = 50;
if (temperature >= 100)
? ?System.out.println("too hot");
else if (temperature <= 40)
? ?System.out.println("too cold");
else
? ?System.out.println("just right");

A.too hot
B.too cold
C.just right
D.too hot too cold just right

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

int x=6, y=10, k=5;
switch( x%y ){?
? ? ? ? case 0: k=x*y;
? ? ? case 6: k=x/y;
? ? ? case 12: k=x-y;
? ? ? default: k=x*y-x;
}

A.60
B.5
C.0
D.54

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

A.x = 10
B.y >= 80
C.inputPass == truePass
D.m !=3

while循环和 do…while循环的区别是：（ B ）
A.没有区别，这两个结构任何情况下效果一样
B.while循环比 do…while循环执行效率高
C.while循环是先循环后判断，所以循环体至少被执行一次
D.do…while循环是先循环后判断，所以循环体至少被执行一次

在JAVA中，给定代码片段如下所示，则编译运行后，输出结果是（B）。

for (int i = 0; i < 10; i++) {
? ? if (i == 10 - i) {
? ? ? ? break;
? ? }

? ? if (i % 3 != 0) {
? ? ? ? continue;
? ? }
? ? System.out.print(i + " ");
}

A.0
B.0 3
C.0 3 6
D.0 3 6 9

下面代码将输出（ B ）行 "Welcome to Java"?。

int count = 0;
do {
? ? ?System.out.println("Welcome to Java");
} while (count++ < 10);

A.10
B.11
C.9
D.1

分析下列代码的运行结果是什么？A

void looper(){

? ? int x=0;
? ? one:
? ? while(x<20) {
? ? ? ? two:
? ? ? ? ? ? System.out.print(++x);
? ? ? ? ? ? if(x>3)
? ? ? ? ? ? ? break two;
? ? }
}

A.编译错误
B.0
C.1
D.2

下列选项中不属于本段代码输出结果的是（ D ）

public class Main{
? ? public static void main(String args[]) {
? ? ? one:
? ? ? two:
? ? ? for(int i=0; i<3; i++) {
? ? ? ? ? three:
? ? ? ? ? for(int j=10; j<30; j+=10) {
? ? ? ? ? ? ?System.out.println(i+j);
? ? ? ? ? ? ?if(i>0)
? ? ? ? ? ? ? ? break one;
? ? ? ? ? }
? ? ? }
? ? }
}

A.10
B.20
C.11
D.21

挑错题（A,B,C,D注释标注的哪行代码有错误？(D）

public class Test {
public static void main(String args[]){
int m=1000;
while (m>100) //A
{
m = m--; //B
if (m == 600){ //C
continue;
m++; //D
}
System.out.println("m= "+m);
}
}

}

在Java中，负责对字节代码解释执行的是 （B ）
A.应用服务器
B.虚拟机
C.垃圾回收器
D.编译器

编译Java源程序文件将产生相应的字节码文件，这些字节码文件的扩展名为( B)。
A..byte
B..class
C..html
D..exe

下列哪个叙述是正确的?B
A.Java应用程序由若干个类所构成,这些类必须在一个源文件中。
B.Java应用程序由若干个类所构成,这些类可以在一个源文件中,也可以分布在若干个源文件中,其中必须有一个源文件含有主类。
C.Java源文件必须含有主类。
D.Java源文件如果含有主类,主类必须是public类。

Java 类可以作为（C ）。
A.类型定义机制
B.数据封装机制
C.类型定义机制和数据封装机制
D.上述都不对

一个*.java文件中可以包含多少个public类？A
A.最多1个
B.最少1个
C.只能是0个
D.不限制

下面的选项中，哪一项不属于“汽车类”的行为（D ）。
A.启动
B.刹车
C.加速
D.速度

下面关于类的封装性的描述中，错误的是（D ）。
A.封装体包含属性和行为
B.被封装的某些信息在外不可见
C.封装提高了可重用性
D.封装体中的属性和行为的访问权限相同

对于类与对象的关系，以下说法错误的是（D ）。
A.类是对象的类型
B.对象由类来创建
C.类是同类对象的抽象
D.对象是创建类的模板

关于类和对象的关系，下列说法哪种说法是错误的？A
A.类和对象都是具体的。
B.类是抽象的，对象是具体的。
C.一般情况下，在定义类之后，能创建无数个对象，可以说，类能化身千万。
D.类是引用型数据类型。

关于下面的类描述中正确的是：C

class Test{
? ? void test(int i){
? ? ? ? System.out.println("I am an int.");
? ? }
? ? void test(String s){
? ? ? ? System.out.println("I am a char");
? ? }
? ? public static void main(String args[]){
? ? ? ? Test t=new Test();
? ? ? ? t.test('a');
? ? }
}

A.编译出错
B.编译通过，运行出错
C.编译通过，运行时输出“I am an int”
D.编译通过，运行时输出“I am a char"

有类Person定义如下：

public class Person {
? ? String name ?;
? ? int age ? ;
}
以下操作的结果是：A

? ? ? ?Person p = new Person();
? ? ? ?System.out.print(p.name+" "+p.age);
? ? ? ?p.name = "Alice";
? ? ? ?p.age = 12;
? ? ? ?System.out.println(p.name+" "+p.age);

A.null 0Alice 12
B.Alice 12Alice 12
C.null 0null 0
D.都不对

现有声明Circle x = new Circle()，如下哪句是最确切的。（C ）
A.x包含了一个int型数据。
B.x包含了一个Circle类型的对象。
C.x包含了一个Circle对象的引用。
D.x可将一个int型数据赋值给x。

分析如下代码。

public class Test {
? public static void main(String[] args) {
? ? double radius;
? ? final double PI= 3.15169;
? ? double area = radius * radius * PI;
? ? System.out.println("Area is " + area);
? }
}

如下说法哪句是正确的？A
A.程序编译错误，因为变量radius没有初始化。
B.程序编译错误，因为常量PI定义在方法中。

C.程序没有编译错误但运行时会出错，因为radius没有初始化。
D.程序编译和运行正确。

下面叙述正确的是（A）。
A.成员变量有默认值
B.this可以出现在static方法中
C.类中的实例方法可以用类名调用
D.局部变量也可以用范围修饰符：public、protected、private修饰

对于下列Hello类的叙述正确的是（ D ）。
class Hello {
Hello(int m){
}

int Hello(){
? return 20;
}
hello(){ ? ?
}
}

A.Hello类有两个构造方法
B.Hello类的int Hello( ) 方法是错误的方法
C.Hello类没有构造方法
D.Hello类无法通过编译，因为其中的hello方法的方法头是错误的（没有类型）

以下代码中，this是指(B )。
class bird{

int x,y;

void fly(int x,int y){

this.x=x;

this.y=y;
}

}

A.用bird创建的对象

B.方法fly

C.类bird

D.不一定

以下描述正确的有? B

A.方法的重写应用在一个类的内部

B.方法的重载与返回值类型无关

C.构造方法不能重载

D.构造方法可以重写

Test类的定义如下，程序的运行结果为下列哪一项？（ C）。

public class Test { 
  public Test() { 
    System.out.println("构造方法一被调用了。。"); 
  } 
  public Test(int x) { 
    System.out.println("构造方法二被调用了。。"); 
   } 
  public Test(boolean b) { 
    System.out.println("构造方法三被调用了。。"); 
   } 
   
     public static void main(String[] args) { 
      Test test=new Test(true); 
   } 
} 

A.构造方法一被调用了。。

B.构造方法二被调用了。。

C.构造方法三被调用了。。

D.构造方法一被调用了。。

构造方法二被调用了。。

构造方法三被调用了。。

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

A.封装

B.继承

C.覆盖

D.重载

以下有关构造方法的说法，正确的是： __A__。

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

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

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

D.构造方法可以和类同名，也可以和类名不同

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

A.this

B.super

C.static

D.public

关于类中成员变量的作用范围，下述说法中正确的是（ C）。

A.只有用public修饰的变量才能在所有方法中使用

B.用private修饰的成员变量可以在main方法中直接使用

C.类中所有成员变量在所有成员方法中有效

D.用static修饰的成员变量只能在用static修饰的方法中使用

下面的（ C）操作符可以使其修饰的变量只能对同包中的类或子类可见

A.private

B.public

C.protected

D.default

分析如下代码。

class Circle {
  private double radius;

  public Circle(double radius) {
    radius = radius;
  }
}

如下哪句是正确的？C

A.程序有一个编译错误，因为没有main方法。

B.程序可以编译，但没有创建一个特定radius的Circle对象。对象的radius始终为0。

C.程序有一个编译错误，因为不能radius = radius。

D.程序无法编译，因为Circle没有缺省的构造函数。

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

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

A.局部 成员 this

B.成员 局部 this

C.类 实例 this

D.实例 类 this

在Java中用什么关键字修饰的方法可以直接通过类名来调用？（A ）。

A.static

B.final

C.private

D.void

以下说法错误的是（B ）

A.静态方法可以直接访问本类的静态变量和静态方法

B.静态方法可以直接访问本类的非静态变量和非静态发方法

C.非静态方法可以直接访问本类的静态变量和静态方法

D.非静态方法可以直接访问本类的非静态变量和非静态方法

下面（C ）修饰符修饰的变量是所有同一个类生成的对象共享的。

A.public

B.private

C.static

D.final

分析如下代码：C

public class Test {
  private int t;

  public static void main(String[] args) {
    int x;
    System.out.println(t);
  }
}

A.变量t没有初始化，所以会引起错误。

B.变量t是私有的，因此不能在main方法中访问。

C.t是非静态的，不能在静态的main方法中引用。

D.变量x没有初始化，所以会引起错误。

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

A.private

B.finaL

C.static

D.public

有如下程序代码，哪处出现编译错误？（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处

声明成员变量时,如果不使用任何访问控制符(public,?protected,?private)，则以下哪种类型的类不能对该成员进行直接访问?（ D? ? ）?.

A.同一类

B.同一包中的子类

C.同一包中的非子类

D.不同包中的子类

Java程序默认引用的包是（C ）。

A.java.text包

B.java.awt包

C.java.lang包

D.java.util包

下列关于使用包中的类哪个说法是正确的。C

A.类不可以使用其所在包中的private类

B.类可以使用其他包中的所有类

C.类可以使用其他包中的public类

D.以上说法都不正确

关于以下程序段，正确的说法是（? C? ）?。

1．??String??s1=”abc”+”def”;
2．??String??s2=new??String（s1）；
3．??if（s1==s2）
4．?????System.out.println(“==?succeeded”);
5．??if?(s1.equals(s2))
6．?????System.out.println(“.equals()??succeeded”);

A.行4与行6都将执行

B.行4执行，行6不执行

C.行6执行，行4不执行

D.行4、行6都不执行

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

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

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

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

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

关于被私有访问控制符private修饰的成员变量，以下说法正确的是（C? ）

A.可以被三种类所引用：该类自身、与它在同一个包中的其他类、在其他包中的该类的子类

B.可以被两种类访问和引用：该类本身、该类的所有子类

C.只能被该类自身所访问和修改

D.只能被同一个包中的类访问

类的实例方法表示的是什么？（ C）

A.父类对象的行为

B.类的属性

C.类对象的行为

D.类的行为

对于实例的清除，下列叙述不正确的是（D）。

A.当不存在对某一对象的引用时，就释放该对象所占用的内存空间。

B.在Java中，对象清除由垃圾回收器自动完成，程序员不需要做任何工作。

C.程序员不能控制垃圾回收器。

D.System.gc()方法能保证垃圾回收器一定执行垃圾回收操作。

关于被私有访问控制符private修饰的成员变量，以下说法正确的是（C ）

A.可以被三种类所引用：该类自身、与它在同一个包中的其他类、在其他包中的该类的子类

B.可以被两种类访问和引用：该类本身、该类的所有子类

C.只能被该类自身所访问和修改

D.只能被同一个包中的类访问

访问修饰符作用范围由大到小是（ D）

A.private-default-protected-public

B.public-default-protected-private

C.private-protected-default-public

D.public-protected-default-private

已知代码：

class Person{
    private static String country="A城市" ;
    String name;
    public static void sFun(String c){
        System.out.println("name="+name);
        fun(c);}
    public void fun(String c ){
        name="name1";
        country=c;
    }
}

关于static，下面描述错误的是 (A)?

A.上述代码在编译时出错，因为在static方法sFun中访问了非static变量name

B.上述代码在编译时出错，因为在static方法sFun中访问了非static方法fun()

C.sFun方法正确

D.fun方法正确

若在某一个类定义中定义有如下的方法： final void aFinalFunction( ),则该方法属于(C )。

A.本地方法

B.静态方法

C.最终方法

D.抽象方法

class Father {? ? 错误行在C
private int money = 12;
float height;
int seeMoney(){
return money; //A
}
}

class Son extends Father{
float height;
int lookMoney(){
int m = seeMoney(); //B
return m;
}
}

class F{
public static void main(String[] args) {
Son erzi = new Son();
erzi.money = 300; //C
erzi.height =1.78F; //D
}

}

A.A

B.B

C.C

D.D

class A{? ? ? ?A
public float getNum(){
return 3.0f;
}
}
public class B {
【代码】
}

A.public float getNum(){return 4.0f;}

B.public void getNum(){ }

C.public void getNum(double d){ }

D.public double getNum(float d){ return 4.0f; }

abstract class Takecare{? ? ? B
protected void speakHello(){} //A
public abstract static void cry(); //B
static int f(){return 0;} //C
abstract float g(); //D

}

A.A

B.B

C.C

D.D

abstract class Animal{? ?D
int m = 100;
}

class Dog extends Animal{
double m;
}
public class E{

public static void main(String args[]){
    Animal animal = null;      //A
    Dog dog = new Dog();
    animal = dog;     //B
    dog.m = 3.14;   //C
    animal.m = 3.14;  //D}
}

A.A

B.B

C.C

D.D

类Teacher和Student是类Person的子类,下面的代码中最后一句语句的运行结果是(D ).

Person p;
Teacher t;
Student s;
//p,t and s are all non-null.
if(t instanceof Person) ?{s=(Student)t;}

A.编译时正确，但运行时错误
B.将构造一个Student对象
C.表达式是错误的
D.表达式是合法的

以下程序运行结果是A

public class Test extends Father{
? ? private String name="test";
? ? public static void main(String[] args){
? ? ? ? Test test = new Test();
? ? ? ? System.out.println(test.getName());
? ? }
}
class Father{
? ? private String name="father";
? ? public String getName() {
? ? ? ? return name;
? ? }
}

A.father
B.编译出错
C.test
D.运行出错，无输出

下列选项中关于java中super关键字的说法错误的B
A.super关键字是在子类对象内部指代其父类对象的引用
B.super关键字不仅可以指代子类的直接父类，还可以指代父类的父类
C.子类可以通过super关键字调用父类的方法
D.子类可以通过super关键字调用父类的属性

下面描述中正确的是？B
A.创建子类的对象时，先调用子类自己的构造方法，然后调用父类的构造方法。
B.子类无法继承父类的构造方法。
C.子类无条件地继承父类不含参数的构造方法。
D.子类必须在自己的构造方法中用super关键字显式地调用父类的构造方法。

关于关键字instanceof的说法不正确的是：（C ）。
A.它不能作为标识符名称出现
B.它用来表示某变量所指向的对象是否是另一种类型的实例
C.Scanner sc=new Scanner(System.in);
boolean b=sc instanceof String;
//这种用法是正确的

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

有如下程序代码，程序编译(执行)的结果为：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);
?}
}

A.B m1
B m2
B m3
20
20
20

B.A m1
B m2
B m3
10
20
20

C.A m1
B m2
B m3
20
20
20

D.A m1
B m2
B m3
20
10
20

以下关于继承的叙述正确的是（A ）。
A.在Java中类只允许单一继承
B.在Java中,一个类只能实现一个接口
C.在Java中，一个类不能同时继承一个类和实现一个接口
D.在Java中，接口也具有单继承性

在某个类中存在一个方法：void getSort(int x),以下能作为这个方法的重载的声明的是( C)
A.public get (float x)
B.int getSort(int y)
C.double getSort(int x,. int y)
D.void get(int x, int y)

下面程序的输出结果为：（ 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

在下面的代码中，若要在子child类中对父类的addvalue方法进行重写，下面对于child类中的addvalue方法的声明哪个是正确的：（ A）。

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)

下列关于抽象类的说法哪一个是错误的。B
A.含抽象方法的类为抽象类
B.抽象类能创建(new)实例
C.子类有未实现父类的抽象方法时仍为抽象类
D.子类实现所有抽象方法时不再是抽象类

下面类的定义，哪个是合法的抽象类定义。C
A.class A { abstract void unfinished() { } }
B.class A { abstract void unfinished(); }
C.abstract class A { abstract void unfinished(); }
D.public class abstract A { abstract void unfinished(); }

以下对接口描述错误的有D
A.接口没有提供构造方法
B.接口中的方法默认使用public、abstract修饰
C.接口中的属性默认使用public、static、final修饰
D.接口不允许多继承

给定以下代码，请问下列选项中哪个是正确的？D

public interface Top{
? void twiddle(String s);
}

A.public abstract class Sub implements Top{
? public abstract void twiddle(String s){ }
}

B.public class Sub implements Top{
? public void twiddle(Integer i){ }
}

C.public class Sub implements Top{
? void twiddle(String s){ }
}

D.public class Sub implements Top{
? public void twiddle(String s){ }
? public void twiddle(Integer i){ }
}

多态的表现形式有A
A.重写
B.继承
C.抽象
D.封装

已知类的继承关系如下：

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();

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

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 ）。

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

A.ABC
B.BCD
C.AB
D.BC

关于字符串的相关使用，如下代码执行结果是（ 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

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

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

A.true
B.false
C.1
D.-1

String类的equals方法，其作用是：（ D）
A.比较2个字符串对象是否为同一个对象
B.比较2个字符串对象的字符长度是否相同
C.比较2个字符串对象的首地址是否相同
D.比较2个字符串对象的字符序列是否相同

下列关于字符串对象的叙述中，错误的是（ B）。
A.字符串常量是对象
B.String 对象存储字符串的效率比 StringBuilder 高
C.字符串对象具有不变性
D.String类提供了许多用来操作字符串的方法：连接、提取、查询等，一旦返回的结果与原字符串不同，就生成一个新对象，而不是在原字符串进行修改

已知: String s="abcdedcba”; 则 s.substring(3,4) 返回的字符串是哪个?（C ）
A.cd
B.de
C.d
D.dedc

关于字符串对象的比较，==用于比较字符串对象的（ A）是否相同；equals()方法用于比较字符串对象的（ ）是否相同。
A.存储地址 字符序列
B.存储地址 存储地址
C.字符序列 存储地址
D.字符序列 字符序列

执行如下两行代码之后，则内存中存在几个字符串对象?（ C）

String str="abc";?
str+="def";

A.1

B.2
C.3
D.4

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 ）。

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

对String类型的字符串String str="abcd"，调用str对象的( )方法，得到char类型的数组['a','b','c','d'] ?? ?A
A.toCharArray()
B.toChars()
C.getChars()
D.getBytes()

关于一维数组的定义形式，哪个是错误的？A
A.int intArr=new int[10];
B.int intArr[]=new int[10];
C.int intArr[]={1,2,3,4,5};
D.int intArr[]=new int[]{1,2,3,4,5};
E.int intArr[]={1,2,3,4,5};

数组的定义为：int[] arr=new int[10];C
如何获得数组的长度？
A.arr.length()
B.arr.size()
C.arr.length
D.arr.size

执行完以下代码int[ ] x = new int[25]；后，以下哪项说明是正确的(A )
A.x[24]为0
B.x[24]未定义
C.x[25]为0
D.x[0]没有数值存在

关于char类型的数组，说法正确的是( D)。
A.其数组的默认值是'A'
B.可以仅通过数组名来访问数组
C.数组不能转换为字符串
D.可以存储整型数值

下面关于数组声明和初始化的语句那个有语法错误？（ C? ）
A.int?a1[]={3,4,5};
B.String?a2[]={"string1","string1","string1"};
C.String?a3[]=new?String(3);
D.int[][]?a4=new?int[3][3];

若int a[][]={{123,345,334},{1,2},{3,4}}; 则 a[2][1]=（ D）。
A.1
B.3
C.2
D.4

在面向对象的软件系统中，不同类对象之间的通信的一种构造称为____D___。
A.属性
B.封装
C.类
D.消息

向Collection中增加数据的方法是（B ）。
A.insert
B.add
C.append
D.concat

Java的集合框架中重要的接口java.util.Collection定义了许多方法。选项中哪个方法不是Collection接口所定义的？(? ?C? )
A.int?size()
B.boolean?containsAll(Collection?c)
C.compareTo(Object?obj)
D.boolean?remove(Object?obj)

要想在集合中保存没有重复的元素，并且按照一定的顺序排列，可以使用以下哪个集合？D
A.LinkedList
B.ArrayList
C.HashSet
D.TreeSet

下列程序代码运行结果是：（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

下面哪个Map是排序的？A
A.TreeMap
B.HashMap
C.Hashtable
D.WeakHashMap
E.LinkedHashMap

要想保存具有映射关系的数据，可以使用以下哪些集合：C
A.ArrayList 、LinkedList
B.HashSet、TreeSet
C.TreeMap、HashMap
D.HashSet、HashMap

使用Iterator时，判断是否存在下一个元素可以使用以下哪个方法？（D）
A.next()
B.hash()
C.hasPrevious()
D.hasNext()

关于Java中异常的叙述，正确的是：（D ）。
A.异常是程序编写过程中代码的语法错误
B.异常是程序编写过程中代码的逻辑错误
C.异常出现后程序的运行马上中止
D.异常是可以捕获和处理的

以下对异常的描述不正确的有C
A.异常分为Error和Exception
B.Throwable是所有异常类的父类
C.Exception是所有异常类父类
D.Exception包括RuntimeException和RuntimeException之外的异常

Java异常类（Exception）是（ B）的子类。
A.RuntimeException
B.Exception
C.Error
D.Throwable

在异常处理时，将可能发生异常的代码放在（ ）语句块中，后面紧跟着一个或多个（ ）语句块，还可以再跟零个或一个（ 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子句

假设方法unsafe()?将抛出IOException,?可以填入如下代码段第1行的选项是（ D）。

1)
2)?{?if(unsafe()){//do?something…}
3)?? else?if(safe()){//do?the?other…}
4)?}

A.public?IOException?methodName()
B.public?void?methodName()
C.public?void?methodName()?throw?IOException
D.public?void?methodName()?throws?IOException

对以下程序进行编译、运行结果是 A

abstract class MineBase {
　　　abstract void amethod();
　　　static int i;
　}

　　public class Mine extends MineBase{
　　　public static void main(String argv[]){
　　　　int[] ar = new int[5];
　　　　for(i = 0;i < ar.length;i++)
　　　　System.out.println(ar[i]);
　　　}
　　}
A.打印5个0。
B.编译出错，数组ar[]必须初始化。
C.编译出错。
D.出现IndexOutOfBoundes的异常

程序异常

public class Test {
? public static void main(String[] args) {
? ? try {
? ? ? String s = "5.6";
? ? ? Integer.parseInt(s); // 引起一个 NumberFormatException异常

? ? ? int i = 0;
? ? ? int y = 2 / i;
? ? }
? ? catch (Exception ex) {
? ? ? System.out.println("NumberFormatException");
? ? }
? ? catch (RuntimeException ex) {
? ? ? System.out.println("RuntimeException");
? ? }
? }
}
该程序会出现（ A）
A.程序显示NumberFormatException。
B.程序显示RuntimeException。
C.程序显示NumberFormatExceptio，然后是RuntimeException。
D.程序编译错误。

下列程序的运行结果是（B?）。

public class Test {
? public static void main(String[] args) {
? ? try {
? ? ? System.out.println("Welcome to Java");
? ? ? int i = 0;
? ? ? int y = 2 / i;
? ? ? System.out.println("Welcome to HTML");
? ? }
? ? finally {
? ? ? System.out.println("The finally clause is executed");
? ? }
? }
}
A.Welcome to Java, 然后是错误信息
B.Welcome to Java，下一行是 The finally clause is executed , 然后是错误信息.
C.替换为正确项
D.替换为错误项

Java中用来抛出异常的关键字是：（C ）。
A.try
B.catch
C.throw和throws
D.finally

Java语言具有许多优点和特点，哪个反映了Java程序并行机制的特点？。B
A.安全性
B.多线程
C.跨平台
D.可移植

下面关于进程和线程的关系不正确的是？（D ）
A.进程是系统进行资源分配和调度的单位，线程是CPU调度和分派的单位。
B.一个进程中多个线程可以并发执行。
C.线程可以通过相互之间协同来完成进程所要完成的任务。
D.线程之间不共享进程中的共享变量和部分环境。

下列说法中错误的一项是（ A）。
A.线程就是程序
B.线程是一个程序的单个执行流
C.多线程是指一个程序的多个执行流
D.多线程用于实现并发

下列哪个叙述是正确的?C
A.多线程需要多个CPU才可以。
B.多线程需要多个进程来实现。
C.一个进程可以产生多线程。
D.线程之间无法实现数据共享。

下列说法中错误的一项是（C ）。
A.一个线程是一个Thread类的实例。
B.线程从传递给纯种的Runnable实例run()方法开始执行。
C.新建的线程调用start()方法就能立即进入运行状态。
D.线程操作的数据来自Runnable实例

实现多线程的方式有：通过继承（ ）类，通过实现（A ）接口。
A.java.lang.Thread ?java.lang.Runnable
B.java.lang.Runnable java.lang.Thread ??
C.java.thread.Thread java.thread.Runnable ??
D.java.thread.Runnable java.thread.Thread

Runnable接口定义了如下哪个方法？( D)。
A.start( )
B.stop( )
C.sleep( )
D.run( )

Thread类的（ ）方法用于启动线程；当新线程启动后，系统会自动调用调用（D ）方法。
A.start sleep
B.run sleep
C.run start
D.start run

已知创建java.lang.Thread的子类MyThread实现多线程编程。现有如下程序代码：

public class MyThread extends Thread {
?public void start() {
? run();
?}
?public void run() {?
?}?
}
public class Main {
?public static void main(String[] args) {
? MyThread myThread=new MyThread();
? myThread.start();
? System.out.println(Thread.activeCount());//返回当前线程的线程组及其子组中活动线程数的估计值。
?}
}
则程序执行结果最大概率是：（ C）。
A.0
B.1
C.2
D.不确定

一个线程在任何时刻都处于某种线程状态（thread?state）,例如运行状态、阻塞状态、就绪状态等。一个线程可以由选项中的哪种线程状态直接到达运行状态？(? D? ?)
A.死亡状态
B.阻塞状态（对象lock池内）
C.阻塞状态（对象wait池内）
D.就绪状态

下列哪个方法可以使线程从运行状态进入其他阻塞状态（ D）。
A.sleep()
B.wait()
C.yield()
D.start()

下列哪个一个操作不能使线程从等待阻塞状态进入对象阻塞状态（D ）。
A.等待阻塞状态下的线程被notify()唤醒
B.等待阻塞状态下的纯种被interrput()中断
C.等待时间到
D.等待阻塞状态下的线程调用wait()方法

下列哪个情况可以终止当前线程的运行？( B)
A.抛出一个异常时
B.当该线程调用sleep()方法时
C.当创建一个新线程时
D.当一个优先级高的线程进入就绪状态时

下面关于Java中线程的说法不正确的是(C )。
A.调用join()方法可能抛出异常InterruptedException
B.sleep()方法是Thread类的静态方法
C.调用Thread类的sleep()方法可终止一个线程对象
D.线程启动后执行的代码放在其run方法中

关于sleep()和wait()，以下描述错误的一项是（ D）。
A.sleep是线程类（Thread）的方法，wait是Object类的方法；
B.sleep不释放对象锁，wait放弃对象锁；
C.sleep暂停线程、但监控状态仍然保持，结束后会自动恢复；
D.wait后进入等待锁定池，只有针对此对象发出notify方法后获得对象锁进入运行状态。

假设test类运行于多线程环境下，那么关于A处的同步下面描述正确的是？A

public class Test {
? List list= new java.util.ArrayList();
? public void test() {
? ? synchronized ( list) { // --A
? ? ? list.add( String.valueOf(System.currentTimeMillis()));
? ? }
? }
}

A.test方法中必须增加synchronized
B.Test类为singleton时有必要增加synchronized
C.test方法中没有必要增加synchronized
D.Test类为singleton时也没有必要增加synchronized

在输入流的read方法返回哪个值，表示读取结束？C
A.0
B.1
C.-1
D.null

利用FileInputStream和FileOutputStream读写文件，哪个方法不抛出IOException?(A )
A.两个类的构造方法
B.read
C.write
D.close

构造BufferedInputStream类型的对象，参数可以是哪些类型的对象？（C?）
A.BufferedOutputStream
B.FileInputStream
C.FileOuterStream
D.File

要从“file.dat”文件中读出第10个字节到变量c中，下列哪个方法适合? （ C)
A.
FileInputStream in=new FileInputStream("file.dat");?
int c=in.read();

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

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

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

字符流与字节流的区别是( C)。
A.每次读入的字节数不同
B.前者带有缓冲，后者没有
C.前者是字符读写，后者是字节读写
D.二者没有区别，可以互换使用

为了从文本文件中逐行读取内容，应该使用哪个处理流对象？（A ）
A.BufferedReader
B.BufferedWriter
C.BufferedInputStream
D.BufferedOutputStream

transient 变量和下面哪一项有关？B
A.Cloneable
B.Serializable
C.Runnable
D.Throwable
E.Comparable