第3章    Java语言面向对象基础
习  题  三

一、填空题
1．类是一组具有相同（属性）和（行为）的对象的抽象。（实例）是由某个特定的类所描述的一个个具体的对象。
2．（接口）只描述系统所提供的服务，而不包含服务的实现细节。
3．模型应具有（抽象性）、（可理解性）、（精确性）、（确定性）和廉价性等基本特性。
4．UML定义了（用例图）、（静态图）、（交互图）、行为图和实现图五类模型图。
5．在UML类图中分别用（ + ）、（ # ）、（ ~ ）和（ - ）表示属性与方法的公有、保护、默认和私有访问控制权限。
6．在UML中，类之间主要有（关联）、（依赖）、（聚集）、（泛化）和实现五种关系。
7．构造方法的方法名与（类名）相同，若类中没有定义任何的构造方法，则运行时系统会自动为该类生成一个（默认构造）方法。
8．在方法体内定义的变量是（局部变量），其前面不能加（public），且必须（初始化）。
9．数组元素作实参时对形参变量的数据传递是（单向值传递），数组名作实参时对形参变量的数据传递是（双向引用传递）。
10．对象作方法形参时，方法实参也用对象，实现（引用）调用。
11．（ new）是一个特殊的方法，用于创建一个类的实例。
12．对象拷贝有（对象引用复制）、（浅复制）和（深复制）三种。
13．（类）方法不能直接访问其所属类的（实例）变量和（实例）方法，只可直接访问其所属类的（类）变量和（类）方法。
14．（类）变量在内存中只有一个拷贝，被该类的所有对象共享；每当创建一个实例，就会为（实例）变量分配一次内存，（实例）变量可以在内存中有多个拷贝，互不影响。
15．Java使用固定于首行的（package）语句来创建包。
16．在运行时，由java解释器自动引入，而不用import语句引入的包是（java.lang）。
17．发布Java应用程序或类库时，通常可以使用JDK中自带的（JAR）命令打包。

二、简答题
1．名词解释：OO、OOSE、OOA、OOD、OOP；抽象、对象、类、实例、方法、属性、消息、接口、封装、继承、多态性；模型、UML、类图、对象图、用例图、顺序图、协作图、状态图、活动图、包图、构件/组件图、部署图。
2．简述面向对象的基本思想、主要特征和基本要素。
3．为什么要对类进行封装？封装的原则是什么？
4．类的封装性、继承性和多态性各自的内涵是什么？
5．简述依赖、关联和聚集的区别。
6．什么是对象？什么是类？二者有何关系？
7．Java中类定义的一般格式是什么？定义类的修饰符有哪些？各自的特点是什么？
8．Java中成员变量定义的一般格式是什么？成员变量有哪些修饰符？
9．Java中成员方法定义的一般格式是什么？成员方法有哪些修饰符？
10．简述构造方法的特点与作用。
11．Java中创建对象的一般格式是什么？如何初始化对象？如何给对象赋值？
12．什么是类变量（静态变量）？什么是实例变量？它们的存储特性、访问方法、主要区别是什么？
13．什么是类方法（静态方法）？什么是实例方法？它们的存储特性、访问方法、主要区别是什么？
14．什么是包？如何创建包？如何引用包？
15．Import语句和package语句的功能分别是什么?
16．举例说明JAR包的创建、加载与运行方法。

三、选择题
1．下面关于封装性的描述中，错误的是（ D ）。
A．封装体包含属性和行为        B．被封装的某些信息在外不可见
C．封装提高了可重用性          D．封装体中的属性和行为的访问权限相同

2．下面关于类方法的描述，错误的是（ B ）。
A．说明类方法使用关键字static   B．类方法和实例方法一样均占用对象的内存空间
C．类方法能用实例和类名调用    D．类方法只能处理类变量或调用类方法

