Java程序员面试分类真题2

Java程序员面试分类真题2一、单项选择题1.

有如下代码：classA{publicA(){System.out.println("A");}classBextendsA{p（江南博哥）ublicB(){System.out.println("B");}publicstaticvoidmain(String[]args){Bb=newB();}}

上述程序将______。A.不确定B.通过编译，输出为ABC.通过编译，输出为BD.通过编译，运行时错误正确答案：A[解析]本题中，当这个程序所在的Java文件名为B.java时，运行结果为AB，否则，编译能通过，运行时会出错，因为找不到程序的入口方法main。所以，选项A正确。

2.

以下关于类的描述中，正确的是______。A.只要没有定义不带参数的构造方法，JVM都会为类生成一个默认构造方法B.局部变量的作用范围仅仅在定义它的方法内，或者是在定义它的控制流块中C.使用其他类的方法仅仅需要引用方法的名字即可D.在类中定义的变量称为类的成员变量，在其他类中可以直接使用正确答案：B[解析]对于选项A，只要类中定义了构造方法(不管有没有参数)，JVM都不会提供默认构造方法。因此，选项A错误。

对于选项B，变量的作用域指的是可以使用此变量的名称来引用它的程序区域，变量声明在程序中的位置决定了该变量的作用域。局部变量在方法或方法中的一个代码块中声明，它的作用域为它所在的代码块(代码块是整个方法或方法中的某块代码，即以括号{}包括的代码)。所以，局部变量仅在定义它的方法或块内可见。因此，选项B正确。

对于选项C，在使用其他类的方法的时候，需要用“类名，方法”来引用，不能直接通过方法名字引用。因此，选项C错误。

对于选项D，只有被static修饰的变量才是类的成员变量，但是当类中的变量被private修饰的时候，其他类是无法直接使用的。因此，选项D错误。

3.

下列关于Java语言中关键字super的说法中，正确的是______。A.关键字super是在子类对象中指代其父类对象的引用B.子类通过关键字super只能调用父类的属性，而不能调用父类的方法C.子类通过关键字super只能调用父类的方法，而不能调用父类的属性D.关键字super不仅可以指代子类的直接父类，还可以指代父类的父类正确答案：A[解析]在Java语言中，关键字this指的是对当前对象的引用，关键字super指的是当前对象里面的父对象的引用。当引用当前对象的某个方法或某个成员时，通常会使用this，而通过super可以调用父类的构造方法、父类的方法和属性。如下例所示：classBase{publicintstatus=0;Base(intstatus){this.status=status;}publicvoidprint(){System.out.println("base");}}classSubextendsBase{publicintstatus;Sub(intstatus){super(status-1);this.status=status;}publicvoidprintSub(){System.out.println("sub");System.out.println("status="+status);}publicvoidprintBase(){super.print();System.out.println("status="+super.status);}}publicclassTest{publicstaticvoidmain(Stringargs[]){Subs=newSub(2);s.printBase();s.printSub();}}程序的运行结果为：basestatus=1substatus=2

通过以上分析可知，选项A正确，选项B和选项C错误，对于选项D，super只能表示父类的引用，不能表示父类的父类。因此，选项D错误。

4.

下列关于实例方法的描述中，正确的是______。A.实例方法可直接调用超类的类方法B.实例方法可直接调用超类的实例方法C.实例方法可直接调用其他类的实例方法D.实例方法可直接调用本类的类方法正确答案：D[解析]超类(SuperClass)也叫作父类，在Java语言中，指的是被继承的类，而继承的类称为子类。当超类的实例方法或类方法为private时，是不能被子类调用的。同理，当其他类的实例方法为private时，也不能被直接调用。所以，选项D正确。

5.

下列关于类方法的描述中，正确的是______。A.在类方法中可用this来调用本类的类方法B.在类方法中调用本类的类方法时可直接调用C.在类方法中只能调用本类中的类方法D.在类方法中绝对不能调用实例方法正确答案：B

6.

有如下代码：publicclassOuter{publicvoidsomeOuterMethod(){//Line3)publicclassInner{}publicstaticvoidmain(String[]argv){Outero=newOuter();//Line8}}

内部类里面实例化了一个实例的是______。A.newInner();//Atline3B.newInner();//Atline8C.newOuter.Inner();//Atline8D.newo.Inner();//Atline8正确答案：A[解析]在Java语言中，可以把一个类定义到另外一个类的内部，在类里面的这个类就叫作内部类，外面的类叫作外部类。在这种情况下，这个内部类可以被看成外部类的一个成员(与类的属性和方法类似)。还有一种类被称为顶层(Top-level)类，指的是类定义代码不嵌套在其他类定义中的类。

内部类主要有以下四种：静态内部类(StaticInnerClass)、成员内部类(MemberInnerClass)、局部内部类(LocalInnerClass)和匿名内部类(AnonymousInnerClass)。它们的定义方法如下：classouterClass{staticclassinnerClass{}//静态内部类}classouterClass{classirmerClass{}//成员内部类(普通内部类)}classouterClass{publicvoidmenberFunction(){classinnerClass{}//局部内部类}}publicclassMyFrameextendsFrame{//外部类publicMyFrame(){addWindowListener(newWindowAdapter(){//匿名内部类publicvoidwindowClosing(WindowEvente){dispose();System.exit(0);}});}}

静态内部类是指被声明为static的内部类，它可以不依赖于外部类实例而被实例化，而通常的内部类需要在外部类实例化后才能实例化。静态内部类不能与外部类有相同的名字，不能访问外部类的普通成员变量，只能访问外部类中的静态成员和静态方法(包括私有类型)。

一个静态内部类，如果去掉“static”关键字，就成为成员内部类。成员内部类为非静态内部类，它可以自由地引用外部类的属性和方法，无论这些属性和方法是静态的还是非静态的。但是它与一个实例绑定在了一起，不可以定义静态的属性和方法。只有在外部的类被实例化后，这个内部类才能被实例化。需要注意的是，非静态内部类中不能有静态成员。

局部内部类指的是定义在一个代码块内的类，它的作用范围为其所在的代码块，是内部类中最少使用到的一种类型。局部内部类像局部变量一样，不能被public、protected、private以及static修饰，只能访问方法中定义为final类型的局部变量。对一个静态内部类，去掉其声明中的“static”关键字，将其定义移入其外部类的静态方法或静态初始化代码段中就成为局部静态内部类。对一个成员类，将其定义移入其外部类的实例方法或实例初始化代码中就成为局部内部类。局部静态内部类与静态内部类的基本特性相同。局部内部类与内部类的基本特性相同。

匿名内部类是一种没有类名的内部类，不使用关键字class、extends和implements，没有构造方法，它必须继承(Extends)其他类或实现其他接口。匿名内部类的一般好处是代码更加简洁、紧凑，但带来的问题是易读性下降。它一般应用于GUI(GraphicalUserInterface，图形用户界面)编程中实现事件处理等。

对于本题而言，它是一个普通的内部类，这个内部类必须在外部类实例化以后才能实例化，因此，对于选项A而言，someOuterMethod是Outer的实例方法，可以访问Inner类，因为在调用someouterMethod时，外部类一定是已经被实例化了，因此，选项A正确。对于选项B、选项C和选项D，它们都试图在没有实例化外部类的情况下直接去实例化内部类，因此，是错误的。如果把这个内部类改成静态内部类，那么，选项B、选项C和选项D就都正确。

所以，本题的答案为A。

7.

下列关于构造方法的描述中，错误的是______。A.Java语言规定构造方法没有返回值，但不用void声明B.Java语言规定构造方法名与类名必须相同C.Java语言规定构造方法不可以重载D.Java语言规定构造方法不能直接被调用正确答案：C[解析]构造方法是一种特殊的方法，用来在对象实例化时初始化对象的成员变量。在Java语言中，构造方法具有以下特点：

1)构造方法必须与类的名字相同，并且不能有返回值(返回值也不能为void)。

2)每个类可以有多个构造方法。当开发人员没有提供构造方法时，编译器在把源代码编译成字节码的过程中会提供一个没有参数的默认构造方法，但该构造方法不会执行任何代码。如果开发人员提供了构造方法，那么编译器就不会再创建默认的构造方法。

3)构造方法可以有0个、1个或1个以上的参数。

4)构造方法总是伴随着new操作一起调用，不能由程序的编写者直接调用，必须要由系统调用。构造方法在对象实例化时会被自动调用，且只运行一次，而普通的方法是在程序执行到它时才被调用，可以被该对象调用多次。

