工作内容
面向对象测试
面向对象的自我梳理：
类
private（封装，能用的时候尽量用）【不可以用于修饰类】
public
protected （子类可用）【不能用于修饰类】
默认
成员变量，类变量（static）
成员方法，类方法（static）— static{ }最先执行,构造函数执行，static 返回类型 方法名(){ }需调用的时候才会执行
【类方法只能操作类变量】
static修饰的属性和方法：属于类，最先拥有内存空间
构造方法：[修饰符] 类名 【同一个类中构造函数可以相互调用，调用方法 this(参数) 】
继承 extends
单继承
父类的构造方法，子类必须super()调用【父类构造方法是无参构造方法，则子类无需super()调用，系统会默认调用】
方法重写：@Override 子类重写父类的方法，子类对象调用的是子类的方法，子类中可以用 super.父类方法 来调用父类方法
方法重载：@Overnode 修饰符，同一个类中，返回值类型【可以】不一样，方法名必须一样，参数个数或参数类型其中任何一种不一样都构成了方法的重载
protected(子类可用)
abstract（抽象类）不能用于创建对象，可以被继承（抽象方法）不能有方法体，在非抽象子类必须被实现（子类是抽象类，可以不实现父类的抽象方法）
接口 interface 【不能被继承extends】
接口中的变量默认是常量（static final）
默认接口中的方法都是抽象方法（无需显式写出 [ 即：可以不写abstract，系统默认就是abstract ] ）
用 implements 继承接口（继承接口后必须实现接口中的所有方法）
可以同时实现多个接口，接口间用“,”隔开
测试分享：
在测试过程中发现还有很多基础的东西需要去理解透彻，平时写代码，写代码测试还不够全面。【测试能帮助你找到一些平时注意不到的问题，并促使你去了解它们，学习它们】
自学分享：
对象输入输出流的使用：（对象先进先出，按序读取，不能跳过读取）
注意：要写入的对象的类需先实现接口Serializable 或者 Externalnalizable，如果调用了父类的构造函数，则需要父类也要实现接口Serializable （接口作用：使类可串行化，可序列化）
【注意：父类实现了接口，则子类可以不实现接口就可以序列化写入和读取】
下面是 写→读 的过程（过程中实现了序列化[写入]与反序列化[读取]）
//输出流建立
FileOutputStream fos = new FileOutputStream(file);
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(dog);//dog可以是对象,或者对象数组
oos.flush(); //清理输出流的缓冲，写入多个对象时，尽量写一个就清理一次
oos.close();
fos.close();
System.out.println("读取：");
//输入流建立
FileInputStream fis = new FileInputStream(file);
ObjectInputStream ois = new ObjectInputStream(fis);
dog2= (Dog)ois.readObject();//反序列化为Dog对象
ois.close();
fis.close();
借阅：（序列化与反序列化——写入对象需实现接口Serializable 或者 Externalnalizable）
http://blog.csdn.net/wangloveall/article/details/7992448
测试题：
一、选择题
1、JAVA语言中，在类定义时使用final关键字修饰，是指这个类（ ）
A 、不能被继承 B、 在子类方法中不能被调用
C 、能被别的程序自由调用 D、 不能被子类的方法覆盖
2、下列选项中，表示数据或方法可以被同一包中的任何类或它的子类访问，即使子类在不同的包中也可以的修饰符是（ ）
A、public B、protected C、private D、final
3、下列选项中，表示数据或方法只能被本类访问的修饰符是（ ）
A、public B、protected C、private D、final
4 、下列选项中，接口中方法的默认可见性修饰符是( )
A、public B、protected C、private D、final
5、方法的重载指多个方法可以使用相同的名字，但是参数的数量或类型必须不完全相同，即方法体有所不同，它实现了java编译时的 （ ）
A、 多态性 B、 接口 C、 封装性 D、 继承性
6、在某个类中存在一个方法、void sort(int x),以下不能作为这个方法的重载的声明的是( )。
A、public float sort(float x) B、int sort(int y)
C、double sort(int x,int y) D、void sort(double y)
7、为了区分类中重载的同名的不同方法，要求( )。
A、采用不同的形式参数列表 B、 返回值类型不同
C、 调用时用类名或对象名做前缀 D、 参数名不同
8、在类的定义中，通过使用（ ）关键字可创建一个现有类的子类。
A、extends B、implements C、inherits D、modifies
9、为了调用超类的方法，可以使用（ ） 关键字后跟包含该超类所需参数的一对圆括号。
A、superclass B、superconstructor C、super D、以上答案都不对
10、关键字（ ）表示某个新类是由一个现有的类中继承的
A、 interits B、extends C、reuses D 、以上答案均不对
11、JAVA语言中的类间的继承关系是（ ）
Ａ、 多重 Ｂ、 单重 Ｃ、 线程 Ｄ、 不能继承
12、下列选项中，用于定义子类时声明父类名的关键字是（ ）
A、 interface B、 package C、extends D、class
13、下列关键字中，用于声明类实现接口的关键字是（ ）
A、 implements B、package C、 extends D、 class
14、下列修饰符可以用于说明类的是（ ）
A、 private B、 static C、 abstract D、 protected
15、用于定义类成员的访问控制权的一组关键字是（ ）
A、 class, float, double, public B、float , boolean ,int , long
C、 char , extends , float , double D、public ,private ,protected
16、下列哪些说法是正确的（ ）
A、JAVA语言只允许单继承
B、JAVA语言中只允许实现一个接口
C、java语言不允许同时继承一个类并实现一个接口
D、JAVA语言的单一继承使得代码更加可靠
17、方法的重载是指（ ）
Ａ、两个或两个以上的方法取相同的方法名，但是参数的个数或类型不同
Ｂ、两个以上的方法去相同的名字和具有相同参数个数，但形参的类型可以不同
Ｃ、两个以上的方法名字不同，但形参的个数或类型相同
Ｄ、两个以上的方法取相同的方法名，并方法的返回值类型相同
18、下列关于类说法正确的是（ ）
A、类是JAVA语言中的一种复合数据类型
B、类是包含数据变量和方法
C、类是对所有具有一定共性的对象的抽象
D、JAVA语言的类支持多继承
19、下面哪个说法确（ ）
A、如果某公共的类被声明在一个源文件中，则该类必须与源文件具有相同的名字
B、JAVA语言中，一个类只能是实现一个接口
C、如果某源文件包含package语句，则该语句必须是第一个非空、非注释行
D、接口中的方法必须是抽象的，但可以不用关键abstract修饰
20、类的设计要求它的某个成员变量不能被外部类直接访问，应该使用下面的那些修饰符获得需要的访问控制（ ）
A、 public B、不加修饰符 C、protected D、private
21、指出下列哪个方法不是方法public void add(int a){}的合理的重载（ ）
A、public int add(int a) B、public void add(long a)
C、public void add (int a,int b) D、public void add(float a)
22、下列说法正确的是（ ）
A、用final修饰一个类表明这个类不可以派生子类
B、用final修饰一个方法表明这个方法不能被覆盖
C、用final修饰一个变量会变成一个常量
D、用final修饰的类可以被继承
23、下列程序片断用的是什么机制？ ( )
class Student{
String name;
int age;
Student(){}
Student(String n, int a){name=n; age=a;}
Student(String n){name=n;}
}
A、方法的覆盖 B、 构造方法重载 C、多态 D、 这是错误的代码
24、关于抽象类下列哪个描述正确？ ( )
A、抽象类不能包含抽象方法。 B、接口和抽象类是一回事。
C、抽象类不能实例化，即不能生成对象。 D、抽象类可以实例化对象。
25、关于被私有保护访问控制符 private protected修饰的成员变量，以下说法正确的是（ ）
A、可以被三种类所引用:该类自身、与它在同一个包中的其他类、在其他包中的该类的子类
B、可以被两种类访问和引用:该类本身、该类的所有子类
C、只能被该类自身所访问和修改
D、只能被同一个包中的类访问
26、编译并运行以下程序，以下描述哪个选项是正确的（ ）
class X{
protected String toString(){
return super.toString();}
}
A、编译通过运行无异常 B、编译通过但运行时出错 、
C、行 2出错，不能成功编译 D、不能成功编译，行3出错
27、下列关于修饰符混用的说法，错误的是（ ）
A、abstract不能与final并列修饰同一个类
B、abstract类中不可以有private的成员
C、abstract方法必须在abstract类中
D、static方法中能处理非static的属性
28、类 Test1定义如下:
public class Test1{
public float aMethod （ float a，float b）{ }
}
将以下哪种方法插入行 3 是不合法的。（ ）
A、 public float aMethod（float a，float b，float c）{ }
B、 public float aMethod（float c，float d）{ }
C、 public int aMethod（int a，int b）{ }
D、 private float aMethod（int a，int b，int c）
29、类 Test1、Test2定义如下、
1 ． public class Test1
2 ． { public float aMethod（float a，float b）throws
3 ． IOException { }
4. }
5. public class Test2 extends Test1{
6 ．
7 ． }
将以下哪种方法插入行 6 是不合法的。（ ）
A、float aMethod（float a，float b）{ }
B、public int aMethod（int a，int b）throws Exception{ }
C、public float aMethod（float p，float q）{ }
D、public int aMethod（int a，int b）throws IOException{ }
30、下列有关 Java中接口的说法哪个是正确的？（ ）
A、接口中含有具体方法的实现代码
B、若一个类要实现一个接口，则用到 “implements” 关键字
C、若一个类要实现一个接口，则用到“ extends”关键字
D、接口不允许继承
31、如果有一个对象 myListener (其中myListener对象实现了ActionListener接口),下列哪条语句使得myListener对象能够接受处理来自于smallButton按钮对象的动作事件?（ ）
A、 smallButton.add(myListener);
B、 smallButton.addListener(myListener);
C、 smallButton.addActionListener(myListener);
D、 smallButton.addItem(myListener);
32、不允许作为类及类成员的访问控制符的是( )。
A、public B、private C、static D、protected
33、对于构造方法，下列叙述不正确的是（ ）
A、 构造方法是类的一种特殊方法，他的方法名必须与类名相同。
B、 构造方法的返回值类型只能是void型。
C、 构造方法的主要作用是完成对类的对象的初始化工作。
D、 一般在创建新对象时，系统会自动调节用构造方法。
34、在JAVA中，一个类可以同时定义许多同名的方法，这些方法的形式参数的个数、类型、顺序各不相同，返回值也可以不相同，这种面向对象程序特征称为（ ）
A、隐藏 B、 覆盖 C、重载 D、JAVA不支持此特性
36、若已经使用A A类创建对象a和BB类创建对象b，则下面的哪一个方法调用是正确的（ ）
A、 a.show B、AA.show C、 AA.show D、 a.show
b.show BB.show b.show BB.show
37、若在某一个类定义中定义有如下的方法 abstract void performDial( );
该方法属于（ ）。
A、本地方法 B、最终方法 C、成员方法 D、抽象方法
38、设有下面两个类的定义、
class Person { class Student extends Person {
long id; // 身份证号 int score; //入学总分
String name; // 姓名 int getScore(){
} return score;
}
}
问：类Person和类Student的关系是（ ） 。
A、包含关系 B、继承关系
C、关联关系 D、无关系，上述类定义有语法错误
39、如果子类中的方法mymethod()覆盖了父类中的方法mymethod()，假设父类方法头部定义如下：void mymethod(int a)，则子类方法的定义不合法的是、（ ）
A、public void mymethod(int a) B、protected void mymethod(int a)
C、private void mymethod(int a) D、void mymethod(int a)
40、ArrayList对象的（ ）方法将返回一个可一次访问ArrayList中元素的迭代器
A、 iterator B、getIterator C、returnTterator D、 以上答案都不对
41、为删除ArrayList中的一个特定索引所对应的元素。应使用（ ）方法
A、remove B、removeAt C、delete D、deleteAt
42、用private声明的类成员，其最大的访问范围是( )。
A、本类 B、本包中的所有类 C、所有包中的子类 D、所有包中的全部类
43、对于任意一个类，用户所能定义的构造方法的个数至多为( )。
A、0个 B、1个 C、2个 D、任意个
44、构造方法何时被调用（ ）
A、类定义时 B、创建对象时 C、调用对象方法时 D、使用对象的变量时
45、如果创建的一个子类覆盖一个父类public方法，则对该方法可以使用哪些修饰符修饰？( )
A、public B、public和protected
C、privite D、任意修饰符都可以，由系统随机选取
46、关于被保护访问控制符protected修饰的成员变量，以下说法正确的是（ ）
A、可以被三种类所引用:该类自身、与它在同一个包中的其他类、在其他包中的该类的子类
B、可以被两种类访问和引用:该类本身、该类的所有子类
C、只能被该类自身所访问和修改
D、只能被同一个包中的类访问
47、下面对java继承机制描述错误的是、（ ）
A、声明子类时用extends关键字 B、继承是面向对象的一个重要特征
C、java支持多重继承 D、继承时子类可以添加自己的方法
48、对关键字super的用法描述正确的是、（ ）
A、 用来调用父类的构造方法 B、 用来调用父类中被重载的方法
C、 用来调用父类中隐藏的成员变量 D、 以上说法都正确
50、当子类中的成员变量与父类中的成员变量相同时:（ ）
A、子类中的成员变量隐藏父类中的变量 B、父类中的成员变量隐藏子类中的变量
C、子类中变量无效 D、该声明非法
51、类class A中方法定义为protected void f()，则该方法的访问性是( )
A、所有类都访问该方法
B、所有子类都访问该方法
C、同一目录下的类可以访问该方法，但需要用import语句装载该类
D、以上均不对
52、在Java中，关键字（ ）使类不能派生出子类。
A、final B、public C、private D、protected
53、在Java中，类Worker是类Person的子类，Worker的构造方法中有一句“super()”，该语句（ ）。
A、调用类Worker中定义的super( )方法 ； B、调用类Person中定义的super( )方法；
C、调用类Person的构造函数； D、调用类Worker的构造函数；
54、下列说法正确的是？ ( )
A、 一个子类可以有多个父类，一个父类也可以有多个子类
B、 一个子类可以有多个父类，但一个父类只可以有一个子类
C、一个子类可以有一个父类，但一个父类可以有多个子类
D、 上述说法都不对
55、已知类关系如下:
class Employee{…};
class Manager extends Employee{…};则以下有关创建对象的语句不正确的是( )
A、Employee e=new Manager(); B、Employee m=new Employee ();
C、 Manager c=new Manager(); D、Manager d=new Employee();
56、在Java程序中，对象之间的相互通信通过( )
A、继承实现 B、调用类的方法实现 C、封装实现 D、方法重载实现
57、关于抽象类正确的是（ ）
A、抽象类中不可以有非抽象方法。
B、某个非抽象类的父类是抽象类，则这个子类必须重载父类所有的抽象方法。
C、不能用抽象类去创建对象。
D、接口和抽象类是同一个概念。
58、下面关于抽象类的描述错误的是（ ）
A、继承抽象类可以创建子类 B、抽象类中一定有抽象方法
C、抽象类中可以有成员方法 D、抽象方法只能存在抽象类或接口中
59、下面选项正确的是（ ）
A、抽象类可以有构造方法。 B、接口可以有构造方法。
C、可以用new操作符操作一个接口。 D、可以用new操作符操作一个抽象类。
60、（ ）访问修饰符可允许其他类对某个方法进行调用
A、 public B、private C、 默认 D、 以上答案都不对
61、使用（ ）方法可以获取得到某个实例变量的值。
A、get方法 B、return语句 C、值的方法 D、set方法
62、一个private实例变量不能（ ）
A、在声明时被初始化 B、在所声明类的外侧被初始化
C、在某个构造方法之内初始化 D、初始化为默认值
63、构造方法和普通方法之间的一个重要区别是（ ）
A、构造方法不能指定返回值类型 B、构造方法不能指定任何参数
C、同一文件中，构造方法位于其他方法之前 D、构造方法能够向实例变量赋值
64、一个类可得到许多（ ），正如一个基本类型可得到许多变量一样
A 、名称 B、 对象 C、 值 D 、类型
65、set方法能够为开发人员（ ）、
A、 提供校验的范围 B、 修改数据
C、 提供数据验证 D、 以上答案都正确
66、声明为private的实例变量不能直接（ ）访问
A、 在类的外侧 B、 由同一个类的其他方法
C、 由类的构造方法 D、 在同一个类的内部
67、下列选项中，定义最终类的关键字是( )。
A、interface B、implements C、abstract D、final
68、Java语言的类间的继承关系是( )
A、单继承 B、多继承 C、单继承和多继承 D、不能继承
69、使用（ ）语句可调用超类中无参的构造方法
A、super(); B、superclass(); C、superClass(); D、以上答案不对
70、当子类覆盖超类中的方法时，如果要在子类中完成对超类方法的访问，那么在调用时需要在对象的名字前添加一个（ ）关键字和一个（ ）
A、 super 分号（；） B、super逗号（，）
C、 super 点（.） D、以上答案都不对
72、如果Truck类扩展Vehicle类那么，若现在希望从Truck类中调用Vehicle类的一个无参的构造方法，则需编写的代码应为（ ）
A、Truck() B、superClass() C、super() D、noArgument()
73、如果Truck类扩展了Vehicle类，那么称Truck类为（ ） ，称Vehicle类为（）
A、超类 ，子类 B、子类， 超类 C、超类，直接超类 D、直接超类，超类
74、当子类覆盖其超类中的方法时，（ ）
A、 超类的方法需要拥有和子类方法相同的方法头
B、 超类的方法将被子类的方法所取代
C、 应使用关键字super后跟一个点（.）来实现子类中超类方法的访问
D、 以上答案都对
75、在（ ）关系中，子类的对象也可看作是其超类的一个对象
A、 is a B、 like a C、has a D、 以上答案都不对
76、在（ ）关系中，类中可包含其他类的对象的引用
A、 is a B、 like a C、 has a D、 以上答案都不对
77、一个类在实现接口时，必须（ ）
A、 额外的定义一个实例变量 B、 实现接口中的所有方法
C、 扩展该接口 D、 以上答案都不对
78、匿名内部类（ ）
A、 没有名字 B、 在另一个类的内部定义
C、 在定义外将创建一个实例 D、 以上答案都对
79、利用多态，使用同一个（ ）可产生不同的操作，这取决于调用方法的参数类型。
A 、方法返回类型 B、 实例变量 C、 局部变量 D、 方法名
80、如果MyTruck类继承MyCar类，则（ ）
A、 MyTruck类的对象可以赋值给MyCar类型的变量
B、 MyCar类的对象可以赋值给MyTruck类型的变量
C 、两个类型的对象可以相互赋值给对方类型的变量
D 、A和B
81、多态能够让开发人员（ ）进行编程
A、 以抽象的形式 B、 以全局的形式 C、以特定的形式 D、A和B
82、对于使用多态的应用程序来说，某个对象的确切类型（ ）
A、 执行时才可以知道 B、应用程序编译时能够判断
C 、程序员编写程序时就已知道 D、永远不会知道
83、通过继承，使用（ ）类型的变量可以调用超类和子类的方法
A、 基本 B、超类 C、子类 D、 以上答案都不对
84、下面哪个语句是正确的？( )
A、 Panel p = new Panel(); B、Button b=new Object("B");
C、 Panel p = new Frame(); D、Frame f = new Panel();
85、指出下列程序的错误，描述正确的是：( )
final class First {
private int a = 1;
int b = 2;
}
class Second extends First {
public void method() {
System.out.println(a + b);
}
}
A 、println()参数应为字符串，因此此处不能调用该方法。
B 、因为变量a是private ,所以在其他类中不能访问a。
C、 Second类 能继承First类。
D、 关键字final不能修饰类。
86、接口A的定义如下，指出下列哪些类实现了该接口？( )
interface A {
int method1(int i);
int method2(int j);
}
A、class B implements A {
int method1() { }
int method2() { }
}
B、class B {
int method1(int i) { }
int method2(int j) { }
}
C、class B implements A {
int method1(int i) { }
int method2(int j) { }
}
D、class B extends A {
int method1(int i) { }
int method2(int j) { }
}
87、下面的是关于类及其修饰符的一些描述，不正确的是、（ ）。
A、abstract类只能用来派生子类，不能用来创建abstract类的对象。
B、final类不但可以用来派生子类，也可以用来创建final类的对象。
C、abstract不能与final同时修饰一个类。
D、abstract类定义中可以没有abstract方法。
88、 对于构造函数，下列叙述不正确的是（ ）。
A、构造函数也允许重载。
B、子类无条件地继承父类的无参构造函数。
C、子类不允许调用父类的构造函数。
D、在同一个类中定义的重载构造函数可以相互调用。
89、下列选项中，定义抽象类的关键字是( )。
A、interface B、implements C、abstract D、class
90、如果任何包中的子类都能访问超类中的成员，那么应使用哪个限定词？( )
A、 public B、private C、protected D、transient
91、下面的哪个选项是正确的？( )
class ExSuper{
String name;
String nick_name;
public ExSuper(String s,String t){
name = s;
nick_name = t;
}
public String toString(){
return name;
}
}
public class Example extends ExSuper{
public Example(String s,String t){
super(s,t);
}
public String toString(){
return name +"a.k.a"+nick_name;
}
public static void main(String args[]){
ExSuper a = new ExSuper("First","1st");
ExSuper b = new Example("Second","2nd");
System.out.println("a is"+a.toString());
System.out.println("b is"+b.toString());
}
}
A、 编译时会出现例外。
B、 运行结果为、a is First
b is second
C、 运行结果为、a is First
b is Secong a.k.a 2nd
D 、运行结果为、a is First a.k.a 1nd
b is Second a.k.a 2nd
92、运行下列程序的结果是哪个？( )
abstract class MineBase {
abstract void amethod();
static int i;
}
public class Mine extends MineBase{
public static void main(String argv[]){
int[] ar = new int[5];
for(i = 0;i < ar.length;i++)
System.out.println(ar[i]);
}
}
A、打印5个0。 B、编译出错，数组ar[]必须初始化。
C、编译出错， Mine应声明为abstract。 D、出现IndexOutOfBoundes的例外。
93、有关类Demo，哪句描述是正确的？( )
public class Demo extends Base{
private int count;
public Demo(){
System.out.println("A Demo object has been created");
}
protected void addOne() {count++; }
}
A、 当创建一个Demo类的实例对象时，count的值为0。
B、 当创建一个Demo类的实例对象时，count的值是不确定的。
C、 超类对象中可以包含改变count值的方法。
D、 Demo的子类对象可以访问count。
94、在以下供选择的概念中，不属于面向对象语言概念的是 ( )
A、消息 B、模块 C、继承 D、多态性
95、对静态成员(用static修饰的变量或方法)的不正确描述是（ ）。
A、静态成员是类的共享成员； B、静态变量要在定义时就初始化；
C、调用静态方法时要通过类或对象激活； D、只有静态方法可以操作静态属性；
96、下列说法正确的是（ ）。
A、语句import java.applet.Applet；最后的Applet是代表类(class)。
B、抽象方法必须在抽象类中，所以抽象类中的方法都必须是抽象方法。
C、如果p是父类Parent的对象，而c是子类Child的对象，则语句c = p是正确的。
D、使用方法length( )可以获得字符串或数组的长度。
97、下列说法错误的是（ ）。
A、类及其属性、方法可以同时有一个以上的修饰符来修饰。
B、接口是特殊的类，所以接口也可以继承，子接口将继承父接口的所有常量和抽象方法。
C、一个类如果实现了某个接口，那么它必须重载该接口中的所有方法。
D、Java的源代码中定义几个类，编译结果就生成几个以.class为后缀的字节码文件。
98、创建对象的关键字是（ ）
A、errupt B、set C、new D、create
99、接口可以继承多个父类接口，父接口之间使用（ ）符号隔开。
A、 . B、 ， C、 ； D、/
100、下列说法正确的一项是（ ）
A、java、lang、Integer是接口 B、java.lang. Runnable类可以创建对象
C、Double对象存在java.lang包中 D、Double对象在java.Lang.Object包中
101、下列关于类、包和源文件的描述中，不正确的一项是（ ）
A、一个包可以包含多个类 B、一个源文件中，可能有一个公共类
C、属于同一个包的类在默认情况下可以相互访问 D、系统不会为源文件创建默认的包
102、下列关于类、包和源文件的说法中，错误的一项是（ ）
A、一个文件可以属于一个包 B、一个包可包含多个文件
C、一个类可以属于一个包 D、一个包只能含有一个类
103、下列关于java.lang包封装的基本类的说法中，不正确上网一项是（ ）
A、java.lang包封装了Object、Class、System、String、Thread等基本类
B、System类提供了标准的I/O操作，可以实例化
C、Class类的对象包含所对应的类的基本信息，可以通过Class类的方法访问这些信息
D、Object类是所有类都必须继承的类
104、定义类时，不可能用到的保留字是（ ）
A、private B、class C、exends D、implements
105、下列那个不是面向对象程序设计方法的特点？（ ）
A、抽象 B、继承 C、多态 D、结构化
106、在使用interface声明一个接口时，可以使用哪一个修饰符定义该接口？（ ）
A、private B、protected C、private protected D、public
107、Java中所有的类都是通过直接或间接地继承（ ）类得到的。
A、java.lang.Object B、java.lang.Class C、任意类 D、以上答案都不对
109、现有两个类M、N，以下描述中表示N继承自M的是( )。
A、 class M extends N B、class N implements M
C、 class M implements N D、class N extends M
110、面向对象的一个重要特征（ ）它使代码可重用，降低程序复杂性。
A、 类 B、 内部类 C、 继承性 D、 多态
Object C、 ArrayList D、 以上答案都不对
113、下列选项中，用于定义接口的关键字是( )。
A、interface B、implements C、abstract D、class
114、以下关于Java语言继承的说法错误的是( )。 A、Java中的类可以有多个直接父类 B、抽象类可以有子类
C、Java中的接口支持多继承 D、最终类不可以作为其它类的父类
115、下列关于构造方法的叙述中，错误的是（ ）
A、Java语言规定构造方法名与类名必须相同
B、Java语言规定构造方法没有返回值，但不用void声明
C、Java语言规定构造方法不可以重载
D、Java语言规定构造方法只能通过new自动调用
116、在一个类中定义成员变量和成员方法时，不允许 （ ） 。
A.、两个成员变量名相同. B、成员变量与成员方法名相同.
C、 两个成员方法名相同 D、成员方法中的参数与成员变量名相同.
117、一个子类继承父类,子类不可以继承父类中访问权限设定为（ ） 的变量和方法.
A、public B、protected C、 private D、 未修饰
118、当子类中的成员变量或方法与继承的父类的成员变量或方法相同时，子类的对象所使用的变量是（ ）
A、是父类的变量,子类的方法 B、父类中的变量或方法
C、 子类中的变量或方法 D、子类的变量,父类的方法
119、下列叙述正确的是 （ ）
A、 在类中的构造方法的名字与类的名字相同, 而且不能重载
B、 在类中的构造方法的名字与类的名字相同,但没有返回类型.
C、 在类中的构造方法的名字与类的名字相同,而且有返回类型.
D、 在类中的构造方法的名字与类的名字相同,而且不能初始化.
120、要想定义一个不能被实例化的抽象类，在类定义中必须加上修饰符( )。
A、 final B、public C、private D、abstract
121、有一个类A，对于其构造函数的声明正确的是（ ）
A、void A(int x){…} B、A(int x){…} C、A A(int x){…} D、int A(int x){…}
122 、下面是有关子类调用父类构造函数的描述正确的是（ ）
A、子类定义了自己的构造函数，就不会调用父类的构造函数
B、子类必须通过super关键字调用父类没有参数的构造函数
C、如果子类的构造函数没有通过super调用父类构造函数，那么子类会先调用父类不含参数的构造函数，再调用子类自己的构造函数
D、创建子类对象时，先调用子类自己的构造函数，然后调用父类的构造函数
123、在Java中，要定义类的保护类型元素，则必须使用的关键字是（ ）
A、default B、private C、public D、protected
124、 若要说明一个抽象类，使用的关键字是、（ ）
A、static B、implements C、extends D、abstract
126、如果任何包中的子类都能访问超类中的成员，那么应使用哪个限定词？ ( )
A.、public B、.private C、protected D、transient
128、下列关于接口和抽象类的说法不正确的是？( )
A、 接口也有构造方法 B、实现接口时，需对接口中的所有方法都要实现
C、抽象类也有构造方法 D、 抽象类可以派生出子类
129、 有关类的说法正确的是？ ( )
A、类具有封装性，所以类的数据是不能被访问的
B、 类具有封装性，但可以通过类的公共接口访问类中的数据
C、 声明一个类时，必须用public修饰符
D、 每个类中，必须有main方法，否则程序无法运行
130、下述哪一组方法，是一个类中方法重载的正确写法？ ( )
A、 int addValue( int a, int b ){return a+b;}
float addValue ( float a, float b) {return a+b;}
B、 int addValue (int a, int b ){value=a+b; }
float addValue ( int a, int b) {return (float)(a+b);}
C、 int addValue( int a, int b ){return a+1;}
int addValue ( int a, int b) {return a+b;}
D、 int addValue( int a, int b ) {return a+b;}
int addValue ( int x, int y ) {return x+y;}
131、下列程序的结果输出为：（ ）
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 B、 j=4 C、 j=6 D、 j=7
132、（ a ）可专门用于存储由多个值所形成的分组
A、 集合 B、 属性 C、 访问器 D、 以上答案都不对
134、Java语言的类间的继承的关键字是( )。
A、 implements B、extends C、class D、public
135、访问修饰符（）用于指明其成员变量只能在该成员变量所属内部来访问（ ）
A、private B、public C、dimensional D、 以上答案都不对
136、给出下面代码
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) }
那些行将引起错误？ （ ）
A、 第3行 B、 第6行 C、 第7行 D、 第8行
137、下面关于构造方法的说法不正确的是（ ）
A、构造方法也属于类的方法，用于创建对象的时候给成员变量赋值。
B、构造方法不可以重载。
C、构造方法没有返回值
D、构造方法一定要和类名相同。
138、下面哪个修饰符修饰的变量是所有同一个类生成的对象共享的（ ）
A、public B、private C、static D、final
139、下面对对象概念描述错误的是：( )
A、操作是对象的动态属性 B、任何对象都必须有继承性
C、对象间的通讯靠消息传递 D、对象是属性和方法的封装体
140、编译并运行下面的程序，运行结果为：( )
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、程序可以编译运行，但没有输出
141、下面关于类的说法不正确的是：（ ）
A、类是 Java语言中的一种复合数据类型 B、类中不包含数据变量和方法
C、类是对所有具有一定共性的对象的抽象 D、Java语言的类只支持单继承
142、能作为类及其成员的修饰符是：（ ）
A、interface B、class C、protected D、public
143、设 x、y均为已定义的类名，下列声明对象x1的语句不可能正确的是：（ ）
A、public x xl=new y(); B、public y xl=new x();
C、x xl=new x(); D、x xl=x();
144、面向对象程序设计技术的特点是：（ ）
A、可重用性 B、可维护性
C、表示方法的一致性 D、可重用性、可维护性、表示方法的一致性
145、设已声明了一个类 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();
146、构造方法何时被调用（ ）
A、类定义时 B、使用对象的变量时 C、调用对象方法时 D、创建对象时
147、下列哪个类声明是正确的是（ ）
A、public abstract class Car{…} B、abstract private move(){…}
C、protected private number; D、abstract final class Hl{…}
148、下列不属于面向对象程序设计的基本特征的是：（ ）
A、抽象 B、封装 C、继承 D、静态
149、请看下面的程序段
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)
150、（ ）是一个特殊的方法，用于对类的实例变量进行初始化。
A、终止函数 B、构造函数 C、重载函数 D、初始化函数
151、关于变量和它们范围的说法，错误的是：（ ）
A、实例变量是类的成员变量
B、实例变量要用关键字 static来声明
C、在一个方法执行时，定义在该方法的局部变量才被创建
D、局部变量必须在它们使用前初始化
152、请看下面的程序段
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
153、请看下面的程序段
public class Test {
long a[ ] = new long[10];
public static void main(String arg[ ]) {
System .out .println(a[6]);
}
}
那一个选项是正确的：（ ）
A、不输出任何内容 B、输出0
C、当编译时有错误出现 D、当运行时有错误出现
154、关键字（ ）表明一个对象或变量在初始化后不能修改。
A、extends B、 final C、 this D、 finalizer
155、声明为 static的方法不能访问（ ）类成员。
A 、超类 B、 子类 C、 非static D、 用户自定义类
156、为了区分重载多态中同名的不同方法，要求：（ ）
A、参数名不同 B、返回值类型不同
C、采用不同的形式参数列表 D、选项A B C都对
157、在某个类中定义一个方法：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、都不能
158、下列对继承的说法，哪个是正确的：（ ）
A、子类只能继承父类 public方法和状态 B、子类能继承父类的非私有方法和状态
C、子类能继承父类的所有方法和状态 D、子类只能继承父类的方法，而不继承状态
159、定义类 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; }
160、下列说法正确的是：（ ）
A、Java中允许一个子类有多个父类
B、某个类是一个类的子类，它仍有可能成为另一个类的父类
C、一个父类只能有一个子类
D、继承关系最多不能超过 4层
161、下列说法正确的是：（ ）
A、子类只能覆盖父类的方法，而不能重载
B、子类只能重载父类的方法，而不能覆盖
C、子类不能定义和父类同名同形参的方法，否则，系统将不知道使用哪个方法。
D、重载就是一个类中有多个同名但不同形参和方法体的方法
162、关于构造函数的说法正确的是：（ ）
A、一个类只能有一个构造函数
B、一个类可以有多个不同名的构造函数
C、构造函数与类同名
D、构造函数必须自己定义，不能使用父类的所有构造函数
163、下面是有关子类调用父类构造函数的描述正确的是：（ ）
A、子类定义了自己的构造函数，就不会调用父类的构造函数
B、子类必须通过 super关键字调用父类有参数的构造函数
C、如果子类的构造没有通过 super调用父类构造函数， 那么子类会先调用子类自己的构造函数，再调用父类不含参数的构造函数。
D、创建子类的对象时，先调用子类自己的构造函数，然后调用父类的构造函数
164、声明为 final的变量不能在子类中覆盖，声明为（ ）和（ ）的方法是隐式的final。（ ）
A、public private B、private protected C、protected static D、static private
165、继承性使▁▁成为可能，它不仅节省开发时间，而且也鼓励人们使用已经验证无误和调 试过的高质量软件。（ ）
A、节省时间 B、软件复用 C、软件管理 D、延长软件生命周期
166、编译运行下面的程序，结果是（ ）。
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.println(“B”);
}
}
A、产生编译错误 B、代码可以编译运行，并输出结果：AB
C、代码可以编译运行，但没有输出 D、编译没有错误，但会产生运行时异常
167、已知类关系如下：
class Employee;
class Manager extends Employeer;
class Director extends Employee;
则以下语句正确的是： （ ）
A、 Employee e=new Manager(); B、 Director d=new Manager();
C、 Director d=new Employee(); D 、Manager m=new Director();
168．一个（ ）类的对象可以当作相应的（ ）类对象看待。（ ）
A、 子 系统 B、 用户 系统 C、 子 超 D、 超 用户
170、被声明为 private，protected及public的类成员，在类外部： （ ）
A、只能访问到声明为 public的成员 B、只可能访问到声明为protected和public的成员
C、都可以访问 D、都不能访问
171、现有两个类 A、B，以下描述中表示B继承自A的是（ ）
A、class A extends B B、class B implements A C、class A implements D、class B extends A
172、设类 B是类C的父类，下列声明对象x1的语句中不正确的是（ ）
A、C x1=new B()； B、B x1=new C()； C、C x1=new C()； D、B xl=new B()；
173、下面有关接口的说法，哪个是正确的（ ）
A、接口与抽象类是相同的概念 B、一个类不可实现多个接口
C、接口之间不能有继承关系 D、实现一个接口必须实现接口的所有方法
174、下列哪个不是属于接口用途的（ ）
A、通过接口可以实现不相关类的相同行为 B、通过接口可以指明多个类需要实现的方法
C、通过接口可以了解对象的交互界面 D、通过接口可以了解对象所对应的类
175、定义字符串 s：String s="Micrsoft公司"；执行下面的语句，char c=s.charAt(9);
c 的值为：（ ）
A、null B、 司 C、产生数组下标越界异常 D、公
176、虽然接口和抽象类不能创建对象，但它们的对象引用仍可指向该类型的对象。
这种说法（ ）
A、正确 B、不正确 C、不能确定 D、接口和抽象类不能说明其对象引用
177、下面哪个类包括 drawImage( )方法、drawString( )方法和setColor( )方法。 （ ）
A、java .awt .Applet B、java .awt .Image C、java .awt .Graphics D、java .util .Date
178、接口中说明了一组公共的抽象方法，其中（ ）包含公共的静态方法
A、可以 B、不可以 C、不能肯定 D、因静态方法不能被改写，故不能出现在接口中
179、接口是 Java面向对象的实现机制之一，以下说法正确的是： （ ）
A、Java支持多重继承，一个类可以实现多个接口
B、Java只支持单重继承，一个类可以实现多个接口
C、Java只支持单重继承，一个类只可以实现一个接口
D、Java支持多重继承，但一个类只可以实现一个接口
180、关于接口的定义和实现，以下描述正确的是： （ ）
A、接口定义中的方法都只有定义没有实现
B、接口定义中的变量都必须写明 final和static
C、如果一个接口由多个类来实现，则这些类在实现该接口中的方法时应采用统一的代码
D、如果一个类实现一个接口，则必须实现该接口中的所有方法，但方法未必声明为 public
181、下面的说法正确的是： （ ）
A、接口是 Java中的一个重要特点 B、在实现接口函数的时候要用关键字public
C、在继承一个类时，可以同时实现一个或者多个接口。 D、接口可以内嵌在一个类中
182、声明接口的保留字是（ ）
A、 interface B、 protect C 、final D、 static
183、下面关于 Vector类的说法不正确的是：（ ）
A、类 Vcetor在java.util包中
B、一个向量(Vcetor)对象存放的是一组有序的对象
C、一个向量(Vcetor)对象大小可以根据存放的元素个数的增加而自动增加
D、一个向量(Vcetor)对象中每个元素必须是相同类型的对象
184、下面的接口（类）定义正确的是：（ ）
A 、public class A {
private int x;
public getx() { return x; }
}
B、public abstract class A{ private int x;
public abstract int getx();
public int amethod()
{ return 0; }
}
C、public class A {
private int x;
public abstract int getx();
}
D、public interface Interfacea {
private int x;
public int getx() {
return x; }
}
185、接口具有下面的特性。（ ）
A、多重继承 B、不可继承 C、抽象性 D、嵌套
186、定义一个包的关键字是（ ）。
A、import B、 package C、 interface D、 protected
187、下列选项中，用于在程序开头引入包的关键字是（ ）。
A 、import B 、implements C、 integer D、 protected
188、以下语句输出的结果是（ ）。
System.out.println(Math.floor(-0.8));
A 、0 B、 -1 C、 -0.8 D、 0.8
189、下面的程序段执行后，变量 a、b、c的值分别是（ ）。
int a,b,c;
a=(int)Math.round(-4.51);
b=(int)Math.ceil(-4.51);
c=(int)Math.floor(-4.1);
A、 -5, -4, -5 B、 -4,-4,-5 C、 -5,-5,-5 D、 -4,-4,-4
190、下面说法不正确的是 （ ）
A、如果某公共的接口被声明在一个源文件中，则接口必须与源文件具有相同的名字
B、如果源文件包含 import语句，则该语句必须是除空行和注释行外的第一个语句行
C、如果某源文件包含 package语句，则该语句必须是第一个非空、非注释行
D、接口中的方法不一定是抽象方法，所以可以不用关键字 abstract修饰
191、在类定义的外部，可以被访问的成员有( )。
A、所有类成员 B、private或protected的类成员 C、public的类成员 D、public或private的类成员
192、现有类A和接口Ｂ，以下描述中表示类Ａ实现接口Ｂ的语句是( )。
A、 class Ａ implements B B、class B implements Ａ
C、 class Ａ extends B D、class B extends Ａ
193、针对Vector MyVector = new Vector(100,50)语句，下面语句中解释正确的是（ ）。
A、创建一个数组类对象MyVector，有100个元素的空间，每个元素的初值为50。
B、创建一个向量类对象MyVector，有100个元素的空间，每个元素的初值为50。
C、创建一个数组类对象MyVector，有100个元素的空间，若空间使用完时，以50
个元素空间单位递增。
D、创建一个向量类对象MyVector，有100个元素的空间，若空间使用完时，以50
个元素空间单位递增。
194、在Java中，存放字符串常量的对象属于（ ）类对象。
A、Character B、String C、StringBuffer D、Vector
195、下面语句对集合描述正确的是（ ）
A、 可以使开发人员的注意力集中到数据存储器上 B、 可以加速应用程序的开发
C、 是Java中预先定义好的类 D、B和C
二、填空题
1、方法重载实现多态时，要求 、 、 三个中的一个必须不同。
2、在Java语言中， 仅支持类间的_ 继承。
3、抽象方法只有 ，没有 的方法。
4、面向对象程序设计语言的三大特征是 、 和 。
5、用于创建类实例对象关键字是 。
6、JAVA中类成员的限定词有以下几种、private ,public , ， 其中， 的限定范围最大。
7、被关键字 修饰符的方法是不能被当前类的子类重新定义的方法
8、创建类的对象时，使用运算符 给对象分配类存空间
9、JAVA中所有类都是类 的子类
10、定义类的构造方法不能有返回值类型，其名称与 名相同
11、接口中的成员只有静态常量和 。
12、在子类中使用关键字 做前缀可以调用被子类覆盖的父类中的方法
13、关键字 用于导入包中的类到程序中，供程序使用
14、 方法是一种仅有方法头，没有具体方法体和操作实现的方法，该方法必须在抽象类之中定义. 方法是不能被当前类的子类重新定义的方法
15、在Java程序中，通过类的定义只能实现_____ __重继承，但通过接口的定义可以实现____ ___重继承关系。
16、当类未用访问权限修饰符（public或private）修饰时，java语言默认此类的访问权限是____ ____ ____
17、类是一组同种对象集合与抽象。即是具有相同 和 的一组对象集合。
18、一个类可以派生出 子类，但只允许有 个父类，而不允许存在 个父类。
19、 在Java中有两种方法实现多态，一种是使用方法的 实现多态，另一种是使用方法的 实现多态。
20、 Java中定义类必须使用关键字_ _作为标志，用__ __关键字声明该类将要实现哪些接口。
21、在java语言中通过 方法实现多继承问题。
22、接口是一种特殊的类，它只能定义 。
26、对于接口的实现，不可以构造一个接口对象，但可以声明一个接口 。
27、在JAVA语言中，所有的类都是直接或间接继承 类而得到的。
28、多态是指 。
29、如果子类中的某个变量的变量名与它的父类中的某个变量完全一样，则称子类中的这个变量_______了父类的同名变量。
30、 属性的隐藏是指子类重新定义从父类继承来的_____ _____。
31、 如果子类中的某个方法的名字、返回值类型和__ _____与它的父类中的某个方法完全一样，则称子类中的这个方法覆盖了父类的同名方法。
32、同一类中的不同对象具有相同的 和 。
34、java语言的接口是特殊的类，其中包含__ ____常量和____ ___方法。
35、 如果接口中定义了一个方法methodA()，一个属性attA，那么一个类ClassA要实现这个接口的话，就必须实现其中的 方法。
36、一个类如果实现一个接口，那么它就必须实现接口中定义的所有方法，否则该类就必须定义成__ ____的。
37、 Java仅支持类间的单重继承，接口可以弥补这个缺陷，支持___ __继承
38、 在方法头用abstract修饰符进行修饰的方法叫做____ ____方法。
39、Java语言中用于表示类间继承的关键字是___ ________。
40、Java语言中，表示一个类不能再被继承的关键字是__ ______。
41、创建类的对象时，使用运算符___ ________给对象分配内存空间。
42、同一个类中多个方法具有相同的方法名，不同的______ _______称为方法的重载。
43、通过类MyClass中的不含参数的构造方法，生成该类的一个对象obj，可通过以下语句实现
44、在java的接口中声明的成员变量全部是 ，声明的方法是 。
45、类及其 、 可以同时有一个以上的修饰符来修饰。
46、一个Java类可以有 个父类。
47、关于被私有保护访问控制符private protected修饰的成员变量， 可以被两种类来引用 、
48、abstract类中不可以有 的成员
49、abstract方法必须在 类中
50、 int是java的 ，Integer是java为int提供的封装类
51、如果源文件包含import语句，则该语句必须是 和 外的第一个语句行。
53、接口中的方法必定是 方法，但可以不用关键字 修饰。
54、在接口的定义中，定义的变量的修饰符是 ， 定义的方法修饰符是 。
55、接口中的成员只有静态常量和__ ____。
57、定义接口的关键字是 ，定义最终类的关键字是 ，定义抽象类的关键字是 。
58、表示数据或方法可以被同一包中的任何类或它的子类访问，即使子类在不同的包中也可以的修饰符是
59、表示数据或方法只能被本类访问的修饰符是
60、接口中方法的默认可见性修饰符是
61、为了区分类中重载的同名的不同方法，要求
63、有abstract方法的类一定是 或 。
64、带 的类不能继承。
65、一个类中可以使用不包含在任何方法体中的静态代码块 当类被载入时 静态代码块被执行 且只被执行 次。
66、引用父类中的成员变量用 ；引用当前的类或对象用 。
三、判断题
1、一个接口不可以继承其他接口。（ ）
2、一个类可以实现抽象类的所有方法，也可以只实现部分方法，但实现部分方法的类仍然是一个抽象类。（ ）
3、在实现接口的时候，要实现接口的所有方法。（ ）
4、抽象方法必须在抽象类中，所以抽象类中的方法都必须是抽象方法。（ ）
5、final类中的属性和方法都必须被final修饰符修饰。（ ）
6、最终类不能派生子类，最终方法不能被覆盖。（ ）
7、子类要调用父类的方法，必须使用 super关键字。（ ）
8、一个 Java类可以有多个父类。（ ）
9、如果 p是父类Parent的对象，而c是子类Child的对象，则语句c = p是正确的。（ ）
10、一个类如果实现了某个接口，那么它必须覆盖该接口中的所有方法。（ ）
11、接口是特殊的类，所以接口也可以继承，子接口将继承父接口的所有常量和抽象方法。（ ）
12、接口其实是一个特殊的 abstract class。（ ）
13、所谓数据封装就是将一组数据和与这一组数据有关的操作组装在一起，形成一个实体，这个实体也就是对象（ ）。
14、静态初始化器是构造方法加上static修饰符。（ ）
15、在定义一个类的时候，若想让类中的成员不能在类的外部访问，则必须在成员前面加上private修饰符。（ ）
16、类的静态成员所属于类所有，实例成员属于对象所有。( )
17、外部类能访问static变量( )
18、抽象类中不可以有非抽象的方法。 （ ）
19、程序在编译通过以后，仍然可能出现运行时错误和逻辑错误。 （ ）
20、可以在子类构造方法中通过this关键字调用基类的构造方法。 （ ）
21、由于Java中类只支持单重继承，所以一个类只能继承一个抽象类和实现一个接口。（ ）
22、内部类始终可以访问外部类。（ ）
23、对于一个抽象类，改变它的属性和方法一定会改变它所有子类的属性和方法。（ ）
24、对象可以赋值，只要使用赋值号（等号）即可，相当于生成了一个各属性与赋值对象相同的新对象（ ）
25、有的类定义时可以不定义构造方法，所以构造方法不是必需的( )
26、类及其属性、方法可以同时有一个以上的修饰符来修饰。( )
27、抽象方法必须在抽象类中，所以抽象类中的方法都必须是抽象方法 ( )
28、超类对象的集合通常比它的任何一个子类对象集合大。（ ）
29、子类可以从多个超类中派生出来。（ ）
30、Java中的类和接口都只支持单重继承。（ ）
31、Java程序里,创建新的类对象用关键字new，回收无用的类对象使用关键字free。 （ ）
32、由继承性可知，程序中子类拥有的成员数目一定大于等于父类拥有的成员数目。 （ ）
33、Java中Object类是最顶层的类。 （ ）
34、可以在子类构造函数中通过this关键字调用基类的构造函数。 （ ）
35、子类只能继续父类的非私有属性，不能继续父类的方法（ ）
36、子类能直接继续父类所有的非私有属性，也可通过接口继续父类的私有属性（ ）
37、抽象，封装，继承，多态是面向对象程序设计中得四个特点（ ）.
38、面向对象程序设计方法的优点是、可重用性，可扩展性，可管理性（ ）
39、class前的修饰符分为访问控制符和非访问控制符两大类.访问控制符包括public和private. （ ）
40、final类是最终类，是能有子类的类，abstract和final不能同时修饰一个类，因为抽象类本身没有具体对象（ ）
41、创建对象的格式为： 类名 对象名=new构造方法(参数);注意前面是类名后面是构造方法名。（ ）
42、构造方法没有返回类型，也不能写void，主要用于完成类对象的初始化工作，一般不能直接编程（ ）
43、如果class前面有public修饰符，则默认构造方法的前面也应该有public
修饰符. （ ）
44、类中有static修饰的域或方法，可用类名或对象名访问。 （ ）
45、类变量的最本质的特点是，他们是类的域，不属于任何一个类的具体对象实例，不是保存在某个对象实例的内存空间中，而是保存在类的内存区域的公共存储单元中。 （ ）
46、用static修饰的变量或方法都为类成员，类成员可以用类名或实例名访问，实例成员只能用实例名来访问。（ ）
47、如果一个类中含有抽象方法，则此类必须为抽象类，如果抽象类的子类不为抽象类，则子类必须实现父类的所有抽象方法。（ ）
48、this变量用在一个方法的内部，指向当前对象，当前对象指的是调用当前正在执行的方法的那个对象。super变量是直接指向父类的构造方法，用来引用父类中的变量和方法。由于他们指的是对象，所以不能通过它来引用类变量和类方法（ ）
49、访问修饰符、类中限定为public的成员可以被所有的类访问。（ ）
50、类中限定为protected的成员可以被这个类本身，它的子类(包括同一个包中和不同包中的子类)，以及同一个包中的其他类访问。（ ）
51、abstract和private，static，final，native能并列修饰同一个方法。（ ）
52、abstract类中不能有private修饰的域和方法（ ）
53、abstract修饰符可修饰字段、方法和类（ ）
54、在类方法中可用this来调用本类的类方法（ ）
55、在类方法中调用本类的类方法时可直接调用（ ）
56、 在类方法中只能调用本类中的类方法（ ）
57、 在类方法中绝对不能调用实例方法（ ）
58、Java面向对象语言容许单独的过程与函数存在（ ）
59、Java面向对象语言容许单独的方法存在（ ）
60、Java语言中的方法必定隶属于某一类（对象），调用方法与过程或函数相同（ ）
61、Java程序中的起始类名称必须与存放该类的文件名相同。（ ）
62、数组是一种对象（ ）
63、数组属于一种原生类（ ）
64、constructor必须与class同名，但方法不能与class同名（ ）
65．Java的类分为两大量、系统定义的类和用户自定义的类（ ）
66、类的静态属性和全局变量的概念完全一样，只是表达形式不同（ ）
67、类的成员至少有一个属性和一个方法（ ）
68、类是对象的实例化（ ）
69、一个类的构造方法可以有多个（ ）
70、子类不能继续父类的私有属性 （ ）
71、 构造方法只能由对象中的其它方法调用（ ）
72、构造方法可以用于给类的 private实例变量赋值。（ ）
73、对象一经声明就可以立即使用。（ ）
74、在定义变量和方法时，必须清楚地在其面前标上访问权限修饰符。（ ）
75、Java程序中的参数传递都是把参数值传递给方法定义中的参数。（ ）
76、在类定义中，成员访问权限修饰符不能多次出现。（ ）
77、new操作符动态地为对象按其指定的类型分配内存，并返回该类型的一个引用。（ ）
78、类的方法通常设为 public，而类的实例变量一般也设为public。（ ）
79、构造方法在创建对象时被调用。（ ）
80、通过点运算符与类对象的引用相连，可以访问此类的成员。（ ）
81、声明为 protected的类成员只能被此类中的方法访问。（ ）
82、同一个类的对象使用不同的内存段，但静态成员共享相同的内存空间。（ ）
83、类的成员变量可以放在类体的任意位置。（ ）
84、声明为 protected的类成员可以被此类作用域中的任何对象访问。（ ）
85、没有返回值的方法可以用 void来表示，也可以不加。（ ）
86、不需要定义类，就能创建对象。（ ）
87、在子类中可以用完全相同的 signature重新定义一个超类方法，这称为方法的覆盖
（override）。（ ）
88、final修饰的方法是不能被子类覆盖的，只能被覆盖。（ ）
89、声明为 final的类不能是超类。（ ）
90、当一个超类成员不适合该子类时，子类会以恰当的方式重新定义它。（ ）
91、对子类实例化对象需要调用超类的构造函数进行初始化工作， 完成对子类中的超类实例变量 的初始化，则子类可以继承超类的构造函数。（ ）
92、在类的定义中如果不明确给出超类，那么默认超类就是 Object类。（ ）
93、protected类型的实例变量或方法只能由声明该变量或方法的类本身及其子类访问。（ ）
94、Java的每个子类的构造函数都要显式的调用它的直接超类的构造函数。（ ）
95、抽象方法不能是静态方法和最终方法。（ ）
96、抽想方法只有方法头的声明，而用分号来替代方法体，没有大括号。（ ）
101、接口中的所有方法都没有被实现 （ ）
102、实现一个接口，则在类中一定要实现接口中的所有方法。 （ ）
103、类体中private修饰的变量在本类中能访问，类生成的对象也能访问。 （ ）
104、抽象类不能实例化 （ ）
105、一个方法最多能有一个return语句 （ ）
106、在Java程序中，通过类的定义只能实现单重继承 （ ）
107、类A和类B位于同一个包中，则除了私有成员，类A可以访问类B的所有其他成员 （ ）
108、一个类中，只能拥有一个构造器方法 （ ）
109、可以用new来创建一个类的实例，即"对象"。（ ）
110、类的public类型的成员变量不可以被继承。（ ）
111、子类可以继承父类所有的成员变量及成员函数。（ ）
112、Java类中不能存在同名的两个成员函数。（ ）
113、对象是类的一个实例。 （ ）
114、类的public类型的成员变量不可以被继承。（ ）
115、用abstract修饰的类必须被继承。 （ ）
四、编程题
实现一个宠物商店，在宠物商店中可以有多种(由用户确定数量)宠物，试表示出此种关系，并要求可以根据宠物的关键字查找到相应的宠物信息。所需要的宠物信息自行设计。宠物的创建由工厂来完成。创建宠物管理类，使用数组来保存宠物，实现宠物的添加，删除，修改，查询，打印功能。
376
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