3．下面关于包的描述中，错误的是（ A ）。
A．包是若干对象的集合        B．使用package语句创建包
C．使用import语句引入包       D．包分为有名包和无名包两种

◆◆◆ 4．下述哪些说法是正确的？（ BCD ）
A．用static关键字声明实例变量      B．实例变量是类的成员变量
C．局部变量在方法执行时创建     D．局部变量在使用之前必须初始化

5．下面哪些代码段是正确的Java源程序？（ BCD ）
A．import java.io.*;                    B．import java.io.*;
package testpackage;                    class Person{}
public class Test{}      public class Test{}
C．import java.io.*;                    D．package testpackage;
import java.awt.*;                      public class Test{}
public class Test{}

四、判断题
1．类是一种类型，也是对象的模板。（ √ ）
2．类中说明的方法可以定义在类体外。（ × ）
3．实例方法中不能引用类变量。（ × ）
4．创建对象时系统将调用适当的构造方法给对象初始化。（ √ ）
5．使用运算符new创建对象时，赋给对象的值实际上是一个引用值。（ √ ）
6．对象赋值实际上是同一个对象具有两个不同的名字，它们都有同一个引用值。（ √ ）
7．对象可作方法参数，对象数组不能作方法参数。（ × ）
8．class是定义类的惟一关键字。（ √ ）
9．Java语言会自动回收内存中的垃圾。（ √ ）

五、分析题
◆◆◆ 分析下面的程序，写出运行结果。
import java.awt.*;
import java.applet.*;
class MemberVar {
    static int sn = 30;
    final int fn;
    final int fk = 40;
    MemberVar() {
        fn = ++sn;
    }
}
public class Exercises5_1 extends Applet {
    public void paint(Graphics g) {
           MemberVar obj1 = new MemberVar();
          MemberVar obj2 = new MemberVar();
          g.drawString("obj1.fn=" + obj1.fn, 20, 30);
          g.drawString("obj1.fk=" + obj1.fk, 20, 50);
          g.drawString("obj2.fn=" + obj2.fn, 20, 70);
           g.drawString("obj2.fk=" + obj2.fk, 20, 90);
    }
}
运行结果是：（       ）
obj1.fn=33
obj1.fk=40
obj2.fn=34
obj2.fk=40

六、改错题
1．下面的程序中有若干个语法错误，找出后请改正。
public class MyMainClass{
public static void main(  )    {
        TheOtherClass obj = new TheOtherClass("John Smith","Male","UK");
        System.out.println(obj.name+' '+obj.gender+' '+obj.nationality);
}
System.out.println("The end of the program! ")
}
public class TheOtherClass{
        private String name,gender,nationality;
        public TheOtherClass(String name,String gender,String nationality)    {
            this.name=name;
            this.gender=gender;
            this.nationality=nationality;
}
}
改正后程序：
public class MyMainClass {
    public static void main(String args[]) {
        TheOtherClass obj = new TheOtherClass("John Smith", "Male", "UK");
        System.out.println(obj.name + ' ' + obj.gender + ' ' + obj.nationality);
        System.out.println("The end of the program! ");
    }
}
class TheOtherClass {
    public String name, gender, nationality;
    public TheOtherClass(String name, String gender, String nationality) {
        this.name = name;
        this.gender = gender;
        this.nationality = nationality;
    }
}

2．下面的程序中有若干个语法错误，找出后请改正。
public class Car{
            private String carName;
            public int mileage;
            private static final int TOP_SPEED=50;
            abstract void alert();
            public static int getTopSpeed(){
                return TOP_SPEED;
}
public static void setCarName(){
        carName="Bensi";
}
public static void setMileage(){
        mileage=180;
}
}
改正后程序：
public abstract class Car {
    private String carName;
    public int mileage;
    private static final int TOP_SPEED = 50;
    abstract void alert();
    public static int getTopSpeed() {
        return TOP_SPEED;
    }
    public void setCarName() {
        carName = "Bensi";
    }
    public void setMileage() {
        mileage = 180;
    }
}