5)构造方法的主要作用是完成对象的初始化工作。

6)构造方法不能被继承，因此，它不能被覆盖，但是构造方法能够被重载，可以使用不同的参数个数或参数类型来定义多个构造方法。

7)子类可以通过关键字super来显式地调用父类的构造方法。当父类没有提供无参数的构造方法时，子类的构造方法中必须显式地调用父类的构造方法。如果父类中提供了无参数的构造方法，此时子类的构造方法就可以不显式地调用父类的构造方法，在这种情况下，编译器会默认调用父类的无参数的构造方法。当有父类时，在实例化对象时，会首先执行父类的构造方法，然后才执行子类的构造方法。

8)当父类和子类都没有定义构造方法时，编译器会为父类生成一个默认的无参数的构造方法，给子类也生成一个默认的无参数的构造方法。此外，默认构造器的修饰符只与当前类的修饰符有关(例如，如果一个类被定义为public，那么它的构造方法也是public)。

从以上分析可知，选项A和选项B正确，选项C错误。

对于选项D，在Java语言中，当类在实例化时，会自动调用构造方法，而不能显式地调用构造方法。因此，选项D正确。

8.

构造方法调用的时间是______。A.定义类时B.创建对象时C.使用对象的变量时D.调用对象方法时正确答案：B[解析]对于选项A，类在定义时只是定义了一个引用类型，并不会调用构造方法。因此，选项A错误。

对于选项B，一般情况下构造方法只在对象被创建时才被调用，例如通过new创建一个新对象时会调用构造方法。因此，选项B正确。

对于选项C，由于在使用对象变量时对象已经存在，因此，也不会去调用构造方法创建新的对象。因此，选项C错误。

对于选项D，由于调用对象方法的前提是这个对象已经存在，因此，在调用方法时不会去调用构造方法。因此，选项D错误。

9.

下列关于类的构造方法的描述中，正确的是______。A.类中的构造方法不可省略B.构造方法必须与类同名，但方法不能与class同名C.构造方法在一个对象被new时执行D.一个类只能定义一个构造方法正确答案：C[解析]对于选项A，类中的构造方法是可以省略的，当省略时，编译器会提供一个默认的构造方法以供使用。因此，选项A错误。

