习题6
一、判断题
1.父类的引用变量可以指向它的子类的对象。                                    （√）
2.Java语言中从一个父类可以派生出多个子类，一个子类可以有多个父类。          （×）
3.在构造方法中如调用super()，则必须使其为该构造方法的第一句。                （√）
4.Java语言中的接口可以继承，一个接口通过关键字extends可以继承另一个接口，一个Java的类可以通过关键字implements实现多个接口。                                  （√）
5.Math类是final类，因此在被其他类继承时其中的方法不能被重写。                （×）
二、选择题
1.下列说法中，正确的是（A）。
A.类是变量和方法的集合体              B.数组是无序数据的集合
C.抽象类可以实例化                    D.类成员数据必须是共有的
2.下面对形参的说法中，正确的是（C）。
A.必须有多个                          B.至少有一个
C.可以没有                            D.只能是简单变量
3.调用构造方法是在（B）。
A.类定义时                            B.创建对象时
C.调用对象方法时                      D.使用对象的变量时
4.下列对继承的说法，正确的是（B）。
A.子类能继承父类的所有方法和状态
B.子类能继承父类的非私有方法和状态
C.子类只能继承父类public方法和状态
D.子类只能继承父类的方法，而不能继承其状态
5.下列接口的定义中，正确的是（D）。
A． interface a{                      B. interface a{
            int I；                            int I=I；
            void g(){}}                        void g(){}}
C． interface a{                      D. interface a{
            int I;                            int I=5；
            protected void g()；}                void g();}
6.一个类可以同时继承或实现（D）个接口。
A．1      B.2        C.3        D.任意
7.下面有关接口的说法，正确的是（D）。
A.接口与抽象类是相同的概念
B.实现一个接口必须实现接口的所有方法
C.接口之间不能有继承关系
D.一个类可以实现多个接口
8.Java语言的多态现象，主要表现在（A）两个方面。
A．方法重载和成员覆盖      B.方法重载和抽象对象
C.抽象对象和成员覆盖        D.创建接口和方法继承
9.Java语言的多态性的实现主要有（B）两种方式。
A.设计时和运行时          B.编译时和运行时
C.设计时和编译时          D.编译时和存储时
三、填空题
1.面向对象程序设计方法最重要的特性是  继承性  、  封装性  和  多态性  。
2.  构造方法  是一个特殊的方法，是为对象初始化操作编写的方法，用它来定义对象的初始状态。
3.为了不允许其他子类  继承  ，简单数据类型的包装类都被声明为    final  。
4．在Java方法体内中指向当前对象的引用是 this ，指向父类对象的引用是  super 。
5.Java中  Object  类是Java中的终极超类，即唯一没有父类的类。
四、简答题
1.谈谈你对面向对象程序设计的理解。
答：(1)首先需要将客观存在的实体抽象成概念世界中的抽象数据类型，其中包括相关的属性和方法；
(2)用面向对象的工具将该抽象数据类型用计算机逻辑表达出来；
(3)最后再将类实例化得到了现实世界中的实体在计算机世界中的映射——对象。
2.什么是类？什么是对象？他们之间的关系是怎样的？
答：类是一种复杂的数据类型，不仅包含数据，还包含对数据进行操作的方法；
对象是显示世界中事物的抽象表示。
类是具有相同或相似性质的对象的抽象。
3.Java设置了几种类成员的访问权限？各表示什么含义？
答：（1）公有的（public）：说明该类成员可被所有类的对象使用
（2）保护的（protected）：说明该类成员能被同一类中的其他成员，或其他子类成员，或同一包中的其他类访问，不能被其他包的非子类访问。
（3）默认的（缺省）：说明该类成员能被同一类中的其他成员，或同一包中的其他类访问，但不能被其他包的类访问。
（4）私有的（private）：说明该类成员只能被同一类中的其他成员访问，不能被其他类的成员访问，也不能被子类成员访问。
4.为什么要将类封装起来？封装的原则是什么？
答：因为封装的类之间互相独立、互不干扰，但可以通过规定的数据接口来进行数据交换，即能保证数据的安全又能提高类之间相互组合的高效性。
一、将数据和对数据的操作组合起来构成类，类是一个不可分割独立单位。
二、类中既要提供与外部联系的方法，同时又要尽可能隐藏类的实现细节和保护自身数据的安全性。
5.什么是继承？什么是多态？方法的重载和覆盖有什么区别？
答：继承：由已有的类创建新类，从而自动实现类中方法和数据共享。
多态：同一名字的方法可以有多种实现，具有完全不同的执行效果或呈现出不同的执行结果状态。
方法的重载：在同一个类中，相同的方法名对应着不同的方法体，方法的参数也不相同。方法重载表现为同一个类中方法的多态性，一个类中可以定义多个参数不同的同名方法，属于编译时多态性。
方法的覆盖：在子类中重定义父类的同名方法。方法覆盖表现为父类与子类之间的方法的多态性，其中形参表、返回值类型也必须相同，且子类方法不能有比父类方法更严格的访问权限。可以为编译时多态性或运行时多态性。
6.什么叫构造方法？构造方法的作用是什么？
答：构造方法是对象实例化时完成对象及其成员变量的初始化时所调用的一种特殊的方法。
构造方法的作用是在使用new关键字创建类的实例的时候被调用来对实例进行初始化。
7．构造方法是否可以被继承？是否可以被重载？试举例
答：构造方法不能够被继承，因为父类构造方法创建的是父类对象，子类必须声明自己的构造方法，创建子类自己的对象。
构造方法可以被重载。例：
public C_Date()
{
          year=1900;
}
Public C_Date(int y,int m,int d)
{
      year=y;
      month=m;
      day=d;
}
该类中构造方法C_Date重载。
8.什么是变量的隐藏？什么是方法的覆盖？二者有何区别？
答：变量的隐藏：子类重定义了与父类同名的成员变量；
    方法的覆盖：子类重定义了与父类中同名的成员方法，子类方法的参数列表和返回值类型与父类的参数列表以及返回值类型完全相同。
