JAVA考核题-面向对象选择题(答案)

技术改变世界 创新驱动发展

北润JAVA考核-面向对象

第一部分 英语测试（每题分，共分）

第二部分 知识点测试（分）

一、选择题（每题2分，共110分）

1．下面关于变量及其作用范围的陈述哪个是不对的?（ B ）

A．实例变量是类的成员变量。

B．实例变量用关键字static声明。

C．在方法中定义的局部变量在该方法被执行时创建。

D．局部变量在使用前必须被初始化。

2．下面哪条语句把方法声明为抽象的公共方法?（ B ）

A．public abstract method(); B．public abstract void method();

D．public void method() extends abstract; C．public abstract void method(){}

3．若在某一个类定义中定义有如下的方法：final void aFinalFunction( ){}则该方法属于（ C ）。

A、本地方法 B、静态方法 C、最终方法 D、抽象方法

4．main方法是Java Application程序执行的入口点，关于main方法的方法头以下哪项是合法的（ B ）。

A、 public static void main()

C、 public static int main(String[ ] args)

B、 public static void main(String[ ] args)

D、public void main(String arg[ ])

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

A、隐藏 B、覆盖 C、重载 D、Java不支持此特性

6．下列关于构造方法的叙述中，错误的是（ C ）

A．Java语言规定构造方法名与类名必须相同

B．Java语言规定构造方法没有返回值，但不用void声明

C．Java语言规定构造方法不可以重载

D．Java语言规定构造方法只能通过new自动调用

您的未来就是我们的未来

技术改变世界 创新驱动发展

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

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

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

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

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

8．类Test1定义如下：

1. public class Test1{

2． public floataMethod(float a, float b){}

3．

4．}

将以下哪种方法插入行3是不合法的。（ B ）

A、public float aMethod（float a,floatb,float c）{ }

B、public float aMethod（float c,floatd）{ }

C、public int aMethod（int a,intb）{ }

D、private float aMethod（inta,intb,intc）{ }

9．阅读以下代码：

public class foo{

public static void main (String[] args){

String s;

n("s=" + s);

}

}

输出结果应该是：（ C ）

A．代码得到编译，并输出“s=”

B．代码得到编译，并输出“s=null”

C．由于String s没有初始化，代码不能编译通过

D．代码得到编译，但捕获NullPointException异常

解析：局部变量必须显示的初始化。引用类型变量初始化时如果没有具体对象引用，可

您的未来就是我们的未来

技术改变世界 创新驱动发展

以初始化为null。

10．下述概念中不属于面向对象这种编程范畴的是( D )。

A．对象、消息 B．继承、多态

C．类、封装 D．过程调用

11．编译并运行以下程序，以下描述哪个选项是正确的( A )。

1. class A{

2. protected String toString(){

3.

4. }

A、行2出错，不能成功编译

C、编译通过运行无异常

B、编译通过但运行时出错

return ng();}

D、不能成功编译，行3出错

解析：方法重写时没有满足访问权限控制符要比父类的大或者相同。

12．假设Foo类有如下定义，设f是Foo类的一个实例，下列语句调用哪个是错误的？( A )

public class Foo

{

int i;

}

A、d(); B、d(); C、n(f.i); D、d()

static String s;

void imethod() { }

static voidsmethod() { }

13．以下哪个接口的定义是正确的？( D )

A、interface A

{ void print() { } ;}

B、abstract interface A

{ void print() ;}

C、abstract interface A extends I1, I2 //I1、I2为已定义的接口

{ abstract void print(){ };}

D、interface A

您的未来就是我们的未来

技术改变世界 创新驱动发展

{ void print();}

解析：接口定义时语法规定上是不需要加abstract的，因为接口本身就是abstract的，java编译器在编译接口时会自动加上abstract。但是我们显示的加上abstract是不会出现问题，不建议加。此处选项B和C可以认为不正确。

14．关于以下程序段，正确的说法是( C )

1． String s1=“a”+“b”;

2． String s2=new String（s1）；

3． if（s1==s2）

4． n(“= = is succeeded”);

5． if ((s2))

6． n(“.equals() is succeeded”);

A．行4与行6都将执行 B．行4执行，行6不执行