对于选项B，构造方法必须与类名相同，但是方法名也可以与类名相同。如下例所示：publicclassTest{publicYest(){System.out.println("construct");}publicvoidTest(){System.out.println("callTest");}publicstaticvoidmain(String[]args){Testa=newTest();//调用构造方法a.Test();//调用Test方法}}程序的运行结果为：constructcallTlest

因此，选项B错误。

对于选项C，当一个对象被new时必定会调用构造方法。因此，选项C正确。

对于选项D，由于构造方法也可以重载，因此，一个类可以定义多个构造方法。因此，选项D错误。

10.

下列关于构造方法的描述中，正确的是______。A.构造方法必须用void声明返回类型B.构造方法名必须与类名相同C.构造方法可以被程序调用D.如果编程人员没在类中定义构造方法，程序将报错正确答案：B[解析]构造方法是一种特殊的方法，主要用来在创建对象时初始化对象，即为对象成员变量赋初始值。

本题中，对于选项A与选项B，构造方法必须与类的名字相同，并且不能有返回值(返回值也不能为void类型)。因此，选项A错误，选项B正确。

对于选项C，构造方法是在对象被创建时由编译器调用的，程序员无法直接调用构造方法。因此，选项C错误。

对于选项D，如果程序员没有提供构造方法，编译器会提供一个默认的构造方法。因此，选项D错误。

11.

下面有关子类继承父类构造方法的描述中，正确的是______。A.创建子类的对象时，先调用子类自己的构造方法，然后调用父类的构造方法B.子类会继承父类的构造方法C.子类必须通过关键字super调用父类的构造方法D.子类无法继承父类的构造方法正确答案：D[解析]对于选项A，当创建子类对象时，必定会首先调用父类的构造方法，然后再调用子类的构造方法。因此，选项A错误。

对于选项B与选项D，由于构造方法是不能被继承的，因此，选项B错误，选项D正确。

对于选项C，当子类没有显式地调用构造方法的时候，编译器会自动调用父类的无参数的构造方法，因此，子类可以不通过super()方法调用父类的构造方法。因此，选项C错误。

12.

有如下代码：classBase{Base(){System.out.print("Base");}}publicclassAlphaextendsBase{publicstaticvoidmain(String[]args){newAlpha();newBase();}}

上述代码的输出结果是______。A.BaseB.BaseBaseC.运行失败D.编译失败正确答案：B[解析]在本题中，当调用newAlpha()时，会首先调用父类的无参数的构造方法，输出Base，然后调用Alpha类的构造方法(编译器提供了一个默认的构造方法)，接着在调用newBase()时，也会调用Base类的构造方法，输出Base。所以，选项B正确。

13.

下面是People和Child类的定义，每个构造方法都输出编号。在执行newChild("c")时，程序的运行结果是______。classPeople{Stringname;publicPeople(){System.out.print(1);}publicPeople(Stringname){System.out.print(2);=name;}}classChildextendsPeople{Peoplefather;publicChild(Stringflame){System.out.print(3);=name;father＝newPeople(name+":F");}publicChild(){System.out.print(4);}}

A.312B.32C.432D.132正确答案：D[解析]本题中，在调用newChild("c")时，由于Child继承了People，但是Child类的构造方法中没有显式地调用父类的构造方法，因此，编译器会默认调用父类的无参数的构造方法，因此，首先会输出1，接着才会调用Child类的构造方法输出3，在Child的构造方法中，调用newPeople(name+":F")语句会调用People类的有参数的构造方法，输出2。所以，选项D正确。

14.

有如下代码：publicclassTest{publicstaticvoidmain(Stringargv[]){Testh=newTest();}protectedTest(){for(inti=0;i＜10;i++){System.out.println(i);}}}

当编译并运行上面程序时，输出结果是______。A.编译错误，构造方法不能被声明为protectedB.运行错误，构造方法不能被声明为protectedC.编译并运行输出0到10D.编译并运行输出0到9正确答案：D[解析]一般而言，构造方法都是被public修饰的，这个构造方法对所有的类都是可见的。当构造方法被protected修饰时，只有当前类、当前包和子类可见。当构造方法被private修饰时，该方法只对本类可见，常被用来实现单例模式。

对于本题而言，定义了一个protected的构造方法，由于main方法在这个类内部，因此，这个构造方法对main方法是可见的，故会调用这个构造方法，输出0到9。因此，选项D正确。

15.

有如下代码：classAextendsB{publicA(){super();}}

以下关于super用法的描述中，正确的是______。A.用来调用类A中定义的super()方法B.用来调用类B中定义的super()方法C.用来调用类B中的无参构造方法D.用来调用类B中第一个出现的构造方法正确答案：C[解析]在Java语言中，子类可以通过super关键字来显式地调用父类的构造函数，示例代码如下：classB{publicB(){System.out.println("constructB");}}classCextendsB{publicC(){super();}}publicclassTest{publicstaticvoidmain(Stringargs[]){newC();}}程序的运行结果为：constructB

super为Java语言的关键字，自定义的方法名不能是super。所以，选项C正确。

16.

不通过构造方法______创建对象。A.可以B.不可以C.不确定正确答案：A[解析]在Java语言中，最常用的创建对象的方法为使用new创建一个对象，这种方式通过调用类的构造方法来完成对象的创建，除此之外，还有如下几种创建对象的方法：

1)调用对象的clone方法，需要以下几个步骤才能使用clone方法：

①实现clone的类首先需要继承Cloneable接口。Cloneable接口实质上是一个标识接口，没有任何接口方法。

②在类中重写Object类中的clone方法。

③在clone方法中调用super.clone()。无论clone类的继承结构是什么，super.clone()都会直接或间接调用java.lang.Object类的clone()方法。

示例代码如下：classObjimplementsCloneable{privateintaInt=0;publicObj(){System.out.println("construct");}publicintgetAInt(){returnaInt;}publicvoidsetAInt(intint1){aInt=int1;}publicvoidchangeInt(){this.aInt=1;}publicObjectclone(){Objecto=ull;try{o=(Obj)super.clone();}catch(CloneNotSupportedExceptione){e.printStackTrace();}returno;}}publicclassTest{publicstaticvoidmain(String[]args){Obja=ewObj();0bjb=(Obj)a.clone();b.changeInt();System.out.println("a:"+a.getAInt());System.out.println("b:"+b.getAInt());}}程序的运行结果为：constructa:0

b:1从以上程序运行结果可以看出，在调用a.clone()方法时，系统创建了新的对象，但是没有调用构造方法。2)通过反射机制来创建对象，如下例所示：classPerson{Stringname="Jack";publicPerson(){System.out.println("construct");}publicStringtoString(){returnname;}}publicclassTest{publicstaticvoidmain(String[]args){ClassclassType;try{classType=Class.forName("Person");Personp=(Person)classType.newInstance();System.out.println(p);}catch(Exceptione){e.printStackTrace();}}}程序的运行结果为：constructJack从以上运行结果可以看出，这种方法也调用了构造方法。3)通过反序列化的方式创建对象，示例代码如下：importjava.io.FileInputStream;importjava.io.FileOutputStream;importjava.io.ObjectlnputStream;importjava.io.ObjectOutputStream;importjava.io.Serializable;publicclassPeopleimplementsSerializable{privateStringname;publicPeople(){="lili";System.out.println("construct");}publicStringtoString(){retum;}publicstaticvoidmain(String[]args){Peoplep=newPeople();System.out.println(p);ObjectOutputStreamoos=null;ObjectInputStreamois=null;try{FileOutputStreamfos=newFileOutputStream("perple.out");oos=newObjectOutputStream(fos);oos.writeObject(p);oos.close(),}catch(Exceptionex){}Peoplep1;try{FileInputStreamfis=newFileInputStream("perple.out");ois=newObjectlnputStream(fis);p1=(People)ois.readObject();System.out.println(p);if(p!=p1)System.out.println("twodifferentobject");ois.close();}catch(Exceptionex){}}}程序的运行结果为：constructlilililitwodifferentobject