9.什么是接口？接口与抽象类有什么区别？
答：接口是一种特殊的数据类型（引用数据类型），主要用于描述某一行为功能所包含的行为方法的基本概况，即方法的名称、返回值类型以及形参表等，是一组常量和抽象方法的集合。
10.什么是编译时多态性？什么是运行时多态性？
答：编译时多态性：多个同名方法在编译时能够确定执行的是哪一个。
    运行时多态性：在编译时不能确定、只有在运行时才能确定执行多个同名方法的哪一个。
五、编程题
1.考虑设计一个绘图工具的面向对象描述，写出代码框架，充分应用抽象、多态等方法。
class Draw_Graph
{
    double line;
    double circle;
    //定义构造方法
    public Draw_Graph()
    {
        line=0;
        circle=0;
    }
    //构造方法重载
    public Draw_Graph(double L,double R)
    {
        line=L;
        circle=R;
    }
    //获取直线长度
    public void getLine(double L)
    {
        System.out.println("作一长度为"+L+"的直线：选择起点>>>选择方向>>>确定");
    }
    //实例方法重载，获取圆的半径
    public void getCircle(double R)
    {
        System.out.println("作一半径为"+R+"的圆：选择圆心位置>>>确定");
    }
}
    //定义抽象类
abstract class Draw_Eraser
{
    public void getEraser()
    {
        System.out.println("选择橡皮擦");
    }
}
    //类Draw_Clean继承抽象类Draw_Eraser并覆盖抽象方法getEraser()
class Draw_Clean extends Draw_Eraser
{
    public void getEraser()
    {
        System.out.println("橡皮擦选项：选择橡皮擦>>>选中需要清除内容>>>确定");
    }
}
public class 习题6_五_1
{
        public static void main(String[] args)
        {
            //创建并实例化类Draw_Graph对象g
            Draw_Graph g=java重写和重载的区别new Draw_Graph(4,3);
            //调用类Draw_Graph方法getLine()、getCircle()
            g.getLine(4);
            g.getCircle(3);
            //创建并实例化类Draw_Clean对象c
            Draw_Clean c=new Draw_Clean();
            //调用类Draw_Clean方法get.Eraser()
            c.getEraser();
        }
}

2.编写一个复数类，具有实部、虚部成员变量，可以完成加、减、乘、获得实部和虚部等方法，并编写一个主类对其进行测试。
class Complex {
private double x;//实部
private double y;//虚部
public Complex(){}
/**构造函数
* @param x 实数部分
* @param y 虚数部分
*/
public Complex(double x,double y){
super();
this.x = x;
this.y = y;
}
/**求模
* @return 该复数的模
*/
public double mod(){
return x * x + y * y;
}
/**复数间加法
* @param complex 加数
* @return 计算结果
*/
public Complex add(Complex complex){
double x = this.x + complex.x;
double y = this.y + complex.y;
return new Complex(x,y);
}
/**复数与实数的加法
* @param a 加数
* @return 计算结果
*/
public Complex add(double a){
return this.add(new Complex(a,0));
}
/**复数间减法
* @param complex 减数
* @return 计算结果
*/
public Complex subtract(Complex complex){
double x = this.x - complex.x;
double y = this.y - complex.y;
return new Complex(x,y);
}
/**复数与实数的减法
* @param a 减数
* @return 计算结果
*/
public Complex subtract(double a){
return subtract(new Complex(a,0));
}
/**复数间乘法
* @param complex 乘数
* @return 计算结果
*/
public Complex multiply(Complex complex){
double x = this.x * complex.x - this.y * complex.y;
double y = this.y * complex.x + this.x * complex.y;
return new Complex(x,y);
}
/**复数间除法
* @param complex 除数
* @return 计算结果
*/
public Complex divide(Complex complex){
double x = (this.x * complex.x + this.y * complex.y) / (d());
double y = (this.y * complex.x - this.x * complex.y) / (d());
return new Complex(x,y);
}
public String toString(){
StringBuffer sb = new StringBuffer();
if(x != 0){
sb.append(x);
if(y > 0){
sb.append("+" + y + "i");
}else if(y < 0){
sb.append(y + "i");
}
}else{
if(y != 0){
sb.append(y + "i");
}
}
if(x == 0 && y == 0){
return "0";
}
String();
}
public double getX() {
return x;
}
public void setX(double x) {
this.x = x;
}
public double getY() {
return y;
}
public void setY(double y) {
this.y = y;
}
}
public class TestComplex {
    public static void main(String[] args) {
        Complex a = new Complex(2,0.5);
        Complex b = new Complex(0.5,2);
        System.out.println("(" + a + ")+(" + b + ")=" + a.add(b));
        System.out.println("(" + a + ")+" + 2 + "=" + a.add(2));
        System.out.println("(" + a + ")-(" + b + ")=" + a.subtract(b));
        System.out.println("(" + a + ")-" + 2 + "=" + a.subtract(2));
        System.out.println("(" + a + ")*(" + b + ")=" + a.multiply(b));
        System.out.println("(" + a + ")/(" + b + ")=" + a.divide(b));
        }
}

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。