C．行6执行，行4不执行 D．行4、行6都不执行

15．下面程序运行结果为：（ D,如果输出count则为A）

public class test3{

public static void main(String args[]){

int count=0;

for (int i=0;i<=100;i++)

count+=count++;

}

}

A 0 B 7 C 编译有错误 D 其他答案

16．下面哪个函数是public void aMethod(){...}的重载函数？（ D ）

A、void aMethod( ){...}

B、public int aMethod(){...}

C、public void aMethod ( ){...}

D、public int aMethod ( int m){...}

17．下面关于继承的哪些叙述是正确的?( D )

您的未来就是我们的未来

技术改变世界 创新驱动发展

A．在java中允许多继承。

B． 在java中一个类只能实现一个接口。

C． 在java中一个类不能同时继承一个类和实现一个接口。

D． java的单一继承使代码更可靠。

18．运行下面程序段的结果是：( D )。

public class MyMain{

public static void main(String args){

n(“Hello Java”);

}

}

A．正常输出Hello Java

B．编译时出错

C．运行时出错

D. 以上答案都不对

19．类与对象的关系是( A )。

A.类是对象的抽象

C.对象是类的抽象

B.类是对象的具体实例

D.对象是类的子类

20．下列关于修饰符混用的说法，错误的是( BD )。

A. abstract不能与final并列修饰同一个类

B. abstract类中不可以有private的成员

C. abstract方法必须在abstract类中

D. static方法中能处理非static的属性

解析：abstract类中可以有private的成员，只是它的private成员不能被继承，所以在abstract类中定义private成员没有意义。

21．编译并运行下述程序段的结果是：( B )。

public class Test{

public static void main(String argv[]){

int[] count = new int[4];

n(count[4]);

您的未来就是我们的未来

技术改变世界 创新驱动发展

}

}

A．编译时错误

C．输出0

B．运行时错误

D．输出null

22．下面是有关子类继承父类构造函数的描述，其中正确的是( CD)。

A．创建子类的对象时, 先调用子类自己的构造函数，然后调用父类的构造函数。

B．子类无条件地继承父类不含参数的构造函数。

C．子类必须通过super关键字调用父类的构造函数。

D．子类无法继承父类的构造函数。

解析：子类无法继承父类的构造器，但有时候可以使用super调用父类构造器中的初始化代码。在继承关系中一定要确保构造器的上溯链不得中断，否则会出错。

23．下列类的定义中，错误的是( B )。

A．class x { .... }

B．public x extends y{ .... }

C．public class x extends y{ .... }

D．class x extends y implements y1{ .... }

24．A派生出子类B ，B派生出子类C，并且在Java源代码中有如下声明：

1. A

2. A

3. A

a0=new A();

a1 =new B();

a2=new C();

问以下哪个说法是正确的？（ D ）

A．只有第1行能通过编译

B．第1、2行能通过编译，但第3行编译出错

C．第1、2、3行能通过编译，但第2、3行运行时出错

D．第1行、第2行和第3行的声明都是正确的

25．运行下列程序的结果是( C )

您的未来就是我们的未来

技术改变世界 创新驱动发展

abstract class MineBase {

}

public class Mine extends MineBase {

}

A．打印5个0 B．编译出错，数组ar[]必须初始化

C．编译出错，Mine应声明为abstract D．出现IndexOutOfBoundes的例外

26．编译并运行以下程序段的结果是：（ A ）

public class MyClass{

final static int i;

MyClass(){i =0;}

public static void main(String args[]){

n(i);

}

}

A．编译出错 B．null C．1 D．0

abstract void amethod();

static int i;

public static void main(String argv[]) {

}

int[] ar = new int[5];

for (i = 0; i < ; i++) {

}

n(ar[i]);

解析：final修饰的成员变量（静态成员原理和实例成员变量）必须显示初始化。静态成员变量可以在声明时或静态初始化代码块显示初始化；实例成员变量可以在声明时、初始化代码块或构造器中显示初始化。

27．下面方法中的“返回类型Type”应该是什么？( A )

public class ReturnIt{

returnTypemethodA(byte x, double y){

您的未来就是我们的未来

技术改变世界 创新驱动发展

return (short)x / y * 2;

}

}