从以上运行结果可以看出，用反序列化的方式创建对象也不需要调用构造方法。

所以，本题的答案为A。

17.

下列有关继承的描述中，正确的是______。A.子类能继承父类的非私有方法和属性B.子类能继承父类的所有方法和属性C.子类只能继承父类的公有方法和属性D.子类能继承父类的方法，而不是属性正确答案：A[解析]本题中，继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力，子类能继承父类的公有和受保护的方法和属性，但是不能继承私有方法和属性。所以，选项A正确，选项B、选项C与选项D错误。

18.

以下关于继承的描述中，正确的是______。A.在Java语言中类只允许单一继承B.在Java语言中一个类只能实现一个接口C.在Java语言中，一个类不能同时继承一个类和实现一个接口D.在Java语言中接口只允许单一实现正确答案：A[解析]继承指的是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。在Java语言中，继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以使用父类的功能，但不能选择性地继承父类。类只允许单继承，但是为了实现类似于C++语言中多继承的特性，Java语言引入了接口的概念，虽然Java语言只允许继承一个类，但是却可以同时实现多个接口，因此，也就间接地实现了多继承。

从以上分析可知，选项A正确，选项B和选项D错误。

对于选项C，一个类只能继承一个类，在继承的同时，还可以实现多个接口。因此，选项C错误。

19.

下列关于abstract的描述中，正确的是______。A.abstract修饰符可修饰属性、方法和类B.抽象方法的方法体必须用一对大括号括住C.抽象方法的方法体(大括号)可有可无D.声明抽象方法不可写出大括号正确答案：D[解析]抽象方法是指在类中存在没有方法体的方法，在Java语言中，当用abstract来修饰一个方法时，该方法就是抽象方法。由此可见，抽象方法不能用大括号{}括住(一旦有大括号就表明这个方法有了方法体)。因此，选项D正确，选项B和选项C错误。对于选项A，abstract只能修饰类和方法，不能修饰字段。因此，选项A错误。

20.

有如下代码：

publicinterfaceUsb{

}

publicabstractclassInterface{

}

以下关于接口的使用中，正确的是______。A.publicinterfaceUsb1extendsUsb{}B.publicinterfaceUsb1extendsInterface{}C.publicinterfaceUsb1implementsUsb{}D.publicinterfaceUsb1implementsInterface{}正确答案：A[解析]如果一个类中包含抽象方法，那么这个类就是抽象类。在Java语言中，可以通过把类或者类中的某些方法声明为abstract来表示一个类是抽象类。接口就是指一个方法的集合，接口中的所有方法都没有方法体，在Java语言中，接口是通过关键字interface来实现的。

在实际使用时，接口可以继承接口，抽象类可以实现接口，抽象类也可以继承具体类。

通过以上分析可知，选项A是正确的，因为接口可以继承接口。

对于选项B，接口不能继承抽象类，因为接口中所有的方法不能有方法体，而抽象类中的方法是可以有方法体的。因此，选项B错误。

对于选项C，implements关键字是指子类要实现接口中定义的方法，因为接口中的方法是没有方法体的，所以接口不能用来实现接口。因此，选项C错误。

对于选项D，implements只能用来实现接口，而Interface是个抽象类，对于抽象类只能用extends来实现。因此，选项D错误。

21.

在Java语言中，已定义两个接口B和C，要定义一个实现这两个接口的类，以下语句正确的是______。A.interfaceAimplementsB,CB.interfaceAextendsB,CC.classAimplementsB,CD.classAimplementsB,implementsC正确答案：C[解析]只有类才能实现接口，而实现接口的关键字为implements，当实现多个接口的时候，只需要一个关键字implements，多个接口用逗号隔开即可。因此，选项C正确，选项D错误。

对于选项A，只有类才能实现接口，而接口是不能实现接口的。因此，选项A错误。

对于选项B，接口只能继承接口，而不能继承类。因此，选项B错误。

22.