七、编程题
1．设计（用UML的类图表示）并实现一点类Point，该类的构成包括点的x和y两个坐标，其构造方法、设置和修改坐标、求解两点距离的方法等，编写应用程序生成该类的对象并对其进行操作。

2．设计（用UML的类图表示）并实现一个矩形类Rectangle，包括其构造方法、求解矩形面积和周长的方法等，实例化后输出相应的信息。

3．计算出Fibonacci数列的前n项，Fibonacci数列的第一项和第二项都是1，从第三项开始，每项的值都是该项的前两项之和。即：
F(n) = F (n-1) + F(n-2)          n≥3
F(1) = F(2) = 1                 n=1,2

4．参照“图3-4”实现Student类的定义，然后生成该类的对象后进行相关操作。




第4章   Java语言面向对象高级程序设计
习  题  四

一、填空题
1．在面向对象系统中，消息分为（公有消息）和（私有消息）两类。
2．类的访问控制符有（public）和（默认default）两种，（public）类具有跨包访问性而（default）类不能被跨包访问。
3．类成员的访问控制符有（public）、（protected）、（private）和默认四种。
4．public类型的类成员可被（同一类）、同一包中的（子类与非子类）和不同包中的 （子类与非子类）的代码访问引用。
5．protected类型的类成员可被（同一类）、同一包中的（子类与非子类）和不同包中的（子类）的代码访问引用。
6．default类型的类成员只能被（同一类）、同一包中的（子类与非子类）的代码访问引用。
7．private类型的类成员只能被其所在类中的代码访问引用，它只具有（类）域访问性。
8．系统规定用（this()）表示当前类的构造方法，用（super()）表示直接父类的构造方法，在构造方法中两者只能选其一，且须放在第一条语句。
9．若子类和父类在同一个包中，则子类继承父类中的（public）、（protected）和（默认）成员，将其作为子类的成员，但不能继承父类的（private）成员。
10．若子类和父类不在同一个包中，则子类继承了父类中的（public）和（protected）成员，将其作为子类的成员，但不能继承父类的（默认）和（private）成员。
11．（子类对象）直接赋值给（父类对象）时，子类对象可自动转换为父类对象，（父类对象）赋值给（子类对象）时，必须将父类对象强制转换为子类对象。
12．Java的多态性主要表现在（方法重载）、（方法覆盖）和（变量覆盖）三个方面。
13．重写后的方法不能比被重写的方法有（更严格）的访问权限，重写后的方法不能比被重写的方法产生更多的异常。
14．Java语言中，定义子类时，使用关键字（extends）来给出父类名。如果没有指出父类，则该类的默认父类为（Object类）。
15．Java语言中，重载方法的选择是在编译时进行的，系统根据（参数个数）、（参数类型）和参数顺序寻找匹配方法。
16．实现接口中的抽象方法时，必须使用（完全相同）的方法头，并且还要用（public）修饰符。
17．接口中定义的数据成员均是（常量数据成员），所有成员方法均为（抽象方法）方法，且没有（构造）方法。
18．this代表（当前对象自身）的引用，super表示的是当前对象的直接父类对象。
19．如果一个类包含一个或多个abstract方法，则它是一个（abstract）类。
20．Java不直接支持多继承，但可以通过（接口）实现多继承。类的继承具有（传递）性。
21．没有子类的类称为（最终类），不能被子类重载的方法称为（最终方法），不能改变值的量称为常量，又称为（最终变量）。
22．一个接口可以通过关键字extends来继承（多个）其他接口。
23．接口中只能包含（public static final）类型的成员变量和（public abstract）类型的成员方法。
24．一般地，内部类又分为定义在方法体外的（成员类）和定义在方法体内的（局部类）两种。
25．静态内部类可直接通过外部类名引用，其一般格式是（new 外部类名.内部类构造方法( );）。
26．匿名类一般分为（语句匿名类）和（参数匿名）类两种。
27．面向对象的软件设计中，根据目的不同模式可分为（创建型）、（结构型）和（行为型）三种。

