Inti=0;int[]arr;While（true）{intx=（int）Math.random（）*10;arr[i]=x;i++;if（i<5）{break;}}
9、什么是类
参考答案：
类是一个概念（名词）抽象的定义。
类定义了该类型对象的数据结构，称之为“成员变量”，同时，也定义了一些可以被调用的功能，称之为“方法”。
类是用于构建对象的模板，对象的实质就是内存中一块存储区域，其数据结构由定义它的类来决定。
10、简述JVM内存结构堆，栈和方法区别，分别存储的内容
参考答案：
JVM会在其内存空间中开辟一个称为“堆”的存储空间，这部分空间用于存储使用new关键字创建的对象。
栈用于存放程序运行过程当中所有的局部变量。
一个运行的Java程序从开始到结束会有多次方法的调用。
JVM会为每一个方法的调用在栈中分配一个对应的空间，这个空间称为该方法的栈帧。
一个栈帧对应一个正在调用中的方法，栈帧中存储了该方法的参数、局部变量等数据。
当某一个方法调用完成后，其对应的栈帧将被清除。
方法区该空间用于存放类的信息。
Java程序运行时，首先会通过类装载器载入类文件的字节码信息，经过解析后将其装入方法区。
类的各种信息都在方法区保存。
11、什么是方法的重载
参考答案：
在Java语言中，允许多个方法的名称相同，但参数列表不同，称之为方法的重载（overload）。
编译器在编译时会根据其参数的不同，绑定到不同的方法。
12、什么是构造方法
参考答案：
在Java语言中可以通过构造方法实现对对象成员变量的初始化。
构造方法是在类中定义的方法。
但不同于其他的方法，构造方法的定义有如下两点规则：
1.构造方法的名称必须与类名同名。
2.构造方法没有返回值，但也不能写void。
13、重写和重载的区别
参考答案：
重载遵循所谓“编译期绑定”，即在编译时根据参数变量的类型判断应该调用哪个方法。
重写遵循所谓“运行期绑定”，即在运行的时候根据引用变量指向的实际对象类型调用方法。
14、下面哪种情况属于方法重载A
A）方法名相同，参数类型与个数不同
B）方法参数类型相同
C）方法参数个数相同
D）方法返回类型相同
E）方法名相同，方法参数类型与个数也相同
15、如果一个子类要继承父类，需要使用哪个关键字D
A）thisB）superC）publicD）extends
16、classCard{}下列不属于Card类的构造方法的是：
C
A.Card（）{}
B.publicCard（）{}
C.publicvoidCard（）{}
D.privateCard（）{}
17、下列说法正确的是：
classCalssA{
publicintnumberOfinstances;
protectedClassA（intnumberOfinstances）{
this.numberOfinstances=numberOfinstances;
}}
PublicclassExtendedAextendsClassA{
privateExtendedA（intnumberOfinstances）{
super（numberOfinstances）;
}
publicstaticvoidmain（String[]ages）{
ExtendedAext=newExtendedA（420）;
System.out.print（ext.numberOfinstances）;
}}
A.运行后，输出420
B.运行时抛出异常
C.编译错误，所有的构造器必须是public的
D.编译错误，构造器不能private的
18、下列不属于java语言特征的是：
C
A.平台无关
B.面向对象
C.支持指针类型
D.垃圾回收机制
19、下列代码的输出结果是：
（C）
publicclassA{
Publicvoidinfo（）{
System.out.println（“Ainfo”）;
}
}
publicclassBextendsA{
publicvoidinfo（）{
System.out.println（“Binfo”）
}
Publicstaticvoidmain（String[]ages）{Bb=newB（）;Aa=b;a.info（）;}}
A.BinfoAinfo
B.AinfoBinfo
C.Ainfo
D.Binfo
20、下列输出结果是：
FOO
classFoo{
publicstaticvoidtest（）{
System.out.println（"Foo"）;}
}
classMooextendsFoo{
publicstaticvoidtest（）{
System.out.println（"Moo"）;
}
}
publicstaticvoidmain（String[]args）{
Fooff=newMoo（）;ff.test（）;
}
21、以下描述不正确的是？
（C）
A.finalclass不能被继承
B.final变量不能被修改
C.final成员变量不可以在构造方法中赋值
D.final方法不能被覆盖（overriden）
22、以下描述不正确的是？
接口的所有成员都应该公开，所以是 public
接口不能实例化，所以只有静态成员：
static
接口的成员一定应该是常量，所以是 final。
A.abstractclass一定有abstractmethod（s）
B.abstractclass可以没有abstractmethod（s）
C.定义abstractclass的目的是为了被继承
D.interface中定义的方法全是abstractmethods
E.interface中定义的变量全部是finalstatic变量
23、一个匿名内部类不可能是？
A.继承其他的类
B.实现了某一接口
C.定义了构造方法因为匿名内部类没有类名
D.可以使用成员变量
24、下面关于java语言中方法的说法错误的是：
A.方法调用时参数类型必须符合方法的定义
B.参数传递是值传递的方式
C.如果方法没有返回值必须声明返回为void
D.如果方法定义为返回void，则方法中不能出现return语句
25、下面运行的结果是：
publicclassFoo{
publicStringdoit（intx,inty）{
return"a"; }
publicStringdoit（int[]vals）{
return"b"; }
publicstaticvoidmain（String[]args）{
Foof=newFoo（）;
System.out.println（f.doit（4,5））;
}
}
A.代码publicStringdoit（int[]vals）{行，编译出错
B.代码System.out.println（f.doit（4,5））;行，抛出运行时异常
C.输出：
a
D.输出：
b
26、关于下列代码说法正确的是：
publicclassFoo{
publicintadd（inta,intb）{
returna+b;
}
publicstaticvoidmain（String[]args）{
Foofoo=null;
System.out.println（foo.add（10,20））;
}
}
A.编译错误
B.正常运行，但无结果输出
C.运行输出：
30
D.运行时抛出NullPointerException异常
27、下列说法正确的有：
A.class中的constructor不可省略
B.constructor必须与class同名，但方法不能与class同名
C.constructor在一个对象被实例化时执行
D.一个class只能定义一个constructor
28、关于Java中继承的特点，下列说法正确的是:
A.使类的定义复杂化
B.Java只支持单继承，不可多继承，但可以通过实现接口来达到多继承的目的
C.子类继承父类的所有成员变量和方法，包括父类的构造方法
D.不可以多层继承，即一个类不可以继承另一个类的子类
1.子类继承父类的成员变量
当子类继承了某个类之后，便可以使用父类中的成员变量，但是并不是完全继承父类的所有成员变量。
具体的原则如下：
1）能够继承父类的public和protected成员变量；不能够继承父类的private成员变量；
2）对于父类的包访问权限成员变量，如果子类和父类在同一个包下，则子类能够继承；否则，子类不能够继承；
3）对于子类可以继承的父类成员变量，如果在子类中出现了同名称的成员变量，则会发生隐藏现象，即子类的成员变量会屏蔽掉父类的同名成员变量。
如果要在子类中访问父类中同名成员变量，需要使用super关键字来进行引用。
2.子类继承父类的方法
同样地，子类也并不是完全继承父类的所有方法。
1）能够继承父类的public和protected成员方法；不能够继承父类的private成员方法；
2）对于父类的包访问权限成员方法，如果子类和父类在同一个包下，则子类能够继承；否则，子类不能够继承；
3）对于子类可以继承的父类成员方法，如果在子类中出现了同名称的成员方法，则称为覆盖，即子类的成员方法会覆盖掉父类的同名成员方法。
如果要在子类中访问父类中同名成员方法，需要使用super关键字来进行引用。
29、下列程序运行结果是？
30、请看下列代码
classClassA{}
classClassBextendsClassA{}
classClassCextendsClassA{}
publicclassTest{
publicstaticvoidmain（String[]args）{
ClassAp0=newClassA（）;
ClassBp1=newClassB（）;
ClassCp2=newClassC（）;
ClassAp3=newClassB（）;
ClassAp4=newClassC（）;
<插入代码>
}
}
下列选项中放置在<插入代码>处，使程序编译正确的是：
A.p0=p1;
B.p1=p2;
C.p2=p4;
D.p2=（ClassC）p1;
31、程序输出的结果是
classOne{
publicOne（）{ System.out.print
（1）;
}
classTwoextendsOne{
publicTwo（）{
System.out.print
（2）;
}
}
classThreeextendsTwo{
publicThree（）{
System.out.print（3）;
}
}
publicclassNumbers{ publicstaticvoidmain（String[]argv）{ newThree（）; }}C
A.1 B.3 C.123 D.321
32、下面代码运行结果是：
D
publicclassAnimal{
publicStringnoise（）{
return"peep";
}
classDogextendsAnimal{
publicStringnoise（）{ return"bark";
}
}
classCatextendsAnimal{
publicStringnoise（）{
return"meow";
}
}
publicstaticvoidmain（String[]args）{
Animalanimal=newDog（）;
Catcat=（Cat）animal;
System.out.println（cat.noise（））;
}
}
A.peep
B.bark
C.meow
D.抛出运行时异常
33、下面代码运行结果是：
34、
classSimpleCalc{
publicintvalue;
publicvoidcalculate（）{
value+=7;
}
}
publicclassMultiCalcextendsSimpleCalc{
publicvoidcalculate（）{
value-=3;
}
publicvoidcalculate（intmultiplier）{
calculate（）;
super.calculate（）;
value*=multiplier;
}
publicstaticvoidmain（String[]args）{
MultiCalccalculator=newMultiCalc（）;
calculator.calculate
（2）;
System.out.println（"Valueis:
"+calculator.value）;
}}
A.Valueis:
8
B.Valueis:
-8
C.Valueis:
12
D.Valueis:
-12
35、下列数组创建和初始化的方式不正确的是：
A.publicclassTest02{
staticfinalint[]a={100,200};}
B.publicclassTest02{
staticfinalint[]a;
static{
a=newint[2];
a[0]=100;
a[1]=200; }}
C.publicclassTest02{
finalint[]a;
publicTest02（）{
a=newint[2];
a[0]=100;a[1]=200; }}
D.publicclassTest02{
staticfinalint[]a;
staticvoidinit（）{
a=newint[3];
a[0]=100;
a[1]=200; }}
36、请看下列代码：
publicabstractclassA{ abstractvoida1（）; voida2（）{ }}
classBextendsA{ voida1（）{ } voida2（）{ }}
classCextendsB{ voidc1（）{ }}
和
Ax=newB（）;
Cy=newC（）;
Az=newC（）;
下列选项中属于多态形式调用方法的是：
A.x.a2（）;
B.z.a2（）;
C.z.c1（）;
D.y.c1（）;
36、程序执行的结果是：
publicclassTest{
intx=12;
publicvoidmethod（intx）{
x+=x;
System.out.println（x）;
}
publicstaticvoidmain（String[]args）{
Testt=newTest（）;
t.method（5）;B
}}
A.5 B.10 C.12 D.17
37、程序执行的结果是：
classFoo{
publicinta;
publicFoo（）{
a=3;
}
publicvoidaddFive（）{
a+=5; }
}
classBarextendsFoo{
publicinta;
publicBar（）{
a=8; }
publicvoidaddFive（）{
this.a+=5; }
}
publicclassTestFoo{
publicstaticvoidmain（String[]args）{
Foofoo=newBar（）;
foo.addFive（）;
System.out.println（"Value:
"+foo.a）; }}
A.Value:
3
B.Value:
8
C.Value:
13
D.Value:
18
38、程序运行结果
publicclassTest{
publicstaticvoidmain（String[]args）{
Childc=newChild（）;
}}
classFather{
publicFather（）{
System.out.println（"父类无参构造函数"）;
}
publicFather（Stringname）{
System.out.println（"父类有参构造函数"）;
}}
classChildextendsFather{
publicChild（）{
this（"dd"）;
System.out.println（"子类无参构造函数"）;
}
publicChild（Stringname）{
super（"dd"）;
System.out.println（"子类有参构造函数"）;
}}
A.父类有参构造函数
子类有参构造函数
子类无参构造函数
B.父类无参构造函数
子类有参构造函数
子类无参构造函数
C.子类有参构造函数
子类无参构造函数
父类无参构造函数
D.子类无参构造函数
子类有参构造函数
父类无参构造函数
39、下列代码的运行结果是：
publicclassAnimal{
publicStringnoise（）{
return"peep"; }
publicstaticvoidmain（String[]args）{
Catcat=null;
Animalanimal=newDog（）;
if（animalinstanceofCat）{
cat=（Cat）animal;
System.out.println（cat.noise（））;
}else{
System.out.println（"animalisnotCat'sinstance"）;
}}}
classDogextendsAnimal{
publicStringnoise（）{
return"bark";
}}
classCatextendsAnimal{
publicStringnoise（）{
return"meow";
}}
A.peep
B.bark
C.meow
D.animalisnotCat'sinstance
升级会员 