有如下代码：interfaceIFTest{publicstaticfinalStringname;//1voidf();//2publicvoidg();//3}abstractclassABTestimplementsIFTest{//4publicvoidf(){}}

以下关于上述代码的描述中，正确的是______。A.第1行错误，没有给变量赋值B.第2行错误，方法没有修饰符C.第4行错误，没有实现接口的全部方法D.第3行错误，没有方法的实现正确答案：A[解析]对于选项A，接口中定义的成员变量默认为public、static和final，只能够有静态的、不能被修改的数据成员，而且，必须给其赋初值，而name没有被初始化，因此，是错误的。所以，选项A正确。

对于选项B，方法f采用默认的修饰符，因此，没有错误。所以，选项B错误。

对于选项C，由于ABTest是抽象类，抽象类中允许有抽象方法，因此，可以不用实现接口IFTest中的全部方法，4行没有错误。所以，选项C错误。

对于选项D，接口中的方法不允许有方法体，因此，第3行写法是正确的。所以，选项D错误。

23.

Java接口的修饰符可以为______。A.staticB.protectedC.finalD.abstract正确答案：D

24.

下列关于abstract的描述中，正确的是______。A.abstract修饰符可以修饰属性、方法和类B.声明抽象方法，大括号可有可无C.抽象方法的body部分必须用一对大括号{}D.声明抽象方法不可写出大括号正确答案：D[解析]在Java语言中，被abstract修饰的方法为抽象方法，这种方法是没有方法体的(也就是说，没有大括号{}；一旦有大括号{}，就说明这个方法有方法体)。因此，选项B和选项C错误，选项D正确。

对于选项A，abstract只能用来修饰方法和类，不能修饰属性。因此，选项A错误。

25.

在集合框架中，要实现对集合里的元素进行自定义排序，要实现的接口是______。A.CloneableB.ThreadC.SerializableD.Comparator正确答案：D[解析]在Java语言中，如果要对集合对象或数组对象进行排序，就需要实现Comparator接口的compare方法，从而实现自定义类的比较。下面给出一个对自定义的类进行排序的例子(通过年龄大小按行排序)，实现代码如下：importjava.util.ArrayList;importjava.util.Collections;importjava.util.Comparator;importjava.util.List;classStudent{privateStringname;privateintage;publicStudent(Stringname,intage){=name;this.age=age;}publicStringgetName(){returnname;}publicvoidsetName(Stringname){=name;}publicintgetAge(){returnage;}publicvoidsetAge(intage){this.age=age;}}classStudentComparatorimplementsComparator＜Student＞{@Overridepublicintcompare(Students1,Students2){if(s1.getAge()＞s2.getAge())return1;elsererun-1;}}publicclassExample{publicstaticvoidmain(String[]args){List＜Student＞stus=newArrayList＜Student＞();stus.add(newStudent("name1",5));stus.add(newStudent("name2",6));stus.add(newStudent("name3",4));Collections.sort(stus,newStudentComparator());for(Studentstu:stus){System.out.println(stu.getName());}}}程序的运行结果为：name3name1name2

本题中，对于选项A，当一个类需要实现复制功能时，需要实现Cloneable接口。所以，选项A错误。

对于选项B，当需要实现一个线程时可以继承Thread类。所以，选项B错误。

对于选项C，Runnable是用来实现多线程的接口。所以，选项C错误。

对于选项D，Serializable是用来实现序列化的接口。在对Student的对象进行排序时，使用的是自定义的比较方法。所以，选项D正确。

二、多项选择题1.

下列关于类方法的调用的描述中，错误的有______。A.在类方法中可用this来调用本类的类方法B.在类方法中调用本类的类方法时可直接调用C.在类方法中只能调用本类中的类方法D.在类方法中绝对不能调用实例方法正确答案：ACD[解析]对于选项A，在Java语言中，每当一个对象创建后，Java虚拟机都会给这个对象分配一个引用自身的指针，这个指针的名字就是this，this是对当前类对象的引用，对象只有被实例化后才存在。而类方法是被static修饰的方法，是不依赖于对象而存在的方法。所以，this只能在类中的非静态方法中使用，静态方法和静态的代码块中绝对不能出现this的用法。因此，选项A错误。

对于选项B，显然，类方法可以直接调用类方法。因此，选项B正确。

对于选项C，类方法可以调用任意类的类方法，只要有权限访问。因此，选项C错误。

对于选项D，从实际应用的角度出发，类方法是属于类的，所有对象公用的，而实例方法只供实例化的对象来使用，因此，类方法调用实例方法是没有意义的；从语法的角度出发，被static修饰的类方法是在类被加载的时候完成的，此时还没有任何实例化对象被初始化，实例的方法还不存在，因此，无法完成调用。无论从哪个角度出发考虑，都不推荐在类方法中调用实例方法。但这并不是说类方法绝对不能调用实例方法，如果有对象被实例化了，在这种情况下，实例化的对象就存在了，此时通过类方法调用实例化的方法也是可以的，如下例所示：publicclassTest{publicstaticvoidmain(String[]args){Stringa="hello";//print(a);//没有实例化对象,编译错误Testt=newTest();t.print(a);//有实例化对象,可以执行}publicvoidprint(Stringstr){System.out.println(str);}}

因此，选项D错误。

所以，本题的答案为A、C、D。

2.

下面类中可以被继承的是______。A.NumberB.ThreadC.DoubleD.MathE.ClassLoader正确答案：ABE[解析]在Java语言中，被final关键字修饰的类是不能被继承的，由于Double和Math都是被final修饰的类，因此，它们不能被继承。所以，选项C与选项D错误。Thread、Number和ClassLoader都没有被final修饰，因此，它们可以被继承。所以，选项A、选项B和选项E正确。

所以，本题的答案为A、B、E。

3.

有如下代码：classA{A(){}}classBextendsA{}

关于上述代码，以下描述正确的是______。A.B类的构造方法一定是publicB.B类的构造方法应该没有参数C.B类的构造方法应该调用this()D.B类的构造方法应该调用super()正确答案：BD[解析]对于选项A，默认构造器的修饰符只与当前类的修饰符有关。如果类B是public的，那么默认构造方法就是public的。如果类B是默认的访问权限，则构造方法与它相同，也是默认访问权限。因此，选项A错误。

对于选项B，编译器提供的默认构造方法是没有参数的。因此，选项B正确。

对于选项C，在Java语言中，没有this()这种写法。因此，选项C错误。

对于选项D，在继承中，子类会默认调用父类的无参数的构造方法。因此，选项D正确。

4.

下面关于构造方法的描述中，正确的是______。A.构造方法不能被重写B.构造方法不能被继承C.构造方法不能被重载D.构造方法不能声明为private正确答案：AB[解析]构造方法是一个类特有的方法，每个类都有自己的构造方法，它是不能被继承的，因此，构造方法不能被重写，但是，可以定义多个参数不同的构造方法，即可以重载构造方法。因此，选项A和选项B正确，选项C错误。

对于选项D，构造方法可以定义为private，在单例模式中，通过把构造方法定义为private可以阻止显式地实例化对象，因此，选项D错误。

5.

以下不能用来修饰接口的有______。A.privateB.publicC.abstractD.static正确答案：AD[解析]在Java语言中，接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征，没有方法的实现，因此，这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为(功能)。接口只能被public和abstract这两个关键字修饰，而不能被private、protected和static修饰。所以，选项B和选项C正确，选项A与选项D错误。

6.

下列选项中，能用来修饰interface方法的有______。A.privateB.publicC.protectedD.finalE.不加修饰符正确答案：BE[解析]接口中所有的成员方法都是public、abstract的，而且只能被这两个关键字修饰。当然也可以不加修饰。

7.

在接口中，以下定义正确的是______。A.voidf();B.publicdoublef();C.publicfinaldoublef();D.staticvoidf(doubledl);E.protectedvoidf(doubledl);正确答案：AB[解析]接口就是指一个方法的集合，接口中的所有方法都没有方法体，在Java语言中，接口是通过关键字interface来实现的。接口中定义的成员变量默认为public、static和final，只能够有静态的不能被修改的数据成员，而且，必须给其赋初值，其所有的成员方法都是public、abstract的，而且只能被这两个关键字修饰。

显然，选项A和选项B是正确的。

对于选项C，接口中的方法不能被final修饰。因此，选项C错误。

对于选项D，接口中的方法不能被static修饰。因此，选项D错误。

对于选项E，接口中的方法不能被protected修饰。因此，选项E错误。

8.

不能用来修饰interface的有______。A.privateB.publicC.finalD.static正确答案：ACD[解析]由于接口的目的就是让其他的类来实现，如果没有被实现，接口就没有存在的意义了，因此，它不能被private和final修饰，否则无法被实现。同理，接口也不能被static修饰。所以，选项A、选项C和选项D正确。

9.

下面关于类和接口的描述中，正确的是______。A.类不能被private修饰B.接口中可定义变量，并且变量的值不能修改C.类可以被protected修饰D.接口不能实例化正确答案：BCD[解析]对于选项A，当一个类作为内部类使用时，可以被private修饰。因此，选项A错误。

对于选项B，接口中定义的成员变量默认为public、static和final，只能够有静态的、不能被修改的数据成员，而且，必须给其赋初值。因此，选项B正确。

对于选项C，内部类可以被protected修饰。因此，选项C正确。

对于选项D，由于接口中的方法都没有具体的实现，因此是不能被实例化的，只有当一个类实现了接口中的所有方法后，这个类才能被实例化。因此，选项D正确。

10.

在Java语言中，下面关于抽象类的描述中，正确的是______。A.声明抽象类必须带有关键字abstractB.如果一个类中有一个方法被声明为抽象的，那么这个类必须是抽象类C.抽象类的方法都必须是抽象的D.抽象类可以被实例化正确答案：AB[解析]在Java语言中，可以通过把类或者类中的某些方法声明为abstract来表示一个类是抽象类。抽象类是不能被实例化的。显然，选项A正确，选项D错误。

对于选项B，只要类中有抽象方法，这个类就必须被声明为抽象类，否则，这个类就能被实例化了，然后去调用抽象方法，这显然是不合理的。因此，选项B正确。

对于选项C，从抽象类的定义可以看出，抽象类没有要求所有的方法是抽象的，抽象类中的方法也可以有方法体，只要这个方法没被abstract修饰。因此，选项C错误。

11.

对于abstract声明的类，下面说法正确的是______。A.不可以被继承B.可以实例化C.子类为abstractD.只能被继承E.可以被抽象类继承正确答案：DE[解析]被声明为abstract的类为抽象类，由于抽象类中存在没有方法体的方法，因此，它不能被实例化，只有实现了抽象方法的子类才能被实例化。所以，选项A和选项B错误。

abstract类的子类可以是abstract，此时子类就无法实例化，abstract类的子类也可以不是abstract，此时子类可以被实例化。所以，选项C错误，选项E正确。

对于选项D，对于一个声明为abstract的类，由于无法实例化，如果要想使用它，那么必须继承这个类并实现抽象方法，所以，选项D正确。

三、填空题1.

面向对象的三大特性是______、______、______。正确答案：继承，封装，多态[解析]以下将分别对这几种特性进行介绍。

1)继承：继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类(子类)，而原始类称为新类的基类(父类)。派生类可以从它的基类那里继承方法和实例变量，并且子类可以修改或增加新的方法使之更适合特殊的需要。

2)封装：封装是指将客观事物抽象成类，每个类对自身的数据和方法实行保护。类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。

3)多态：多态是指允许不同类的对象对同一消息作出响应。多态包括参数化多态和包含多态。多态性语言具有灵活、抽象、行为共享和代码共享的优势，很好地解决了应用程序方法同名问题。