二、简答题
1．什么是继承？什么是父类？什么是子类？继承的特性可给面向对象编程带来什么好处？什么是单继承？什么是多重继承？
2．如何创建一个类的子类？
3．若在一个public类中的成员变量及成员方法的访问控制符为protected，则此类中的成员可供什么样的包引用？
4．什么是多态？使用多态有什么优点？Java中的多态有哪几种？重载方法与覆盖方法分别属于哪种多态？
5．什么是重载方法？什么是覆盖方法？它们的主要区别是什么？
6．什么是成员变量的继承？什么是成员变量的覆盖？
7．举例说明什么是上转型对象，上转型对象的操作原则是什么？
8．简述接口定义的一般格式。
9．什么是接口？如何定义接口？接口与类有何区别？
10．一个类如何实现接口？实现某接口的类是否一定要重载该接口中的所有抽象方法？
11．比较接口与抽象类的异同。
12．什么是抽象类？什么是抽象方法？各自有什么特点？
13．什么是最终类？什么是最终变量？什么是最终方法？
14．简述内部类的类型。
15．简述在外部类的内部与外部对实例成员类实例化的方法。
16．简述定义语句匿名类和参数匿名的一般格式。
17．什么是适配器模式？什么是装饰模式？

三、选择题
1．下面关于类的继承性的描述中，错误的是（ C ）。
A．继承是在已有的基础上生成新类的一种方法
B．Java语言要求一个子类只有一个父类
C．父类中成员的访问权限在子类中将被改变
D．子类继承父类的所有成员，但不包括私有的成员方法

2．在成员方法的访问控制修饰符中，规定访问权限包含该类自身，同包的其他类和其他包的该类子类的修饰符是（ B ）。
A．默认         B．protected      C．private          D．public

3．在类的修饰符中，规定只能被同一包类所使用的修饰符是（ B ）。
A．public        B．默认          C．final           D．abstract

4．下列关于子类继承父类的成员描述中，错误的是（ C ）。
A．当子类中出现成员方法头与父类方法头相同的方法时，子类成员方法覆盖父类中的成员方法。
B．方法重载是编译时处理的，而方法覆盖是在运行时处理的。
C．子类中继承父类中的所有成员都可以访问。
D．子类中定义有与父类同名变量时，在子类继承父类的操作中，使用继承父类的变量；子类执行自己的操作中，使用自己定义的变量。

5．定义一个类名为“MyClass.java”的类，并且该类可被一个工程中的所有类访问，则下面哪些声明是正确的？（ AB ）
A．public class MyClass extends Object        B．public class MyClass
C．private class MyClass extends Object       D．class MyClass extends Object

6．下列关于继承性的描述中，错误的是（ C ）。
A．一个类可以同时生成多个子类    B．子类继承了父类中除私有的成员以外的其他成员
C．Java支持单重继承和多重继承    D．Java通过接口可使子类使用多个父类的成员

7．下列关于抽象类的描述中，错误的是（ C ）。
A．抽象类是用修饰符abstract说明的       B．抽象类是不可以定义对象的
C．抽象类是不可以有构造方法的        D．抽象类通常要有它的子类

8．设有如下类的定义：
public class parent {
int change() {}
}
class Child extends Parent { }
则，下面哪些方法可加入Child类中？（ AB ）
A．public int change(){ }             B．int chang(int i){ }
C．private int change(){ }                D．abstract int chang(){ }

9．下列关于构造方法的叙述中，错误的是（ D ）。
A．构造方法名与类名必须相同        B．构造方法没有返回值，且不用void声明
C．构造方法只能通过new自动调用     D．构造方法不可以重载，但可以继承

