下列关于运算符优先级的描述中，错误的是().下列关于运算符优先级的说法中，不正确的一个是A:用基本数据类型作为参数 B:两种说法都对：用基本数据类型作为参数；用对象作为参数 C:用对象作为参数 D:两种说法都不对：用基本数据类型作为参数；用

下列循环语句的循环次数是().
int i=5 ;
do{
System. out. println( i–);
i– ;
}while(i! =0);

A. 0 B. 1 C. 5 D. 无限

A:1
B:5
C:无限
D:0
答案: 无限

下列循环语句中，循环体被执行的次数为().
for (int i=O,j=O;(j!=18)||(j

A:不确定
B:无限
C:3
D:4
答案: 无限

下列说法正确的是（）

A:D JAVA程序的main方法中如果只有一条语句，可以不用{}(大括号)括起来
B:B JAVA程序中可以有多个main方法
C:C JAVA程序中类名必须与文件名一样
D:A JAVA程序的main方法必须写在类里面
答案: A JAVA程序的main方法必须写在类里面

下列输出结果是（）
int a = 0 ;
while ( a switch(a){
case 0:
case 3 : a = a + 2;
case 1 :
case 2 : a = a + 3;
default : a = a + 5;
}
}
System.out.print ( a ) ;

A:A 0
B:D 其他
C:B 5
D:C 10
答案: C 10

下面有关for循环的描述正确的是（）

A:A for循环体语句中，可以包含多条语句，但要用大括号括起来
B:D for循环是先执行循环体语句，后进行条件判断
C:C 在for循环中，不能使用break语句跳出循环
D:B for循环只能用于循环次数已经确定的情况
答案: C 在for循环中，不能使用break语句跳出循环

在调用方法时，若要使方法改变实参的值，可以（）。

A:用基本数据类型作为参数
B:两种说法都对：用基本数据类型作为参数；用对象作为参数
C:用对象作为参数
D:两种说法都不对：用基本数据类型作为参数；用对象作为参数
答案: 用对象作为参数

类Test1定义如下： public class Test1{ public float aMethod(float a,float b){ } }将以下哪种方法插入行3是不合法的（）

A:Bpublic float aMethod(float c,float d){ }
B:Dpublic float aMethod(int a,int b,int c){ }
C:Cpublic float aMethod(int a,int b){ }
D:Apublic float aMethod(float a,float b，float c){ }
答案: Bpublic float aMethod(float c,float d){ }

下列关于for循环和while循环的说法中哪个是正确的（）

A:Bwhile循环判断条件一般是程序结果，for循环判断条件一般是非程序结果
B:C两种循环任何时候都可替换
C:D两种循环的循环体都不能为空
D:Awhile循环能实现的操作,for循环也都能实现
答案: Bwhile循环判断条件一般是程序结果，for循环判断条件一般是非程序结果

下列方法定义中正确的是（）

A:Bvoid x(){…return ture;}
B:Dint x(int a,b){return a+b;}
C:Cint x(){…return ture;
D:Aint x(){ char ch=’a’; return (int)ch;} }
答案: Aint x(){ char ch=’a’; return (int)ch;} }

当条件为真和条件为假时，（）控制结构可以执行不同的动作。

A:Cfor
B:Bwhile
C:Dif/else
D:Aswitch
答案: Dif/else

下面哪些循环不会导致死循环（）。

A:Afor(int k=0;k B:Cfor(int k=0;k C:Dfor(int k=0;k>0;k++)
D:Bfor(int k=10;k>0;k–)
答案: ;
;

关于while和do－while循环，下列说法不正确的是（）

A:与do－while语句不同的是，while语句的循环至少执行一次
B:其余都不对。
C:两种循环除了格式不同外，功能完全相同
D:do-while语句首先计算终止条件，当条件满足时，才去执行循环体中的语句
答案: 与语句不同的是语句的循环至少执行一次;
两种循环除了格式不同外功能完全相同;
语句首先计算终止条件当条件满足时才去执行循环体中的语句

（）表达式可以作为循环条件

A:A i++;
B:B i>5;
C:C bEqual = str.equals(“q”);
D:D count = = i;
答案: ;

下面哪几个函数是public void example(){…}的重载函数？

A:Bpublic int example(){…}
B:Apublic void example( int m){…}
C:D public int example ( int m, float f){…}
D:Cpublic void example2(){…}
答案: ;

给出下面的代码段: public class Base{ int w, x, y ,z; public Base(int a,int b) { x=a; y=b; } public Base(int a, int b, int c, int d) { // assignment x=a, y=b w=d; z=c; } }
在代码说明// assignment x=a, y=b处写入如下哪几个代码是正确的（）

A:Dthis(a,b);
B:Cx=a; y=b;
C:ABase(a,b);
D:Bx=a, y=b;
答案: ;

下列关于条件语句的描述中，错误的是（）。

A:if 语句可以有多个 else 子句和 else if 子句
B:if 语句中的 条件 可以使用任何表达式
C:if 语句中可以没有 else 子句和 else if 子句
D:if 语句的 if else 体内可以有循环语句
答案: 语句可以有多个子句和子句;
语句中的条件可以使用任何表达式

下列关于开关语句的描述中，错误的是 ().

A:退出开关语句的唯一条件是执行 break 语句.
B:开关语句中， case子句的语句序列一定含有 break 语句.
C:开关语句中， case子句和default子句都可以有多个.
D:开关语句中， default 子句可以省略.
答案: 退出开关语句的唯一条件是执行语句;
开关语句中子句的语句序列一定含有语句;
开关语句中子句和子句都可以有多个

下列关于循环语句的描述中，错误的是()

A:循环体可以是空语句，也可以是空
B:double
C:任何一种循环体内都可以包含一种循环语句
D:循环语句中，循环体至少被执行一次
E:循环体内可以出现多个 break 语句
F:float
答案: 循环体可以是空语句也可以是空;
循环语句中循环体至少被执行一次

下列特点中不属于Java的是()。

A:多继承
B:跨平台
C:报考性
D:多线程
答案: 跨平台;
报考性;
多线程

结构化程序所要求的基本结构包括

A:选择(分支)结构
B:GOTO跳转
C:顺序结构
D:重复(循环)结构
答案: 选择分支结构;
顺序结构;
重复循环结构

在异常处理中，若try中的代码可能产生多种异常则可以对应多个catch语句，若catch中的参数类型有父类子类关系，此时应该将父类放在后面，子类放在前面。

A:错
B:对
答案: 对

在Java中对象可以赋值，只要使用赋值号（等号）即可，相当于生成了一个各属性与赋值对象相同的新对象。

A:错
B:对
答案: 错

default语句块在switch语句中是必需的。

A:错
B:对
答案: 错

if结构和if/else结构所做的动作相同。

A:对
B:错
答案: 错

在switch（expression）语句中，expression的数据类型可以是double

A:错
B:对
答案: 错

表达式（12==0）&&（1/0

A:错
B:对
答案: 错

下面程序段的输出结果是7。

publicclassTest{

publicstaticvoidmain(Stringargs[]){

inta，b;

for(a=1，b=1;a

if(b>=10)break;

if(b%2==1){

b+=2：

continue;

}

}

System.OUt.println(a);

}

}

A:对
B:错
答案: 对

break是Java语言中的跳转语句

A:错
B:对
答案: 对

for(;;){}可作为无限循环语句。

A:对
B:错
答案: 对

已知表达式int m[] = {0, 1, 2, 3, 4, 5, 6 };下面哪个表达式的值与数组下标量总数相等？

A:Bm.length
B:m.length()
C:m.length()+1
D:m.length+1
答案: Bm.length

下列语句会造成数组new int[10]越界的是（）

A:a[0]+=9;
B:a[0]=a[0]-a[9]
C:for（int i=0;i D:a[9]=10;
答案: for（int i=0;i

当访问无效的数组下标时会发生（）。

A:终止程序
B:直接跳过
C:抛出异常
D:系统崩溃
答案: 抛出异常

下列关于字符串的描述中，错误的是().

A:两种不同的字符串都是 String 类的对象
B:Java 语言中不再使用字符数组存放字符串
C:Java 语言中，字符串分为字符串常量和字符串变量两种
D:Java Application 程序的 main( )的参数 args[] 是一个 String 类的对象数组，用它可存放若干个命令行参数
答案: 两种不同的字符串都是 String 类的对象

 score是一个整数数组，有五个元素，已经正确初始化并赋值，仔细阅读下面代码，程序运行结果是（）
temp = score[0];
for (int index = 1;index if (score[index] temp = score[index];
}
}

A:求最大数
B:找到数组最后一个元素
C:编译出错
D:求最小数
答案: 求最小数

编译并且执行以下代码，会出现什么情况？
public class Q{
public static void main(String argv[]){
int anar[]=new int[]{1,2,3};
System.out.println(anar[1]);
}
}

A:有错误，数组anar在初始化以前不能正常输出。
B:1
C:2
D:有错误，数组的大小没有定义。
答案: 2

以下程序的输出结果是
public class ko6_9
{
public static void main(String args[])
{
int sum=0;
int ko[][]={{1,2,3},{4,5,6},{7,8,9}};
for(int n=0;n for(int m=0;m sum+=ko[n][m];
System.out.println(“sum=”+sum);
}
}

A:sum=9
B:sum=0
C:sum=55
D:sum=45
答案: sum=45

执行下面程序段的输出结果为( )。
public class Q
{
public static void main(String argv[])
{
int anar[]=new int[5];
System.out.println(anar[0]);
}
}

A:0
B:5
C:2
D:1
答案: 0

以下各选项中能正确声明一个表示50个值为null的字符串数组的是()。

A:stringa[]；
B:stringa[]=newString[50]
C:chara[50][]；
D:string[]a；
答案: stringa[]=newString[50]

下列程序运行的结果是______。
　　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 “);
　　System.out.print(ex.ch);
　　}
　　public void change(String str,char ch[]){
　　str=”test ok”;
　　ch[0]=’g’;
　　}

A:test ok and abc
B:good and abc
C:test ok and gbc
D:good and gbc
答案: good and gbc

下面关于数组的说法中，错误的是（）

A:数组必须先声明，然后才能使用
B:数组可以在内存空间连续存储任意一组数据
C:在类中声明一个整数数组作为成员变量，如果没有给它赋值，数值元素值为空
D:数组本身是一个对象
答案: 数组可以在内存空间连续存储任意一组数据;
在类中声明一个整数数组作为成员变量如果没有给它赋值数值元素值为空

下列关于数组的定义形式，错误的是 ().

A:int[]a;a=new int; ;
B:int[Jc=new char[lOJ;
C:int[]d[3J=new int[2] D:char b[];b=new char[80];
答案: ;
;

引用数组元素时，数组下标可以是（）。

A:其余都不是
B:整型常量
C:整型变量
D:整型表达式
答案: 整型常量;
整型变量;
整型表达式

下面声明数组的写法正确的是（）

A:int[][3] a;
B:int[3][] a;
C:int a[];
D:int[] a;
答案: ;
;

执行完代码int[] x=new int[25];后，以下说法不正确的是（）

A:x[24]未定义
B:x[25]为0
C:x[0]为空
D:x[24]为0
答案: 未定义;
为;
为空

下列关于 Java 语言的数组描述中，正确的是（）。

A:数组的长度通常用 length 表示
B:数组下标从0开始
C:数组元素是按顺序存放在内存的
D:数组在赋初值和赋值时都不判界
答案: 数组的长度通常用表示;
数组下标从开始;
数组元素是按顺序存放在内存的

下面关于数组声明和初始化的语句哪个语法是正确的？

A:BString a2[]={“string1″,”string2″,”string3”};
B:int[][] a4=new int[3][3];
C:int a1[]={3,4,5};
D:String a3[]= new String(3);
答案: ;
;

下面哪一个不是合法的数组声明和构造语句（）

A:int[] a=new int[100];
B:int（） a=new int[100];
C:int[] a=[100];
D:int a=new int[100];
答案: ;
;

对于数组 int[][] t={{1,2,3}{4,5,6}};来说t.length=3,t[0].length=3

A:错
B:对
答案: 错

数组由具有一个名字和相同类型的一组连续内存单元构成

A:对
B:错
答案: 对

数组对象的长度在数组对象创建之后，还可以改变。

A:错
B:对
答案: 错

一个数组可以存放许多不同类型的数值

A:对
B:错
答案: 错

数组可以声明为任何数据类型

A:错
B:对
答案: 对

java中数组的元素可以是简单数据类型的量，也可以是某一类的对象

A:对
B:错
答案: 对

数组声明后其大小固定

A:错
B:对
答案: 错

grid[9][5]是二维数组

A:错
B:对
答案: 对

编译并且执行以下代码，结果为1？
public class Q{
public static void main(String argv[]){
int anar[]=new int[]{1,2,3};
System.out.println(anar[1]);
}
}

A:对
B:错
答案: 错

二维数组的列的长度可以不同

A:对
B:错
答案: 对

数组中可以包含什么类型的元素？         

A:int型 

B:float
C: 数组 

D:string型
答案: 微软雅黑型;
微软雅黑;
微软雅黑数组;
微软雅黑型

类成员和对象成员的区别是前者加（）修饰符

A:static
B:abstract
C:private
D:final
答案: static

下列访问权限控制符中权限最小的是

A:public
B:默认
C:private
D:protected
答案: private

创建对象时调用（）方法

A:main
B:set
C:构造
D:get
答案: 构造

将类放在包中，使用（）语句。

A:package
B:include
C:import
D:namespace
答案: package

类内定义了一个String类型的属性，未赋初值，则其值为

A:“空格”
B:”null”
C:“空串”
D:”abc”
答案: “null”

包外子类能访问，非子类不能访问，指的是哪种修饰符修饰的成员？

A:默认
B:private
C:public
D:protected
答案: protected

关于import语句说法错误的是：

A:只能有一条
B:支持通配符
C:可以有多条
D:放在类外面
答案: 只能有一条

对于private成员，允许访问的是

A:包外
B:包内
C:类内
D:类外
答案: 类内

要访问包外的某个无继承关系的类的方法，需要满足

A:类是公共的就行
B:方法是公共的就行
C:类和方法都是公共的
D:类和方法都不必是公共的
答案: 类和方法都是公共的

定义类时，用（）指代当前对象

A:变量
B:类
C:方法
D:属性
答案: 类

构造函数主要用于创建对象时调用。

A:错
B:对
答案: 对

通过类名可以直接调用实例方法（不用static修饰）。

A:错
B:对
答案: 错

同一类中，main方法可以直接调用实例方法。

A:对
B:错
答案: 错

构造方法的返回值是void，方法名同类名。

A:对
B:错
答案: 错

通过对象名可以调用静态方法

A:对
B:错
答案: 对

定义类时，构造方法必须定义。

A:错
B:对
答案: 错

成员属性必须初始化。

A:对
B:错
答案: 错

导入包中的类使用include语句。

A:对
B:错
答案: 错

package语句可以省略，写的话要放在第一句。

A:对
B:错
答案: 对

公共类中的方法在包外允许访问。

A:对
B:错
答案: 错

类的特征有（）

A:抽象
B:多态
C:继承
D:封装
答案: 抽象;
多态;
继承;
封装

final可以修饰

A:类
B:方法
C:局部变量|常量
D:成员属性
答案: 类;
方法;
局部变量常量;
成员属性

外部类的访问控制符可以是

A:private
B:protected
C:不加
D:public
答案: 不加;

下列有关构造方法说法正确的是

A:返回类型为void
B:构造方法只能有一个
C:可以有多个
D:方法名同类名
答案: 可以有多个;
方法名同类名

关于静态方法的访问说法正确的是

A:可通过类名访问
B:不可通过对象访问
C:可通过对象访问
D:不可通过类名访问
答案: 可通过类名访问;
可通过对象访问

关于实例成员访问说法正确的是

A:可通过类名访问
B:可通过对象访问
C:可在同一类内其它实例方法内直接用方法名调用
D:可在同一类内其它静态方法内直接用方法名调用
答案: 可通过对象访问;
可在同一类内其它实例方法内直接用方法名调用

A a=new A();则A b=a完成的功能为：

A:a，b指向两个相同内容的对象
B:将a中地址值赋给b
C:a，b指向同一个对象
D:让b指向a所指对象的一个copy
答案: 将中地址值赋给;
指向同一个对象

成员属性的访问控制符可以是

A:private
B:public
C:不加
D:protected
答案: ;
;
不加;

下列说法错误的是

A:一个源文件中只能定义一个类
B:一个源文件中最多只能定义一个公共类
C:一个源文件中可以定义多个类
D:一个源文件中可以定义多个公共类
答案: 一个源文件中只能定义一个类;
一个源文件中可以定义多个公共类

下列哪种修饰符修饰的成员可以通过包内的其他类访问

A:private
B:默认
C:protected
D:public
答案: 默认;
;