2.

下面代码的运行结果为______。publicclassEx{publicstaticvoidmain(String[]args){Fxf=newFx(5);}Ex(){System.out.println("Ex,no-args");}Ex(inti){System.out.println("Ex,int");}}classFxextendsEx{Fx(){super();System.out.println("Fx,no-args");}Fx(inti){this();System.out.println("Fx,int");}}正确答案：Ex,no-args

Fx,no-args

Fx,int[解析]只有当子类的构造方法没有调用父类的构造方法时，编译器才会默认地去调用父类中无参数的构造方法。对于本题而言，类Fx中无参数的构造方法显然已经调用了父类的构造方法，而Fx类中带参数的构造方法也通过调用无参数的构造方法间接调用了父类的构造方法，因此，编译器不会在调用Fx类有参数的构造方法时再去调用父类的构造方法。在调用Fxf=newFx(5)时，先调用Fx的构造方法，在这个方法中，首先调用无参数的构造方法，在无参数的构造方法中，首先调用父类的无参数的构造方法输出Ex,no-args，接着在类Fx无参数的构造方法中输出Fx,no-args，最后调用类Fx有参数的构造方法，输出Fx,int。

3.

构造方法、成员变量初始化以及静态成员变量初始化三者的先后顺序是______。正确答案：静态成员变量，成员变量，构造方法[解析]当类第一次被加载的时候，静态变量会首先初始化，接着编译器会把实例变量初始化为默认值，然后执行构造方法。