A．double B. int C. byte D. short

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

A、public B、private C、static D、final

29．下面关于java中类的说法哪个是不正确的?（ AC ）

A．类体中只能有变量定义和成员方法的定义，不能有其他语句。

B．构造函数是类中的特殊方法。

C．类一定要声明为public的，才可以执行。

D．一个java文件中可以有多个class定义。

30．下列哪个类声明是正确的? ( D)

A．abstract final class H1｛…｝

B．abstract private move()｛…｝

C．protected private number；

D．public abstract class Car｛…｝

31．方法重载是指( A )

A．两个或两个以上的方法取相同的方法名，但形参的个数或类型不同

B．两个以上的方法取相同的名字和具有相同的参数个数，但形参的类型可以不同

C．两个以上的方法名字不同，但形参的个数或类型相同

D．两个以上的方法取相同的方法名，并且方法的返回类型相同

32．指出下列程序运行的结果( B )

public class Example{

String str=new String("good");

char[]ch={'a','b','c'};

public static void main(String args[]){

Example ex=new Example();

(,);

(+" and ");

您的未来就是我们的未来

技术改变世界 创新驱动发展

();

}

public void change(String str,charch[]){

str="test ok";

ch[0]='g';

}

}

A．good and abc B．good and gbc

D．test ok and gbc C．test ok and abc

33．下列哪些语句关于内存回收的说明是正确的?( B )

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

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

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

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

34．MAX_LENGTH是int型public成员变量, 变量值保持为常量100，用简短语句定义这个变量。( CD )

A、 public int MAX_LENGTH=100;

B、 final int MAX_LENGTH=100;

C、 final public int MAX_LENGTH=100;

D、 public final int MAX_LENGTH=100;

35．给出下面代码：

1) class Parent {

2} private String name;

3} public Parent(){}

4} }

5) public class Child extends Parent {

6} private String department;

7} public Child() {}

8} public String getValue(){ return name; }

您的未来就是我们的未来

技术改变世界 创新驱动发展

9} public static void main(String arg[]) {

10} Parent p = new Parent();

11} }

12} }

那些行将引起错误？ ( D )

A、 第3行 B、 第6行 C、 第7行 D、 第8行

36．类Teacher和Student是类Person的子类；

Person p;

Teacher t;

Student s;

//p, t and s are all non-null.

if(t instanceof Person) { s = (Student)t; }

最后一句语句的结果是：( B )

A、 将构造一个Student对象；

C、 表达式是错误的；

B、 表达式是合法的；

D、 编译时正确，但运行时错误。

解析：考查instanceof和继承中的强制转换。t instanceof Person 表达式是正确的。s = (Student)t;这句转换编译是错误的。

37．给出下面代码段

1) public class Test {

2) int m, n;

3) public Test() {}

4) public Test(int a) { m=a; }

5) public static void main(String arg[]) {

6) Test t1,t2;

7) intj,k;

8) j=0; k=0;

9) t1=new Test();

10) t2=new Test(j,k);

11) }

您的未来就是我们的未来

技术改变世界 创新驱动发展

12) }

哪行将引起一个编译时错误？( D)

A、 line 3 B、 line 5 C、 line 6 D、 line 10

38．对于下列代码：

1) class Person {

2) public void printValue(int i, int j) {//... }

3) public void printValue(int i){//... }

4) }

5) public class Teacher extends Person {

6) public void printValue() {//... }

7) public void printValue(int i) {//...}

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

9) Person t = new Teacher();

10) alue(10);

11) }

第10行语句将调用哪行语句？ ( D )

A、 line 2 B、 line 3 C、 line 6 D、 line 7

39．System类在哪个包中? ( D )

A、 B、 C、

40．对于下列代码：

public class Parent {

public intaddValue( int a, int b) {

int s;

s = a+b;

return s;

}

}

class Child extends Parent {

}

您的未来就是我们的未来

D、

技术改变世界 创新驱动发展

下述哪些方法可以加入类Child? ( CD )

