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];
正确答案：
B
//代码太多了，自己在eclipse运行一下，用debug调试一下，每次数组的变化，其实就是将两个数组按从小到大的顺序合并
9.（单选）A类中有一个方法：
protectedintprint（Stringstr）{},
B类继承A类，以下方法能在B类中重写A类中print（）方法的是:
（）。
//考大家重写：
重写原则：
两同两小一大
重写要求子类中的返回值类型小于或者等于父类型，有一个特殊情况，如果父类的返回值类型是基本类型或者是void的，子类必须与父类保持一致
A.publicintprint（Stringstr）{}
B.privateintprint（Stringstr）{}
C.privatevoidprint（Stringstr）{}
D.publicvoidprint（Stringstr）{}
正确答案：
A
10.（单选）下列代码的输出结果是（）。
boolean
b=true?
false:
true==true?
false:
true;
System.out.println（b）;
//三目运算符结构：
boolean表达式？
表达式1：
表达式2
true?
false:
true==true?
false:
true;
选择表达式1：
false
A.true
B.false
C.null
D.空字符串
正确答案：
B
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;
正确答案：
D
12.（单选）类Super及Sub定义如下：
publicclassSuper{
privatevoidf（）{
System.out.println（"Super.f（）"）;}
publicvoidg（）{
f（）;}
publicvoidk（）{f（）;
}}
publicclassSubextendsSuper{
privatevoidf（）{
System.out.println（"Sub.f（）"）;}
publicvoidk（）{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（）
正确答案：
C
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的
正确答案：
A
//子类（Subclass）可以继承父类（Superclass）的成员变量及成员方法。
届时，子类将具有父类的成员
注意补充：
java构造方法的修饰符：
public,protected,默认，private四种都可以
使用public修饰构造方法，那么所有的类都可以实例化这个类。
使用private修饰构造方法，那么所有的类都不可以实例化使用这个类。
14.
（单选）关于下列代码说法正确的是：
publicclassA{
privateintcounter=0;
publicstaticintgetInstanceCount（）{
returncounter;}
publicA（）{counter++;}
publicstaticvoidmain（String[]args）{
Aa1=newA（）;
Aa2=newA（）;
Aa3=newA（）;
System.out.println（A.getInstanceCount（））;}}
A.该类编译失败
B.输出：
1
C.输出：
3
D.输出：
0
正确答案：
A
//在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;i<10）{}//缺循环变量的变化
正确答案：
D
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;}}
正确答案：
C
//接口无法实例化：
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”）;}，编译将通过
正确答案：
C
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调试，非常容易看到结果的变化
System.out.println（"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;}//如果返回值是基本类型要保持一致
正确答案：
A
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
正确答案：
B
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]
正确答案：
D
src：
源数组
srcPos：
源数组中的起始位置
dest：
目标数组
destPos:
目标数组中的起始位置
length：
要复制的数组元素的数量
arraycopy（Objectsrc,intsrcPos,Objectdest,intdestPos,intlength）
23.
（单选）下列数组声明语句中，错误的是：
（）。
A.int[]arr=newint[8];
B.int[]arr=newint[8]{};
C.int[]arr={};
D.int[]arr=newint[]{};
正确答案：
B
24.
（单选）下列代码编译和运行的结果是：
publicstaticvoidmain（String[]args）{
String[]elements={"for","tea","too"};
Stringfirst=（elements.length>0）?
elements[0]:
null;
true
System.out.println（first）;}
A.编译出错
B.输出：
tea
C.输出：
for
D.输出：
null
正确答案：
C
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;
System.out.println（"a="+a+",b="+b）;
输出的结果是：
（）。
A.a=100,b=300
B.a=100,b=200
C.a=200,b=100
D.a=300,b=200
正确答案：
C
26.（单选）下列关于JVM说法，错误的是（）。
A.JVM通过专门的线程实现内存的回收。
B.使用java命令时，可以通过参数来设置分配JVM的内存大小。
C.JRE包括JVM及Java核心类库。
D.目前主流版本JVM通过纯解释的方式运行Java字节码。
正确答案：
D
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*/}}
正确答案：
A
先继承后实现，排除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（）{
System.out.print（"B（）"）;
System.out.println（a）;}}
运行下面的代码：
newB（）;
实例化B类对象，程序调用B类无参构造器，执行代码前先隐式调用父类无参构造
输出的结果是：
（）。
升级会员 