Java程序的初始化一般遵循以下三个原则(以下三原则优先级依次递减)：①静态对象(变量)优先于非静态对象(变量)初始化，其中，静态对象(变量)只初始化一次，而非静态对象(变量)可能会初始化多次；②父类优先于子类进行初始化；③按照成员变量定义顺序进行初始化，即使变量定义散布于方法定义中，它们依然在任何方法(包括构造方法)被调用之前先初始化。

Java程序初始化工作可以在许多不同的代码块中完成(例如静态代码块、构造方法等)，它们执行的顺序如下：父类静态变量、父类静态代码块、子类静态变量、子类静态代码块、父类非静态变量、父类非静态代码块、父类构造方法、子类非静态变量、子类非静态代码块和子类构造方法。

4.

______方法是一种仅有方法头，没有具体方法体和操作实现的方法，该方法必须在抽象类中定义。______方法是不能被当前类的子类重新定义的方法。正确答案：抽象(abstract)，final[解析]在Java语言中，可以通过把方法声明为abstract来表示这个方法是抽象方法，抽象方法是没有方法体的，子类只有实现了父类的抽象方法，才能被实例化。被final修饰的方法是不能被子类重写的。

5.

在Java程序中，通过类的定义只能实现______重继承，但通过接口的定义可以实现______重继承关系。正确答案：单，多[解析]在Java语言中，只允许单重继承，也就是说，任何一个类都只能有一个父类，但是Java语言引入了接口的概念，一个类可以同时实现多个接口，从而间接地实现了多重继承。

6.

Java语言提供了两种用于多态的机制，分别是______与______。正确答案：重载，覆盖[解析]多态是面向对象程序设计中代码重用的一个重要机制，它表示当同一个操作作用在不同对象时，会有不同的语义，从而会产生不同的结果。在Java语言中，多态主要有以下两种表现方式：

(1)重载(Overload)

重载是指同一个类中有多个同名的方法，但这些方法有着不同的参数，因此，在编译时就可以确定到底调用的是哪个方法，它是一种编译时多态。重载可以被看作一个类中的方法多态性。

(2)覆盖(Override)

子类可以覆盖父类的方法，因此，同样的方法会在父类与子类中有着不同的表现形式。在Java语言中，基类的引用变量不仅可以指向基类的实例对象，也可以指向其子类的实例对象。同样，接口的引用变量也可以指向其实现类的实例对象。而程序调用的方法在运行期才动态绑定(绑定指的是将一个方法调用和一个方法主体连接到一起)，即引用变量所指向的具体实例对象的方法，也就是内存里正在运行的那个对象的方法，而不是引用变量的类型中定义的方法。通过这种动态绑定的方法实现了多态。由于只有在运行时才能确定调用的是哪个方法，因此，通过方法覆盖实现的多态也可以被称为运行时多态。如下例所示：classBase{publicBase(){g();}publicvoidf(){System.out.println("Basef()");}publicvoidg(){System.out.pfintln("Baseg()");}}classDerivedextendsBase{publicvoidf(){System.out.println("Derivedf()");}publicvoidg(){System.out.println("Derivedg()");}}publicclassTest{publicstaticvoidmain(String[]args){Baseb=newDerived();b.f();b.g();}}程序的运行结果为：Derivedg()Derivedf()Derivedg()

上例中，由于子类Derived的f()方法和g()方法与父类Base的方法同名，因此，Derived的方法会覆盖父类Base的方法。在执行Baseb=newDerived()语句时，会调用Base类的构造方法，而在Base的构造方法中，执行了g()方法，由于Java语言的多态特性，此时会调用子类Derived的g()方法，而非父类Base的g()方法，因此，会输出Derivedg()。由于实际创建的是Derived类的对象，后面的方法调用都会调用子类Derived的方法。

四、论述题1.

下面程序是否存在问题?如果存在，请指出问题所在，如果不存在，说明输出结果。publicclassHelloBextendsHelloA{publicHelloB(){System.out.pfintln("HelloB");}{System.out.println("I'mBclass");}static{System.out.pfintln("staticB");}publicstaticvoidmain(String[]args){newHelloB();}}classHelloA{publicHelloA(){System.out.pfintln("HelloA");}{System.out.println("I'mAclass");}static{System.out.println("staticA");}}正确答案：不存在问题，程序的运行结果为：staticAstaticBI'mAclassHelloAI'mBclassHelloB