A、 intaddValue( int a, int b ){// }

B、 public void addValue (int a, int b ){// }

C、 public intaddValue( int a ){// }

D、 public intaddValue( int a, int b )throws MyException {//}

解析：A选项不符合一大；B选项返回值类型不匹配；C选项为自己的方法；D选项异常更明确。

41．看下面一段程序：

class Aclass{

void go(){

n("Aclass");

}

}

public class Bclass extends Aclass{

void go{

n("Bclass");

}

public static void main(String args[]){

Aclass a=new Aclass();

Aclass a1=new Bclass();

();

();

}

以上程序运行结果是：( C )

A、 AclassAclass

C、 AclassBclass

B、 BclassBclass

D、 BclassAclass

42．运行下列程序，会产生什么结果：( B)

class Outer1{

private int a;

您的未来就是我们的未来

技术改变世界 创新驱动发展

void foo(double d,final float f){

String s;

final boolean b;

class Inner{

void methodInner(){

}

}

}

public static void main(String args[]) {

Outer1 me=new Outer1();

(123,123);

n("outer");

}

}

A、 in the Inner outer

C、 in the Inner

B、 outer

D、 编译不通过

n("in the Inner");

43．下面哪个修饰符修饰的方法只能被本类中的其他方法使用（ C ）

A、protected B、static C、private D、public

44．下面程序运行后的输出结果为（ C ）

class A{

staticint y=3;

void showy( ){

n(“y=”+y);

}

}

classtestA{

public static void main(String aaa [])

{

您的未来就是我们的未来

技术改变世界 创新驱动发展

A a1=new A( );

A.y+=1;

a1.y++;

}

}

输出结果选择：

A、y=3; B、y=4; C、y=5; D、程序运行出错

( );

45．下面关于构造函数的说法不正确的是（ B ）

A、构造函数也属于类的方法，用于创建对象的时候给成员变量赋值。

B、构造函数不可以重载。

C、构造函数没有返回值。

D、构造函数名称一定要和类名相同。

46．给出如下代码:

class Test{

privateint m;

public static void fun() {

//

}

}

如何使成员变量m被函数fun()直接访问?( C)

A、将private int m 改为protected int m

B、将private int m 改为 public int m

C、将private int m 改为 static int m

D、将private int m 改为 int m

47．为AB类的一个无形式参数无返回值的方法method书写方法头，使得使用类名AB作为前缀就可以调用它，该方法头的形式为( A )。

A. static void method( ) B. public voidmethod( )

C. final void method( ) D. abstract void method( )

您的未来就是我们的未来

技术改变世界 创新驱动发展

48．如果类中的成员变量可以被同一包访问，则使用如下哪个约束符?( D )

A、private

B、public

C、protected

D、no modifier

49．构造方法何时被调用( B )

A.类定义时 B.创建对象时

D.使用对象的变量时 C.调用对象方法时

50．如果任何包中的子类都能访问超类中的成员，那么应使用哪个限定词( C )

ted

e

ent

51．Java变量中，以下不属于复合类型的数据类型是( B )

A.类

B.字符型

D.接口 C.数组型

52．对象使用时，下面描述错误的是( B )

A.通过“.”运算符调用成员变量和方法

B.通过成员变量的访问权限设定限制自身对这些变量方法的调用

C.将一个对象申明为类的成员时，必须在使用前为其分配内存

D.在方法中使用对象作为参数时，采用引用调用(也解释的通，但一定要了解实质为值调用)

53．Java编程所必须的默认引用包为( B )

包

包

包

D.以上都不是

54．定义一个类名为“”的类，并且该类可被一个工程中的所有类访问，那么该类的正确声明应为：( C )

e class MyClass extends Object

yClass extends Object

class MyClass

e class MyClass extends Object

您的未来就是我们的未来

技术改变世界 创新驱动发展

55．内部类是在一个类内嵌套定义的类。其特点描述错误的是( A )

A.只能在定义它的类或程序段中或表达式内匿名使用，外部使用时必须给出类的全名

B.可以使用它所在类的静态成员变量或实例成员变量，但不可以使用所在类中的局部变量(后半句可对可错，看怎么理解)

C.可以作为其它类的成员，而且可访问它所在类的成员

D.除static内部类外，不能在类内声明static成员

二、填空题（每空0.5分，共26.5分）

1、在类声明中提供类标志的关键字是 class 。

2、当一个方法中有多个参数时,参数之间是用英文逗号隔开。

3、在Java中,使用变量遵守先声明后使用(先定义后使用)的原则。

4、比较两个字符串是否相同采用 equals() 方法。

5、 抽象 方法是一种仅有方法头，没有具体方法体和操作实现的方法，该方法必须在抽象类之中定义。

6、包定义时，需使用关键字package来实现。创建一个名为 MyPackage 的包的语句是package MyPackage;。要使用包中的类，必须用关键字import导入这些类所在的包。当要引用包中所有的类时，类名可以用通配符 * 号代替。

7、对象是由一组属性和对这组属性进行 操作 的一组服务组成的。对象是指 具体

的事物,而类是指一类具有某种共性的事物。由类来确定具体对象的过程称为 实例化 。

8、 对一类对象的抽象则是类,而类的实例化结果是 对象 。一个类是由类声明和

类体两部分组成。类修饰符有3种,它们分别是public、abstract和final。

8、 抽象 类不能被实例化,它不具备实际功能,只用于衍生子类。 抽象 方法是只有方法声明,没有代码实现的空方法。

9、当一个类的类修饰符为final时,说明该类不能被继承,即不能有子类。

10、Java用extends关键字指明继承关系。一个类要从另一个类继承变量和方法，必须使用关键字extends。Java程序在extends之后只能有一个父类,即extends只能实现 单 继承。在Java中只能实现单继承(Java不支持多重继承),但可通过 接口 实现多重继承。

11、要在类声明中实现接口,需使用关键字implements。一个类可实现多个接口,各接口名是以英文逗号分隔。

12、在Java中,变量分为成员变量和局部变量。在类体中声明的变量称为 成员变量。在方您的未来就是我们的未来

技术改变世界 创新驱动发展

法中声明的变量称为 局部变量 。成员变量在整个类体中有效,而局部变量只在定义它的

方法 内有效。如果局部变量名与成员变量名相同,则成员变量被屏蔽。

13、在Java程序中，使用关键字 this 来引用当前对象。Java中通过关键字super来实现对父类成员的访问。

14、一个方法的定义是有方法声明和 方法体 两部分组成。方法声明包括方法名、返回类型和形式参数,一个方法的标志是 圆括号 。

15、构造方法的方法名要求与 类名 相同,而且无返回值。构造方法只能通过 new

运算符调用,用户不能直接调用。

16、 方法重载 是指多个方法享有相同的名字,但这些方法的参数必须不同,或者是参数的个数不同,或者是参数类型不同。

17、一个对象的生命周期包括3个阶段：创建、使用和 释放（消亡） 。

18、对象通过使用运算符 “.” 实现对自己的变量访问。

19、面向对象的3个特性是：封装性、继承性和 多态性 。在Java中，通过对象的

封装 ，实现了模块化和信息隐藏。

20、两个方法具有相同的名字，相同的参数表和相同的返回类型，只是函数体不同，则称为重写。

21、Java中成员方法可分成两种：类方法和实例方法。用关键字static修饰的方法就称为类方法。实例方法可对当前对象的实例变量进行操作，也可对类变量进行操作。 实例方法不但可以访问实例变量，也可以访问类变量。 类 方法不能访问实例变量，只能访问类变量。

22、在Java中，用关键字abstract来修饰一个类，则该类为抽象类。若某个类包含了抽象方法，则该类必须被定义为 抽象 类。

23、接口的定义，需使用关键字interface来声明。接口中没有什么实例方法，所有的成员方法都是 public abstract 方法。

24、声明父类时，需使用关键字 extends 来实现。由于Java的继承性，所以子类的成员数目比父类的成员数目 多 。

三、简答题（每题5分，共60分）

第一步：理解考核知识点和考核的目的。

第二步：背下来，记忆清晰准确。

第三步：能把知识点用自己的话准确的描述出来。

您的未来就是我们的未来

技术改变世界 创新驱动发展

1、super()与this()的区别？

解答：this为当前类的对象的引用,所有资源都可以访问。super为父类对象的引用，在子类访问父类的成员和行为时使用,必须受类继承规则的约束。

在构造函数中,如果第一行没有写super(),编译器会自动插入。但是如果父类没有不带参数的构造函数,或这个函数被私有化了(用private修饰)。此时你必须加入对父类的实例化构造。而this就没有这个要求,因为它本身就进行实例化的构造。

而在方法中super和this使用的方法就差不多了。只不过super 要考虑是否能访问其父类的资源。

2、请列举Java语言中的权限访问修饰符，并说明每种权限的含义。

解答：正确使用权限访问修饰符，能够有效控制类以及类成员的安全性，Java语言中有四种访问修饰符，包括public、同包、protected以及private，一般情况下，应用中的类多是public权限，属性多是private权限，方法多是public权限。

参考答案：Java语言中有四种权限访问修饰符，即public、protected、同包以及private。

public表示公共权限，即任何包中都可以访问；

protected表示受保护权限，即同包中可以访问，同包中的子类可以访问：

同包权限是默认权限，即不显示指明权限修饰符的时候就是同包权限，表示只有同包中可以访问；

private是私有权限，表示只能在本类中访问。

3、java中实现多态的机制是什么？

解答：静态的多态:方法名相同，参数个数或类型不相同。(overloading)

动态的多态:子类覆盖父类的方法，将子类的实例传与父类的引用，调用的是子类的方法；实现接口的实例传与接口的引用，调用的实现类的方法。

4、abstract class 和interface的区别。

解答：（1）抽象类通过extends继承，只能继承一个抽象类；接口通过implements使用，可以实现多个接口。

（2）抽象类可以有部分实现，抽象类和接口都不能创建实例。

声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。不能创建abstract 类的实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子您的未来就是我们的未来

技术改变世界 创新驱动发展

类的一个实例。不能有抽象构造函数或抽象静态方法。Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类为。取而代之，在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法。

接口（interface）是抽象类的变体。在接口中，所有方法都是抽象的。多继承性可通过实现这样的接口而获得。接口中的所有方法都是抽象的，没有一个有程序体。接口只可以定义static final成员变量。接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。当类实现特殊接口时，它定义（即将程序体给予）所有这种接口的方法。然后，它可以在实现了该接口的类的任何对象上调用接口的方法。由于有抽象类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。引用可以转换到接口类型或从接口类型转换，instance of 运算符可以用来决定某对象的类是否实现了接口。

5、静态变量和实例变量的区别？是否可以从一个static方法内部发出对非static方法的调用并说明理由？

解答：（1）声明时静态变量用static修饰，静态变量属于整个类，被该类的所用实例对象所共有。实例变量属于该类的某个对象，拥有自己的特征。

（2）静态变量在类加载初始化的时候分配内存并初始化，实例变量在由该类实例化对象时进行分配内存并初始化。

（3）调用方法不同。静态方法可以调用静态变量，不可调用实例变量。实例方法可以调用静态变量、实例变量

不可以从一个static方法内部发出对非static方法的调用，因为static方法属于整个类，实例方法得由该类的某个对象来调用。当调用包含非static方法的static方法时，该类不确定是否存在实例化对象，所以在static方法内调用非static方法时将出现错误。鉴于此道理不可以，编译阶段就会提示该调用的错误。

不可以,如果其中包含对象的method()，不能保证该对象初始化.

6、说说你说知道的设计模式。

解答：单例模式、工厂模式和命令模式。

7、Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)?、

解答：匿名内部类可以继承其他类或完成其他接口。

8、Static Nested Class 和 Inner Class的不同，说得越多越好。

您的未来就是我们的未来

技术改变世界 创新驱动发展

解答：（1）Static Nested Class是被声明为静态（static）的内部类，它可以不依赖于外部类实例被实例化。而通常的内部类需要在外部类实例化后才能实例化。

Static内部类可以包含static成员；普通内部类不可以。

9、什么是方法重载（overload）？什么是方法的重写（Override）？Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型?

解答： 方法重载：如果在一个类中定义了多个同名的、相同返回值类型的方法，它们或有不同的参数个数或有不同的参数类型(不同的形参列表)，则称为方法的重载(Overloading)。

方法重写：如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被"屏蔽"了。

区别：方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。

Overloaded的方法是可以改变返回值的类型和权限修饰符。如果父类定义方法A，子类要重写方法A，则子类不能使用其它返回类型，必须使用父类一致的返回类型或比父类返回类型小。

另外解析重载：如果一个类的某个行为，会有不同的算法和逻辑，例如，Math类的计算绝对值的方法，既可以计算int类型数值的绝对值，也可以计算double类型数值的绝对值。这种情况下，每种类型都定义一个不同的方法名，如abInt、absDouble，那么类的可读性就较差，使用时，必须熟悉处理每种类型参数所对应的方法名。然而，如果使用同一个方法名，而使用不同的形式参数来区别这些方法，那么就具有很好的可读性，如abs（int

i）、abs（double d）等。可读性强的代码是企业对开发人员的基本要求，方法重载能够使得代码有很好的可读性。

方法重载指的是在一个类中可以声明多个相同名字的方法，而方法的形式参数有区别。调用这些同名的方法时，JVM会根据实际参数的不同绑定到不同的方法。

10、构造器Constructor是否可被override?

解答：构造器Constructor不能被继承，因此不能重写Override，但可以被重载您的未来就是我们的未来

技术改变世界 创新驱动发展

Overload。

11、是否可以继承String类，并说明理由? String类是一个“不可变类”，请解释“不可变类”的含义。

解答：不可以，因为String类是final类故不可以继承。

解析不可变类：String类是一个不可变类，即immutable类。所谓不可变，意思是当一个字符串被初始化后，它的值就不会被改变。例如，String s=new String（“hello”）为将初始化一个值为hello的字符串，如果调用 rCase()看起来是把hello变为大写的HELLO，然而事实上并不会把已有的hello变为HELLO，而是在新的空间初始化一个HELLO字符串。也正因为有这种不可变性，所以才能支持“字符串实例池”的使用。

参考答案：所谓的不可变类，就是当字符串初始化后，就不能够被改变。

12、请说明Java语言中的值传递规则。

当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递?

第一问解析：值传递时编写应用时不可避免的操作。例如某方法声明形式是public void

f(int x){}，写方法是，必须为其传递一个int类型的实际参数，如f(10)。又如public void

g(Employee)。那么使用该方法时，必须为其传递一个Employee类型的实际参数，例如g(new

Employee())。所以，对于初级程序员来说，了解Java语言的值传递规则非常重要。Java语言是本类型传递的值，例如f(10)，仅仅把10复制给形式参数x，是值的拷贝。而引用类的传递时引用，即虚地址，例如g(new Employee())是把实际参数的虚地址传递给形式参数e，也就是说实际参数和形式参数的虚地址相同，物理上是同一个对象。

第一问解答：基本数据类型传递的是值，引用类型传递的是引用，即虚地址。

第二问解答：是值传递。Java 编程语言只有值传递参数。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。对象的内容可以在被调用的方法中改变，但对象的引用是永远不会改变的。

四、程序题（每题5分，共25分）

1、补足代码

定义一个抽象类AbstractTest，其中有一个公共的抽象方法printMsg()。然后定义此抽象类的一个子类DefaultTest，包括的成员变量有姓名，学号，分数，且此类中包括二个构造方法。

您的未来就是我们的未来

技术改变世界 创新驱动发展

abstract class AbstractTest{

(1)

}

(2)

{

String name;

String id;

int score;

//接收三个参数的构造方法

(3)

//接收姓名和学号二个参数的构造方法

(4)

//实现抽象方法，方法体为打印出学生的姓名与成绩

(5)

}

答案：

abstract class AbstractTest {

// 抽象方法定义

public abstract void printMsg();

}

public class DefaultTest extends AbstractTest {

String name;

String id;

int score;

/**

* 接收三个参数的构造方法

*/

您的未来就是我们的未来

技术改变世界 创新驱动发展

public DefaultTest(String name, String id, int score) {

}

/**

* 接收姓名和学号两个参数的构造方法

*/

public DefaultTest(String name, String id) {

}

/**

* 实现抽象方法，方法体为打印出学生的姓名与成绩

*/

public void printMsg() {

n("学生" + + "的成绩为：" + );

}

}

2、补足代码

定义接口Student，该接口中有一个无参、无返回值的方法prtMsg；定义类College，包括的私有属性有id和name，包括一个接收学生学号和姓名的构造方法，并且实现Student接口。

interface Student{

}

(2) //College类的声明，实现Student接口

{

(3) //定义私有成员变量id和name，类型自定

(1)

= name;

= id;

= name;

= id;

= score;

您的未来就是我们的未来

技术改变世界 创新驱动发展

(4)//构造方法声明和定义，接收二个参数

(5)//实现prtMsg方法的声明

{

}

//prtMsg的方法体

n(id + name);

}

答案：

interface Student {

}

public class College implements Student {

/**

* 实现prtMsg方法的声明

*/

public void prtMst() {

/**

* 构造方法声明和定义，接收二个参数

*/

public College(String name, String id) {

}

= name;

= id;

// 定义私有成员变量id和name，类型自定

private String name;

private String id;

void prtMst();

您的未来就是我们的未来

技术改变世界 创新驱动发展

}

}

// prtMsg的方法体

n(id + name);

3、改正下面程序段中的错误（共5处）

public class Student{

String id;

String name;

int salary;

public void Test(String id, String name, int salary){ //1：意图为该方法为构造方法，需去掉返回值，并改正方法名

= id;

= name;

= salary;

}

public void changeInfo(String id, int salary){ //2：返回值改为boolean

boolean result;

if(id == ){ //3：==改为equals()方法

= salary;

result = TRUE; //4:改为true

}else{

result = false;

}

return result;

}

public booleanchangeInfo(String ids, intsalarys){ //5：方法重复定义，并不是重载

……

}

}

4、写一个Singleton出来。

解答：

解析：Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。它必须自行创建这个唯一的实例，必须自行向整个系统提供这个实例。使用单例模式的一个必要条件：在一个系统中要求只有一个类的实例时应当使用单例模式，反过来说如果一个类可以有几个实例共存，那么就没有必要使用单例类。

一般Singleton模式通常有以下几种形式。

（1）第一种形式-饿汉式单例类：

定义一个类，它的构造函数为private的，它有一个static的private的该类变量，在类初始化时实例化，通过一个public的getInstance方法获取对它的引用,继而调用其中的方法。

public class Singleton {

您的未来就是我们的未来

技术改变世界 创新驱动发展

// 在自己内部定义自己一个实例，是不是很奇怪？

private static Singleton instance = new Singleton();

// 注意这是private 只供内部调用

private Singleton() {

}

// 这里提供了一个供外部访问本class的静态方法，可以直接访问

public static Singleton getInstance() {

return instance;

}

}

（2）第二种形式-懒汉式单例类：第一次调用才初始化。

public class GoodSingleton {

// 在自己内部定义自己一个实例，是不是很奇怪？

private static GoodSingleton instance = null;

// 注意这是private 只供内部调用

private GoodSingleton() {

}

//这个方法比上面有所改进，不用每次都进行生成对象，只是第一次

//使用时生成实例，提高了效率

public static synchronized GoodSingleton getInstance() {

if(instance == null){

return new GoodSingleton();

}else{

return instance;

}

}

}

//懒汉式的另一种改进

public class GoodSingleton {

// 在自己内部定义自己一个实例，是不是很奇怪？

private volatile static GoodSingleton instance;

// 注意这是private 只供内部调用

private GoodSingleton() {

}

// 两次检查

public static GoodSingleton getInstance1() {

if (instance == null) {

您的未来就是我们的未来

技术改变世界 创新驱动发展

synchronized () {

if (instance == null) {

instance = new GoodSingleton();

}

}

}

return instance;

}

}

（3）登记式单例类：为了克服饿汉式和懒汉式单例类不可继承的缺点而设计的。

5、补足代码

packagelianxi;

interface Interface {

}

class Test{

}

public class Lianxi{

}

答案：

interface Interface {

}

class Test{

void method();

//补上代码，通过匿名内部类

public static void main(String[] args) {

}

on().method();

void method();

public static Interface function() {

//补上代码，通过匿名内部类

return new Interface(){

public void method() {

n("Hello Beirun!");

您的未来就是我们的未来

技术改变世界 创新驱动发展

}

}

};

}

public class Lianxi{

}

public static void main(String[] args) {

}

// 解析：读懂本句代码是解题关键

on().method();

您的未来就是我们的未来