面向对象编程基本知识练习 一、判断题
1.不需要定义类，就能创建对象。（）
2.构造方法用于给类的 private 实例变量赋值。（） 3.对象一经声明就可以立即使用。（）
4.在定义变量和方法时，必须清楚地在其面前标上访问权限修饰符。（） 5.Java 程序中的参数传递都是把参数值传递给方法定义中的参数。（） 6.在类定义中，成员访问权限修饰符不能多次出现。（）
7.new 操作符动态地为对象按其指定的类型分配内存，并返回该类型的一个引用。（） 8.类的方法通常设为 public，而类的实例变量一般也设为 public。（） 9.构造方法在创建对象时被调用。（）
10.通过点运算符与类对象的引用相连，可以访问此类的成员。（） 11.声明为 protected 的类成员只能被此类中的方法访问。（）
12.同一个类的对象使用不同的内存段，但静态成员共享相同的内存空间。（） 13.类的成员变量可以放在类体的任意位置。（）
14.声明为 protected 的类成员可以被此类作用域中的任何对象访问。（） 15.没有返回值的方法可以用 void 来表示，也可以不加。（） 二、选择题
1. 下面对对象概念描述错误的是：( ) A 操作是对象的动态属性 B 任何对象都必须有继承性 C 对象间的通讯靠消息传递 D 对象是属性和方法的封装体
2．编译并运行下面的程序，运行结果为：( ) 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 程序可以编译运行，但没有输出 3．下面关于类的说法不正确的是：（） A 类是 Java 语言中的一种复合数据类型 B 类中不包含数据变量和方法
C 类是对所有具有一定共性的对象的抽象 D Java 语言的类只支持单继承
4．能作为类及其成员的修饰符是：（） A interface B class
C protected D public
5．设 x、y 均为已定义的类名，下列声明对象 x1 的语句不可能正确的是：（） A public x xl=new y(); B public y xl=new x(); C x xl=new x(); D x xl=x();
6．面向对象程序设计技术的特点是：（） A 可重用性 B 可维护性
C 表示方法的一致性
D 可重用性、可维护性、表示方法的一致性 7．下列方法定义中，方法头不正确的是：（） A public static x(double a){…} B public static int x(double y){…} C void x(double d) D public int x(){…}
8．设已声明了一个类 A 的两个对象 al、 a2，为了初始化 a1 和 a2，下面语句正确的是：（）
A al=new(); a2=new(); B al=A new(); a2=A new(); C al,a2=new A();
D al=new A(); a2=new A(); 9．构造方法何时被调用?（） A 类定义时
B 使用对象的变量时 C 调用对象方法时 D 创建对象时
10．下列哪个类声明是正确的?（） A public abstract class Car{…} B abstract private move(){…} C protected private number; D abstract final class Hl{…}
11．下列不属于面向对象程序设计的基本特征的是：（）
A 抽象 B 封装 C 继承 D 静态
12．请看下面的程序段 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 as two arguments version of constructer //including assignment name=n,age=a } }
下面那一选项可以添加到“//doing the same??”处：（） A Person(n,a)
B this(Person(n,a)) C this(n,a)
D this(name.age)
13．（）是一个特殊的方法，用于对类的实例变量进行初始化。 A 终止函数 B 构造函数 C 重载函数 D 初始化函数
14．关于变量和它们范围的说法，正确的是：（） A 实例变量是类的成员变量
B 实例变量要用关键字 static 来声明
C 在一个方法执行时，定义在该方法的局部变量才被创建 D 局部变量必须在它们使用前初始化 15．请看下面的程序段 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 改成 static int m D 将 private int m 改成 int m
16．在 Java 中，方法 main()将返回一个（）值。 A String
B int C char D void
17．有一个类 A，对于其构造函数的声明正确的是（） A void A(int x){…} B public A(int x){…} C A A(int x){…} D int A(int x){…}
18．请看下面的程序段 public class Test {
long a[ ] = new long[10];
public static void main(String arg[ ]) { System .out .println(a[6]); } }
那一个选项是正确的：（） A 不输出任何内容 B 输出 0
C 当编译时有错误出现 D 当运行时有错误出现
19．关键字（）表明一个对象或变量在初始化后不能修改。 A extends B final C this D finalizer
20．声明为 static 的方法不能访问（）类成员。 A 超类 B 子类
C 非 static D 用户自定义类 类的封装练习 一、判断题
1.在子类中可以用完全相同的 signature 重新定义一个超类方法，这称为方法的覆盖 （override）。（）
2.final 修饰的方法是不能被子类覆盖的，只能被重载。（） 3.声明为 final的类不能是超类。（）
4.当一个超类成员不适合该子类时，子类会以恰当的方式重新定义它。（） 5.对子类实例化对象需要调用超类的构造函数进行初始化工作，完成对子类中的超类实例变量的初始化，则子类可以继承超类的构造函数。（）
6.在类的定义中如果不明确给出超类，那么默认超类就是 Object 类。（）
7.protected 类型的实例变量或方法只能由声明该变量或方法的类本身及其子类访问。（） 8.Java 的每个子类的构造函数都要显式的调用它的直接超类的构造函数。（） 9.超类对象的集合通常比它的任何一个子类对象集合大。（） 10.子类可以从多个超类中派生出来。（）
二、选择题
1．为了区分重载多态中同名的不同方法，要求：（） A 参数名不同 B 返回值类型不同
C 采用不同的形式参数列表 D 选项 A B C 都对
2．在某个类中定义一个方法：void GetSort(int x)，以下关于能否作为这个方法的重载错 误的是：（）
A void GetSort(float x){x*=x;}
B int GetSort(double y){ return(int)(2*y); } C double GetSort(int x,int y){return x+y; } D 都不能
3．下列对继承的说法，哪个是正确的：（） A 子类只能继承父类 public 方法和状态 B 子类能继承父类的非私有方法和状态 C 子类能继承父类的所有方法和状态
D 子类只能继承父类的方法，而不继承状态 4．定义类 A 如下： class A
{ int a,b,c;
public void B(int x,int y,int z){a=x; b=y; c=z; } }
下面对方法 B()的重载哪些是正确的：（）
A public void A(int xl,int yl,int z1){ a=x; b=y; c=z; } B public void B(int x1,int yl,int z1){ a=x; b=y; c=z;} 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; } 5．下列程序的结果输出为：（） class Strange{ int j; Strange(){ this(4); }
Strange(int j){ this.j=j; } }
class MainStrange{
public static void main(string[] args){ Strange funny=new Strange(); System.out.println(“j=“+funny.j); } } A j=2