1609第一次月考详细解析Word格式.docx
《1609第一次月考详细解析Word格式.docx》由会员分享，可在线阅读，更多相关《1609第一次月考详细解析Word格式.docx（33页珍藏版）》请在冰点文库上搜索。
A._mem
B.12a//不能以数字开头
C.M12
D.$12
6.（单选）下列Java标识符，错误的是（）
A._sys_varl
B.$change
C.User_name
D.1_file//不能以数字开头
D
7.（单选）Java程序的执行过程中用到一套JDK工具，其中javac.exe是指（）。
A.Java语言编译器
B.Java字节码解释器
C.Java文档生成器
D.Java类分解器
A
8.（单选）运行下列代码：
int[]oneArr={2,11,26,27,37,44,48,60};
int[]twoArr={19,35,49,55,58,75,83,84,91,93};
int[]threeArr=newint[oneArr.length+twoArr.length];
intp=0,q=0;
while（p<
oneArr.length&
&
q<
twoArr.length）{
threeArr[p+q]=oneArr[p]<
twoArr[q]?
oneArr[p++]:
twoArr[q++];
}
if（p<
oneArr.length）{
System.arraycopy（oneArr,p,threeArr,p+q,oneArr.length-p）;
}elseif（q<
System.arraycopy（twoArr,q,threeArr,p+q,twoArr.length-q）;
System.out.println（Arrays.toString（threeArr））;
输出的结果是：
A.[2,11,26,27,37,44,48,60,19,35,49,55,58,75,83,84,91,93];
B.[2,11,19,26,27,35,37,44,48,49,55,58,60,75,83,84,91,93];
C.[19,35,49,55,58,75,83,84,91,93,2,11,26,27,37,44,48,60];
D.[2,19,11,35,26,49,27,55,37,58,44,75,48,83,60,84,91,93];
//代码太多了，自己在eclipse运行一下，用debug调试一下，每次数组的变化，其实就是将两个数组按从小到大的顺序合并
9.（单选）A类中有一个方法：
protectedintprint（Stringstr）{},
B类继承A类，以下方法能在B类中重写A类中print（）方法的是:
（）。
//考大家重写：
重写原则：
两同两小一大
重写要求子类中的返回值类型小于或者等于父类型，有一个特殊情况，如果父类的返回值类型是基本类型或者是void的，子类必须与父类保持一致
A.publicintprint（Stringstr）{}
B.privateintprint（Stringstr）{}
C.privatevoidprint（Stringstr）{}
D.publicvoidprint（Stringstr）{}
10.（单选）下列代码的输出结果是（）。
boolean
b=true?
false:
true==true?
true;
System.out.println（b）;
//三目运算符结构：
boolean表达式？
表达式1：
表达式2
true?
选择表达式1：
false
A.true
B.false
C.null
D.空字符串
11.（单选）下列赋值语句中，正确的是（）。
A.byteb1=10,b2=20;
byteb=b1+b2;
//需要强转，byteb=（byte）（b1+b2）
B.byteb1=10,b2=20;
byteb=~b1;
//需要强转,byteb=（byte）（~b1）;
C.byteb1=10,b2=20;
byteb=b1>
>
1;
//需要强转byteb=（byte）（b1>
1）;
D.byteb1=10;
byteb=++b1;
12.（单选）类Super及Sub定义如下：
publicclassSuper{
privatevoidf（）{
System.out.println（"
Super.f（）"
）;
}
publicvoidg（）{
f（）;
publicvoidk（）{f（）;
}}
publicclassSubextendsSuper{
privatevoidf（）{
System.out.println（"
Sub.f（）"
}}
运行下列语句:
Superobj=newSub（）;
//创建了一个obj的引用变量指向Sub对象，类型为Super
obj.g（）;
//能点出来什么看类型，所以这时调的g方法应该是访问Super的g（）方法，g方法里调f（）方法，父类的f（）方法为private为不可重写。
虽然子类中看上去重写了，其实是两个无关f（）方法，只是方法名而已。
在多态调用的时候，只会直接找父类的f（）方法.
所以调用f（）方法时，实际是调用父类的private。
输出：
Super.f（）
obj.k（）;
//调k（）方法，子类重写后的版本，它为一个公共方法，该公共方法再调用本类的私有方法.输出：
Sub.f（）
A.Sub.f（）Sub.f（）
B.Sub.f（）Super.f（）
C.Super.f（）Sub.f（）
D.Super.f（）Super.f（）
13.
（单选）关于下列代码说法正确的是：
classClassA{
publicintnumberOfinstances;
protectedClassA（intnumberOfinstances）{
this.numberOfinstances=numberOfinstances;
}}
publicclassExtendedAextendsClassA{
privateExtendedA（intnumberOfinstances）
{super（numberOfinstances）;
publicstaticvoidmain（String[]args）{
ExtendedAext=newExtendedA（420）;
//new对象，走进子类构造方法，执行代码前先调用父类的有参构造方法
System.out.print（ext.numberOfinstances）;
A.运行后，输出420
B.运行时抛出异常
C.编译错误，所有的构造器必须是public的
D.编译错误，构造器不能是private的
//子类（Subclass）可以继承父类（Superclass）的成员变量及成员方法。
届时，子类将具有父类的成员
注意补充：
java构造方法的修饰符：
public,protected,默认，private四种都可以
使用public修饰构造方法，那么所有的类都可以实例化这个类。
使用private修饰构造方法，那么所有的类都不可以实例化使用这个类。
14.
publicclassA{
privateintcounter=0;
publicstaticintgetInstanceCount（）{
returncounter;
publicA（）{counter++;
Aa1=newA（）;
Aa2=newA（）;
Aa3=newA（）;
System.out.println（A.getInstanceCount（））;
A.该类编译失败
B.输出：
1
C.输出：
3
D.输出：
//在static方法中无法返回非static的变量由于static在调用时没有具体的对象，因此在static方法中不能对非static成员（对象成员）进行访问。
15.（单选）下面for语句,存在编译错误的是（）。
A.for（;
;
）{}//相当于while（true），死循环
B.for（inti=0;
i<
100;
i++）{}
C.for（inti=0,j=0;
i++,j++）{}//相当于while（true），死循环
D.for（inti=0;
10）{}//缺循环变量的变化
16.
（单选）请看下列代码：
interfaceFoo{
intbar（）;
publicclassSprite{
publicintfubar（Foofoo）{
returnfoo.bar（）;
publicvoidtestFoo（）{
fubar（<
插入代码>
）;
使类Sprite编译通过，在<
处应填入的代码是：
A.Foo{publicintbar（）{return1;
B.newFoo{publicintbar（）{return1;
C.newFoo（）{publicintbar（）{return1;
D.newclassFoo{publicintbar（）{return1;
//接口无法实例化：
fubar方法中需要传入一个Foo类型的参数，但是Foo只是一个接口，无法直接实例化对象，因此在这里我们选择了匿名内部类进行实例化
17.
publicclassPlant{
privateStringname;
publicPlant（Stringname）{
this.name=name;
}//Plant中的有参的构造方法
publicStringgetName（）{returnname;
classTreeextendsPlant{
publicvoidgrowFruit（）{}
publicvoiddropLeaves（）{}}
下列说法正确的是：
A.在Tree类中添加代码：
publicTree（）{Plant（）;
}，编译将通过
//子类构造方法中调用父类的构造方法，写法是：
super（）;
不写的话系统会默认有
B.在Plant类中添加代码：
publicPlant（）{Tree（）;
C.在Plant类中添加代码：
publicPlant（）{this（”fern”）;
}，编译将通//无参构造方法中调用有参的构造方法，可以。
格子类的时候，有类似的例子
D.在Plant类中添加代码：
publicPlant（）{Plant（”fern”）;
18.
（单选）请看下列代码编译和运行的结果是（）。
interfaceDeclareStuff{
publicstaticfinalintEASY=3;
voiddoStuff（intt）;
publicclassTestDeclareimplementsDeclareStuff{
publicstaticvoidmain（String[]args）{
intx=5;
newTestDeclare（）.doStuff（++x）;
}
//调用方法，把++x（为6）传给了形参s，这时s为6
s=6+3+7
voiddoStuff（ints）{//编译错误，方法缺public修饰，接口的方法默认都是由publicabstract修饰的
s+=EASY+++s;
//等同于s=s+EASY+（++s）
//用debug调试，非常容易看到结果的变化
s="
+s）;
A.s=14
B.s=16
C.s=10
D.编译失败
D//如果没有编译错误，能输出s=16
19.
（单选）下列关于IDE开发环境Eclipse，说法错误的是：
A.Eclipse可以通过插件（plugin）的方式扩展其功能。
B.Eclipse联盟是由IBM公司捐资组建的。
C.Eclipse使用了SWT图形界面技术。
D.Eclipse的运行不需要有JRE的支持。
D//这题都要讲解的话，是在侮辱你的智商
20.
（单选）下列代码的输出结果是：
publicclassBlip{
protectedintblipvert（intx）{return0;
classVertextendsBlip{<
在<
处填入选项中的代码，使Vert类没有编译错误的是（）。
//继承，可以对方法进行重写，两同两小一大原则：
A.publicintblipvert（intx）{return0;
B.privateintblipvert（intx）{return0;
}//权限要比父类大或相等
C.privatevoidblipvert（intx）{return0;
}//权限和返回类型都错了
D.protectedlongblipvert（intx）{return0;
}//如果返回值是基本类型要保持一致
21.
（单选）下列表达式中，可以得到精确结果的是（）。
A.doubled1=3.0-2.6;
B.doubled4=2.5*1.5;
C.doubled2=30/300;
D.doubled3=1/2+0.5;
//1/2是取整，为0，没法得到0.5
22.
（单选）下列代码的输出结果是（）。
publicstaticvoidmain（String[]args）{
int[]one=newint[]{4,6,8};
int[]two=newint[]{1,3,5,7,9};
System.arraycopy（one,1,two,2,2）;
System.out.println（Arrays.toString（two））;
A.[1,3,7,4,6]
B.[1,3,5,7,8]
C.[1,3,5,6,9]
D.[1,3,6,8,9]
src：
源数组
srcPos：
源数组中的起始位置
dest：
目标数组
destPos:
目标数组中的起始位置
length：
要复制的数组元素的数量
arraycopy（Objectsrc,intsrcPos,Objectdest,intdestPos,intlength）
23.
（单选）下列数组声明语句中，错误的是：
A.int[]arr=newint[8];
B.int[]arr=newint[8]{};
D.int[]arr=newint[]{};
24.
（单选）下列代码编译和运行的结果是：
String[]elements={"
for"
"
tea"
too"
};
Stringfirst=（elements.length>
0）?
elements[0]:
null;
true
System.out.println（first）;
A.编译出错
tea
for
null
25.（单选）运行下面的程序：
inta=100;
intb=200;
a=a+b;
//a=100+200=300;
b=a-b;
//b=300-200=100;
a=a-b;
//a=300–100=200;
a="
+a+"
b="
+b）;
A.a=100,b=300
B.a=100,b=200
C.a=200,b=100
D.a=300,b=200
26.（单选）下列关于JVM说法，错误的是（）。
A.JVM通过专门的线程实现内存的回收。
B.使用java命令时，可以通过参数来设置分配JVM的内存大小。
C.JRE包括JVM及Java核心类库。
D.目前主流版本JVM通过纯解释的方式运行Java字节码。
JVM先通过javac进行编译，再将编译后的字节码文件通过java指令进行解释运行，如果纯解释的话根本无法识别源码
27.（单选）请看下列代码：
interfaceData{
publicvoidload（）;
abstractclassInfo{
publicabstractvoidload（）;
下列选项中，能正确使用Data接口和Info类的是（）。
A.publicclassEmployeeextendsInfoimplementsData{publicvoidload（）{/*dosomething*/}}
B.publicclassEmployeeimplementsInfoextendsData{publicvoidload（）{/*dosomething*/}}//要先继承后实现
C.publicclassEmployeeimplementsInfoextendsData{publicvoidData.load（）{/*dsomething*/}publicvoidload（）{/*dosomething*/}}
D.publicclassEmployeeextendsInfoimplementsData{publicvoidload（）{/*dosomething*/}publicvoidInfo.load（）{/*dosomething*/}}
先继承后实现，排除BC，D中Info.load（）错误，静态方法才可以通过类名点方法
注意：
接口中的load和Info中的load的签名完全一致，同时没有父子继承关系，所以load方法既不构成重载，也不构成重写。
28.（单选）类A，B的定义如下：
classA{
privateinta=100;
A（）{
System.out.print（"
A（）"
System.out.println（a）;
classBextendsA{
privateinta=200;
B（）{
B（）"
System.out.println（a）;
运行下面的代码：
newB（）;
实例化B类对象，程序调用B类无参构造器，执行代码前先隐式调用父类无参构造
输出的结果是：
升级会员 