面向对象测试题，快来看看自己的掌握程度吧
一、选择题（针对以下题目，请选择最符合题目要求的答案。针对每一道题目，所有答案都选对，则该题得分，所选答案错误或不能选出所有答案，则该题不得分。每题2分，共80分。）
1、在方法内定义的变量，描述正确的是（）？
A、一定在方法内所有位置可见
B、可能在方法的局部位置可见
C、在方法外可以使用
D、在方法外可见
2、关于方法的形参，描述正确的是（）？
A、可以没有
B、至少有一个
C、必须定义多个形参
D、只能是简单变量
3、关于return语句，描述正确的是（）？
A、不能用来返回对象
B、只可以返回数值
C、方法都必须含有
D、一个方法中可以有多个return语句
4、编译并运行下面的程序，运行结果是（）？
| public class A{ public static void main(String[] args){ A a=new A(); a.method(8); } void method(int i){ System.out.println("int:"+i); } void method(long i){ System.out.println("long:"+i); } } |
A、程序可以编译运行，输出结果为："int:8"
B、程序可以编译运行，输出结果为："long:8"
C、程序有编译错误，因为两个method()方法必须定义为静态（static）的
D、程序可以编译运行，但是没有输出
5、下列不属于面向对象程序设计的基本特征的是（）？
A、多态
B、封装
C、继承
D、静态
6、下列方法定义中，方法头不正确的是（）
A、public static x(double b){return b;}
B、public static int x(int y){return y;}
C、void x(double b){}
D、public int x(){return 0;}
7、请看下面的程序段
| class Person{ String name,department; int age; public Person(String n){name=n;} public Person(String n,int a){name=n;age=a;} public Person(String n,String d ,int a){ // doing the same ...
} } |
下面那个选项可以添加到//doing the same ...处（）？
A、Person(n,a)
B、this(Person(n,a))
C、this(n,a)
D、this(name,age)
8、请看下面的程序段
| class Test{ private int m; public static void fun(){ //some code
} } |
方法fun()如何来访问变量m（）?
A、将 private int m 改成 protected int m
B、将 private int m 改成 public int m
C、将 private int m 改成 int m
D、将 private int m 改成 private static int m 或者 创建Test对象 通过对象调用m;
9、关于接口的定义和实现，一下描述正确的是（）？
A、接口定义的方法只有定义没有实现
B、接口定义的变量都必须写明final和static
C、如果一个接口由多个类来实现，则这些类在实现该接口中的方法采用统一的代码
D、如果一个类实现接口，则必须实现该接口中的所有方法
10、从下列程序中你发现了几处错误（）？
| abstract class A{ abstract void f(){}; public abstract void k(); } class B extends A{ protected void f(); void k(){ System.out.println("i am subclass") } public static void main(String[] args){ A a=new A(); a.f(); a.k(); } } |
A、1
B、2
C、3
D、4
11、下列有关抽象类和接口的叙述中正确的是哪一个（）？
A、抽象类中必须要有抽象方法，接口中也必须有抽象方法
B、抽象类中可以有非抽象方法，接口中也可以有非抽象方法
C、含有抽象方法的类必须是抽象类，接口中的方法必须是抽象方法
D、抽象类中的变量定义时必须初始化，而接口中的不是
12、JAVA 是一种（）的语言。
A、面向过程
B、面向对象
C、基于对象
D、没有对象
13、下面a方法的重载哪个是正确的（）。
| void a(int b){} |
A、void a(int a,flaot b){};
B、int a(int b){ return b;};
C、float a(int b){ return 1.0;};
D、void b(float b){}
14、下面A类构造方法哪个是正确的（）。
| Class A{} |
A、A(){}
B、void A(){}
C、A(){return 1;}
D、Static A(){};
15、接口中的成员变量被隐含地声明为（）
A、 public static final
B、public final
C、public static
D、public abstract
16、已知：
| class Base { public Base(String s) { System.out.print(“B”); } } public class Derived extends Base { public Derived (String s) { System.out.print("D"); } public static void main(String [] args) { new Derived ("C"); } } |
那么结果为（）？
A、 BD
B、DB
C、C
D、编译错误
17、关于包的描述错误的是（）？
A、包可以将相关的类和接口组织在一起，便于识别和管理
B、包中的类可以访问同一包的其它类的私有成员
C、不同包中的相同命名，不会产生冲突
D、用public 修饰的顶级类和接口对包外代码可见
18、已知:
| class C { int x; String y; public C() { this(“1”); System.out.print(“one”); } public C(String y) { this(1, y); System.out.print(“two”); } public C(int x, String y) { this.x = x; this.y = y; System.out.print(“three”); } public static void main(String[] args) { C c = new C(); System.out.println(c.x + ““ + c.y); } } |
则输出为
A、11onetwothree
B、11threetwoone
C、onetwothree11
D、threetwoone11
19、以下代码运行输出是（）
| public class Person{ private String name=”Person”; int age=0; }
public class Child extends Person{ public String grade; public static void main(String[] args){ Person p = new Child(); System.out.println(p.name); } } |
A、输出：Person
B、没有输出
C、编译出错
D、运行出错
20、以下对封装的描述正确的是（）
A、只能对一个类中的方法进行封装，不能对属性进行封装
B、如果子类继承了父类，对于父类中进行封装的方法，子类仍然可以直接调用
C、封装的意义不大，因此在编码时尽量不要使用
D、封装的主要作用在于对外隐藏内部实现细节，增强程序的安全性
21、重载指的是方法具有相同的名字，但是这些方法的参数必须不同，下列哪种说法不属于方法的参数必须不同（）？
A、形式参数的个数不同
B、形式参数的类型不同
C、形式参数的名字不同
D、形式参数的排列顺序不同
22、下列程序运行的结果是（）？
| interface A{ String s="good"; void f(); } class B implements A{ public void f(){ System.out.println(s); } } class C{ void g(A a){ a.f(); } } public class E{ public static void main(String[] args){ C c= new C(); c.g(new A()); } } |
A、good
B、编译正确，但是无运行结果
C、编译错误：c.g(new A())
D、以上都不对
23、关于java中的继承，下列说法错误的是（）？
A、继承是面向对象编程的核心特征，通过继承可以更加有效的组织程序结构
B、继承使得开发人员可以在原有的基础上很快设计出一个功能更强的新类，而不必重头开始，避免了工作上的重复
C、每一次继承时，子类都会自动继承父类拥有的公有属性和方法，同时也可以加入自己的一些特性，使得它更具体、功能更加强大
D、继承一般有多重继承与单继承两种方式，在单一继承中每一个类最多只有一个父类，而多重继承，则可以有多个父类。java中的类采用的是多重继承。
24、已知类关系如下：
| class Employee{} class Manager extends Employee{} class Director extends Employee{} |
下列语句正确的是（）
A、Employee e=new Manager();
B、Director d= new Manager();
C、Manager m=new Director();
D、Director d=new Employee();
25、编译下面程序，结果是（）
| public class A{ public static void main(String[] args){ B b=new B(); b.test(); } void test(){ System.out.print("A"); } } class B extends A{ void test(){ super.test(); System.out.print("B"); } } |
A、产生编译错误
B、代码可以编译运行，并输出结果：AB
C、代码可以编译运行，但是没有输出
D、编译没有错误，但是会在运行中出错
26、接口是Java面向对象的实现机制之一，以下说法正确的是（）。
A、Java 支持多重继承，一个类可以实现多个接口
B、Java 只支持单重继承，一个类可以实现多个接口
C、Java 支持多重继承， 一个类只可以实现一个接口
D、Java 只支持单重继承，一个类只可以实现一个接口
27、声明为static 的方法不能直接访问（）类成员。
A、超类
B、子类
C、非static
D、用户自定义类
28、关键字（）表明一个对象或者变量在初始化不能修改。
A、extends
B、final
C、finalize
D、this
29、定义类
| class A{ int a,b,c; public void B(int x,int y.,int z){a=x;b=y;c=z;} } |
下面对方法重载那些是正确的（）？
A、public void A(int x,int y,int z){a=x;b=y;c=z;}
B、public void B(int x1,int y1,int z1){a=x1;b=y1;c=z1;}
C、public void B(int x,int y){a=x;b=y;c=0;}
D、public B(int x,int y,int z){a=x;b=y;c=z;}
30、给定java程序，如下：
| public class Test{ private static final int counter=10; public static void main(String [] args){ System.out.println(++counter); } |
编译运行Test.java，结果是 （ ）
A、10
B、11
C、编译错误
D、运行时出现异常
31、给定如下Java程序代码，在横线处加入（ ）语句，可以使这段代码编译通过。
| interface Parent{ public int count(int i); } public class Test implements Parent { public int count(int i){ return i % 9; } public static void main(String[] args){ ________________ int i = p.count(20); } } |
A、Test p = new Test();
B、Parent P = new Test();
C、Parent p = new Parent();
D、Test P = new Parent();
32、分析如下Java代码，如果想在控制台以多态的形式上输出“B类的test()方法”，则在横线处应填入（ ）。
| class A { public void test() { System.out.println("A类的test()方法"); } } class B extends A { public void test() { System.out.println("B类的test()方法"); } public static void main(String args[]) { _______________________________ } } |
A、A a = new B();
a.test();
B、A a = new A();
a.test();
C、B b = new A();
b.test();
D、B b = new B();
b.test();
33、分析如下所示的Java代码，则选项中的说法正确的是（）。
| class Parent{ public String name; public Parent(String pName){ this.name = pName; } } public class Test extends Parent { //2 public Test(String Name){ //3 name="hello"; //4 super("kitty"); } } |
A、第2行错误，Test类的构造函数中参数名称应与其父类构造函数中的参数名相同
B、第3行错误，应使用super关键字调用父类的name属性，改为super.name="hello";
C、第4行错误，调用父类构造方法的语句必须放在子类构造方法中的第一行
D、程序编译通过，无错误
34、Java中，如果类C是类B的子类，类B是类A的子类，那么下面描述正确的是（）。
A、C不仅继承了B中的公有成员，同样也继承了A中的公有成员
B、C只继承了B中的成员
C、C只继承了A中的成员
D、C不能继承A或B中的成员
35、分析如下所示的Java代码，其中this关键字的意思是（）。
| public class Test { private String name; public String getName() { return name; } public void setName(String name) { this.name = name; //this关键字所在的行 } } |
A、name属性
B、Test类的内部指代自身的引用
C、Test类的对象引用Test类的其他对象
D、指所在的方法
36、使用Java实现封装，第一步是修改属性可见性来限制对属性的访问，
第二步是创建赋值和取值方法，用于对属性的访问，第三步应该是（）。
A、使用赋值和取值方法访问属性
B、编写常规方法访问属性
C、在赋值和取值方法中，加入对属性的存取限制
D、编写main方法创建对象，调用赋值和取值方法访问属性
37、在Java中，下面对于构造函数的描述正确的是（）。
A、类必须显式定义构造函数
B、构造函数的返回类型是void
C、构造函数和类有相同的名称，并且不能带任何参数
D、一个类可以定义多个构造函数
38、在Java中，下列关于方法重载的说法中错误的是（）。
A、方法重载要求方法名称必须相同
B、重载方法的参数的个数或者参数的类型或者参数的排序排列顺序必须不一致
C、重载方法是在同一个类中进行
D、一个方法在所属的类中只能被重载一次
39、下面Java代码的运行结果是（）。
| class Penguin { private String name=null; // 名字 private int health=0; // 健康值 private String sex=null; // 性别 public void Penguin() { health = 10; sex = "雄"; System.out.println("执行构造方法。"); } public void print() { System.out.println("企鹅的名字是" + name + "，健康值是" + health + "，性别是" + sex+ "。"); } public static void main(String[] args) { Penguin pgn = new Penguin(); pgn.print(); } } |
A、企鹅的名字是null，健康值是10，性别是雄。
B、执行构造方法。企鹅的名字是null，健康值是0，性别是null。
C、企鹅的名字是null，健康值是0，性别是null。
D、执行构造方法。企鹅的名字是null，健康值是10，性别是雄
40、下列选项中关于Java中封装的说法错误的是（）。
A、封装就是将属性私有化，提供公有的方法访问私有属性
B、属性的访问方法包括setter方法和getter方法
C、setter方法用于赋值、getter方法用于取值
D、类的属性必须进行封装，否则无法通过编译
答案自此！
1-5 BADAD
6-10 ACDDC
11-15 CBAAA
16-20 DBDCD
21-25 CCDAB
26-30 BCBCC
31-35 BADAB
36-40 CDDCD