在Java语言中，当实例化对象时，对象所在类的所有成员变量首先要进行初始化，只有当所有类成员完成初始化后，才会调用对象所在类的构造函数创建对象。

Java程序的初始化一般遵循以下三个原则(以下三原则优先级依次递减)：①静态对象(变量)优先于非静态对象(变量)初始化，其中，静态对象(变量)只初始化一次，而非静态对象(变量)可能会初始化多次；②父类优先于予类进行初始化；③按照成员变量定义顺序进行初始化，即使变量定义散布于方法定义中，它们依然在任何方法(包括构造函数)被调用之前先初始化。

Java程序初始化工作可以在许多不同的代码块中完成(例如静态代码块、构造函数等)，它们执行的顺序如下：父类静态变量、父类静态代码块、子类静态变量、子类静态代码块、父类非静态变量、父类非静态代码块、父类构造函数、子类非静态变量、子类非静态代码块和子类构造函数。

根据以上分析可知，本题中，当代码运行时，首先执行父类静态代码块，输出staticA；接着执行子类静态代码块，输出staticB；执行父类非静态代码块，输出I'mAclass；执行父类构造函数，输出HelloA；执行子类非静态代码块，输出I'mBclass，最后执行子类构造函数，输出HelloB。

2.

下面代码的运行结果是______。classBase{intnum=1;publicBase(){this.print();num=2;}publicvoidprint(){System.out.println("Base.num="+num);}}classSubextendsBase{intnum=3;publicSub(){this.print();num=4;}publicvoidprint(){System.out.println("Sub.num="+num);}}publicclassTest{publicstaticvoidmain(String[]args){Baseb=newSub();System.out.println(b.num);}}正确答案：程序的运行结果为：Sub.num=0Sub.num=32

由于子类可以覆盖父类的方法，因此，同样的方法会在父类与子类中有看不同的表现形式。在Java语言中，基类的引用变量不仅可以指向基类的实例对象，也可以指向其子类的实例对象。同样，接口的引用变量也可以指向其实现类的实例对象。而程序调用的方法在运行期才动态绑定(绑定指的是将一个方法调用和一个方法主体连接到一起)，就是引用变量所指向的具体实例对象的方法，也就是内存里正在运行的那个对象的方法，而不是引用变量的类型中定义的方法。通过这种动态绑定的方法实现了多态。需要注意的是，只有方法有多态的概念，属性是没有多态的概念的。

对于本题而言，在执行语句Baseb=newSub()时，会首先调用父类的构造方法，而在父类构造方法中调用了print()方法。根据多态的特性，此时实例化的是Sub类的对象，因此，会调用Sub类的print方法。由于此时Sub类中的初始化代码intnum=3还没有执行，因此，num的默认值为0，所以，输出为Sub.num=0，接着把父类的num初始化为2。然后会调用子类的构造方法，根据初始化的顺序可知，在调用子类构造方法时，非静态的变量会先执行初始化动作，所以，此时子类Sub的num值为3，因此，调用print方法会输出Sub.num=3。接着输出b.num，由于b的类型为Base，而属性没有多态的概念。因此，此时会输出父类中的num值：3。

3.

有如下代码：

classReadOnlyClass{

privateIntegerage=20;

publicIntegergetAge(){returnage;}

}

现给定一个ReadOnlyClass的对象roc，能否把这个对象的age值改成30?正确答案：从正常编程的角度出发分析会发现，在本题中，age属性被修饰为private，而且这个类只提供了获取age的public的方法，而没有提供修改age的方法，因此，这个类是一个只读的类，无法修改age的值。但是Java语言还有一个非常强大的特性：反射机制，所以本题中，可以通过反射机制来修改age的值。

在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取对象的信息以及动态调用对象的方法的功能称为Java语言的反射机制。Java反射机制容许程序在运行时加载、探知、使用编译期间完全未知的Class。换句话说，Java可以加载一个运行时才得知名称的Class，获得其完整结构。

在Java语言中，任何一个类都可以得到对应的Class实例，通过Class实例就可以获取类或对象的所有信息，包括属性(Field对象)、方法(Method对象)或构造方法(Constructor对象)。对于本题而言，在获取到ReadOnlyClass类的Class实例后，就可以通过反射机制获取到age属性对应的Field对象，然后可以通过这个对象来修改age的值，实现代码如下：importjava.lang.reflect.Field;classReadOnlyClass{privateIntegerage=20;publicIntegergetAge(){returnage;}}publicclassTest{publicstaticvoidmain(String[]args)throwsException{ReadOnlyClasspt=newReadOnlyClass();Class＜?＞clazz=ReadOnlyClass.class;Fieldfield=clazz.getDeclaredField("age");field.setAccessible(true);field.set(pt,30);System.out.println(pt.getAge());}}程序的运行结果为：30

4.

接口和抽象类有什么区别?正确答案：接口(interface)和抽象类(abstract

class)是支持抽象类定义的两种机制(注意，该句中前后两个抽象类的意义不一样，前者表示的是一个实体，后者表示的是一个概念)。二者具有很大的相似性，甚至有时候是可以互换的。但同时，二者也存在很大的区别。

具体而言，接口是公开的，里面不能有私有的方法或变量，是用于让别人使用的，而抽象类是可以有私有方法或私有变量的，如果一个类中包含抽象方法，那么这个类就是抽象类。在Java语言中，可以通过把类或者类中的某些方法声明为abstract(abstract只能用来修饰类或者方法，不能用来修饰属性)来表示一个类是抽象类。