10．下面叙述中，错误的是（ C ）。
A．子类继承父类  B．子类能替代父类  C．父类包含子类   D．父类不能替代子类

11．下列对多态性的描述中，错误的是（ B ）。
A．Java语言允许方法重载与方法覆盖     B．Java语言允许运算符重载
C．Java语言允许变量覆盖               D．多态性提高了程序的抽象性和简洁性

12．下面关于接口的描述中，错误的是（ A ）。
A．一个类只允许继承一个接口    B．定义接口使用的关键字是interface
C．在继承接口的类中通常要给出接口中定义的抽象方法的具体实现
D．接口实际上是由常量和抽象方法构成的特殊类

13．欲构造ArrayList类的一个实例，此类继承了List接口，下列哪个方法是正确的？（ C ）
A．ArrayList myList=new Object();        B．ArrayList myList=new List();
C．List myList=new ArrayList();           D．List myList=new List();

14．下列哪些方法与方法public void add(int a){}为合理的重载方法？（ ACD ）
A．public void add(char a)              B．public int add(int a)
C．public void add(int a,int b)            D．public void add(float a)

◆◆◆ 15．MAX_LENGTH是int型public成员变量，变量值保持为常量100，其定义是（ BC ）。
A．public int MAX_LENGTH=100;         B．final public int MAX_LENGTH=100;
C．public final int MAX_LENGTH=100;     D．final int MAX_LENGTH=100;

四、判断题
1．Java语言中，构造方法是不可以继承的。（ √ ）
2．子类的成员变量和成员方法的数目一定大于等于父类的成员变量和成员方法的数目。（ × ）
3．抽象方法是一种只有说明而无具体实现的方法。（ √ ）
4．Java语言中，所创建的子类都应有一个父类。（ √ ）
5．调用this 或super构造方法的语句必须放在第一条语句。（ √ ）
6．一个类可以实现多个接口，接口可以实现“多重继承”。 （ √ ）
◆◆◆ 7．实现接口的类不能是抽象类。（ × ）
◆◆◆ 8．使用构造方法只能给实例成员变量赋初值。（ × ）
9．Java 语言不允许同时继承一个类并实现一个接口。（ × ）

五、分析题
◆◆◆ main少static  1．分析下面的程序，写出运行结果。
public class Exercises6_1 extends TT{
　　　　public void main(String args[]){
　　　　Exercises6_1 t = new Exercises6_1("Tom");
　　　}
　　　public Exercises6_1(String s){
　　　　super(s);
　　　　System.out.println("How do you do?");
　　　}
　　　public Exercises6_1(){
　　　　this("I am Tom");
　　　}
　　}
　　class TT{
　　　　public TT(){
　　　　　System.out.println("What a pleasure!");
　　　　}
　　　　public TT(String s){
　　　　　this();
　　　　　System.out.println("I am "+s);
　　　　}
　　}
运行结果是：（    原题是没有结果的，无法执行          ）
What a pleasure！
I am Tom
How do you do？

2．分析下面的程序，写出运行结果。
public class Exercises6_2 {
        private static int count;
        private String name;
        public class Student {
            private int count;
            private String name;
            public void Output(int count) {
                count++;
                this.count++;
                Exercises6_2.count++;
                Exercises6_2.this.count++;
                System.out.println(count + " " + this.count + " "
                        + Exercises6_2.count + " " + Exercises6_2.this.count++);
            }
        }
        public Student aStu() {
            return new Student();
        }
        public static void main(String args[]) {
            Exercises6_2 g3 = new Exercises6_2();
            g3.count = 10;
            Exercises6_2.Student s1 = g3.aStu();
            s1.Output(5);
        }
}
运行结果是：（               ）
6 1 12 12

3．分析下面的程序，写出运行结果。
class Exercises6_3 {
        class Dog {
            private String name;
            private int age;
            public int step;
            Dog(String s, int a) {
                name = s;
                age = a;
                step = 0;
            }
            public void run(Dog fast) {
                fast.step++;
            }
        }
        public static void main(String args[]) {
            Exercises6_3 a = new Exercises6_3();
            Dog d = a.new Dog("Tom", 3);
            d.step = 29;
            d.run(d);
            System.out.println(" " + d.step);
        }
}
运行结果是：（            ）
30

4．分析下面的程序，写出运行结果。
class Aclass {      void go() { System.out.println("Aclass");  }  }
public class Bclass extends Aclass {
    void go() { System.out.println("Bclass"); }
public static void main(String args[]) {
          Aclass a = new Aclass();
          Aclass a1 = new Bclass();
          a.go();
          a1.go();
}  }
运行结果是：（           ）
Aclass
Bclass

六、改错题
1．找出下面代码的错误部分，说明错误类型及原因，并更正之。
public class Car {
  private String carName;
  public int mileage;
  private static final int TOP_SPEED = 200;
  abstract void alert();
  public static int getTopSpeed() {
    return TOP_SPEED;
  }
  public static void setCarName() {
    carName = "奥迪";
  }
  public static void setMileage() {
    mileage = 180;
  }
}
错误：因为含有抽象方法的类，必须是抽象类；静态方法只能访问静态成员。
更正：
public abstract class Car {
    private String carName;
    public int mileage;
    private static final int TOP_SPEED = 200;
    abstract void alert();
    public static int getTopSpeed() {
        return TOP_SPEED;
    }
    public void setCarName() {
        carName = "奥迪";
    }
    public void setMileage() {
        mileage = 180;
    }
}


2．下列代码不能编译的原因是：（     ）。
class A {
    private int x;
    public static void main(String args[]) {  new B(); }
    class B {  B() {System.out.println(x);  }
    }
}
因为在A类的main方法中,还没有A的实例就要试图生成内部类的实例。
更正如下：
public class A {
    private int x;
    public static void main(String args[]) {
        A a = new A();
        a.new B();
    }
    class B {
        B() {
            System.out.println(x);
        }
    }
}

七、编程题
1．先在一个包中编写第一个类ClassA，要求该类中具有四种不同访问权限的成员，再在另一个包中编写第二个类ClassB，并在该类中编写一个方法以访问第一个类中的成员。总结类成员访问控制的基本规则。
2．设计一个汽车类Car，实现构造方法的重载，然后利用这些构造方法，实例化不同的对象，输出相应的信息。
3．设计一个乘法类Multiplication，在其中定义三个同名的mul方法：第一个方法是计算两个整数的积；第二个方法是计算两个浮点数的积；第三个方法是计算三个浮点数的积。然后以Java Applet程序方式调用这三个同名的方法mul，输出其测试结果。
4．已知编一个抽象类AbstractShape如下所示：
abstract class AbstractShape {
    final double PI=3.1415926;
            public abstract double getArea();
    public abstract double getGirth();
}
请编写AbstractShape类的一个子类，使该子类实现计算圆面积方法getArea()和周长的方法getGirth()。
5．按下列要求编程：
（1）编写一个抽象类，至少有一个常量和一个抽象方法。
（2）编写二个抽象类的子类，重写定义抽象类中的抽象方法。
（3）编写一个主类使用3个类，进行某种运算。
6．设计一个形状Shapes接口，在其中定义计算面积的getArea( )方法和求周长的getPerimeter( )方法，然后设计一个Circle类以实现Shapes接口中的两个方法，最后以Java Application程序方式测试前述接口及其实现类，输出其测试结果。
7．使用继承和接口技术，编写一个程序，求解几何图形（如直线、三角形、矩形、圆和多边形）的周长和面积。
8．使用继承和接口技术，编写一个程序，求解一元多次方程（如一元一次、一元二次和一元高次方程）的解。
9．使用内部类技术构造一个线性链表。
10．参照例4-30以组合方式创建某类的适配器。