自考教材《java语言程序设计(一)》第三章习题解答

第三章习题解答

3.1什么是面向对象技术?它有什么优点?

通过面向对象的方式，将现实世界的物抽象成对象，现实世界中的关系抽象成类、继承，帮助人们实现对现实世界的抽象与数字建模。程序设计者考虑的是对象的描述、对象间的关系、类的管理、什么时候和什么地方调用对象的哪一种方法。

面向对象技术的最大优点是有效支持重用,使得大的程序也变得相对容易维护。

3.2面积对象的程序设计和面向过程的程序设计有什么区别？

面向过程语言编程模式是：

程序＝数据结构+算法

编程时需要考虑和内容是的程序什么、怎么做、重点考虑每个实现的细节。

面向对象的语言的编程模式是：

程序＝对象+消息

程序设计者考虑的是对象的描述、对象间的关系、类的管理、什么时候和什么地方调用对象的哪一种方法。

3.3在程序中类和对象有什么区别？

类是同一种对象的描述，类概括了同类对象的共有性质：数据和方法。类的每个对象都有自己的标识，但它们具有相同的一级属性和提供相同的方法。

在程序中，对象的名称用于捐弃引用对象，对象的成员变量用于存储对象的状态值，对象和方法用于描述对象的行为。

3.4 类变量和实例变量，以及类方法和实例方法的区别。

加载类之前创建对象之后调用方法访问权限

成员变量实例变量不分配内存

各个对象之间各

自分配独立的内

存空间

对象名.实例变量

名

被实例方法，构造方

法访问

类变量

直接分配内

存

各个对象之间共

享这段已经分配

完的内存

对象名.类变量

名；类名.类变量

名

被实例方法，类方法，

构造方法访问

成员方法实例方法

不分配入口

地址

共享一个入口地

址

对象名.实例方法

名

实例变量、类变量，

实例方法、类方法类方法

直接分配入

口地址

共享这个入口地

址

对象名.类方法

名；类名.类方法

名

类变量、类方法

3.5 子类能继承超类的哪些成员变量和方法？

同包继承不同包继承（import进来的）

私有（private）不继承不继承

友好（缺省默认）继承不继承

受保护（protected）继承继承

共有（public）继承继承

3.6 子类在什么情况下能隐藏超类的成员变量和方法？

解：在子类重载父类的成员变量、方法的情况下。

3.7 在子类中是否允许有一个方法和超类的方法名字相同，而类型不同？

解：不允许！方法重写是指：子类中定义一个方法，并且这个方法的名字、返回类型、参数个数、和类型与从父类继承的方法完全相同。（与方法重载不同）

3.8试说出对象、类、继承和多态性的概念。

所有东西都是对象，现实世界中的对象都有状态、行为和名称。

类是同一种对象的描述，类概括了同类对象的共有性质：数据和方法。类的每个对象都有自己的标识，但它们具有相同的一级属性和提供相同的方法。

继承就是在已有类的基础上扩充属性，或扩充或者改写其某些方法，生成新的类。继承定义的类称为子类，被继承的类称为超类。子类继承父类具有的属性和方法，还可增加某些特殊性，并可扩充和修改部分行为。继承具有传递性。

多态性指同样的消息被不同类型的对象接收时导致完全不同的行为。方法的重写、重载与动态联编构成多态性。

3.9为什么要定义抽象类？为什么抽象类没有具体的对象？

如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。抽象类往往用来表征我们在对问题领域进行分析、设计中得出的抽象概念，是对一系列看上去不同，但是本质上相同的具体概念的抽象。

正是因为抽象的概念在问题领域没有对应的具体概念，所以用以表征抽象概念的抽象类是不能够实例化的，即没有具体的对象的。

3.10试比较接口和抽象类的异同。使用接口有哪些注意事项？

相同点：两者定义的方法均是抽象方法，即没有实现的代码。

不同点：

(1)方法的实现者不同。抽象类的方法实现交给每一个子类去完成，而接口则是一些列没有实现代码的方法（即抽象方法）和常量的组合，方法的实现则要在实现这个接口的类中完成，但它不限定类如何实现这些方法。

(2)继承方式不同。接口使得类不必受限于单一继承的关系，接口本身可以继承多个父接口，而实现接口的类也可以继承一个类和实现多个接口。对有继承并实现接口的类来说，实际上实现了有控制的多继承，而抽象类的子类则不能实现多继承。

（3）实现某个接口的类必须实现该接口的所有方法，而抽象类的子类实现其超类的方法早则没有这种限制。

3.11指出Applet的程序结构及各方法的作用。

程序结构：

public class Applet程序名 extends java.applet.Applet{

public void init(){…}

public void start(){…}

public void stop(){…}

public void destroy(){…}

public void paint(Graphic g){…}

…

}

方法：

Java API 的 Applet 类为您提供设计 applet 程序外观并管理其动作时所需要的支持。该类提供一种叫做 Panel（面板）的图形用户界面（GUI）组件以及大量方法。其基本方法有：(P63－64)

init()方法、start()、stop()、destroy()、paint()、repaint()、update()

要创建一个 applet 程序，就需要扩展该 Applet 类（或创建子类）并实现您所需要的外观和动作。

3.12 以下程序有什么错误？

public class Takecare{

int a=90;

static float b=10.98f;

public static void main(String args[]){

float c=a+b;System.out.println(“=”+c);

}

}

解：类方法main()调用了类的实例变量，main方法是类方法，不能调用类的实例变量a，导致错误！

3.13 声明一个复数类Complex。要求该类提供：由已知实部和虚部构造复数的方法；复数与实数和复数与复数的四则运算方法；取复数对象的实部、虚部的方法；输出复数的方法。并要求编写一个应用程序实现对复数类的完整测试。

class Complex{

double a,b;

Complex(){}

Complex(double a, double b)

{

this.a=a;this.b=b;

}

public String Print()//输出复数的字符串表示

{

String result= new String(this.a+ (b>0?"+":"") + (b!=0?this.b+ "i":""));//

此处很有技巧：

//如果虚部b大于0，则输出格式为“a+bi”，如果虚部b小于0.则第一个条件表达式的值为空，输出格式为“abi”，而因b前有负号，故自动成为“a-bi”格式

//如果虚部b为0，则第一个和第二个条件表达式值均为空，输出格式为“a”。

return result;

}

public Complex add(Complex val)//复数加法

{

Complex result = new Complex();

result.a = this.a + val.a;

result.b = this.b + val.b;

return result;

}

public Complex subtract(Complex val)//复数减法

{

Complex result = new Complex();

result.a = this.a - val.a;

result.b = this.b - val.b;

return result;

}

public Complex multiply(Complex val)//复数乘法

{

Complex result = new Complex();

result.a = this.a * val.a-this.b*val.b;

result.b = this.a * val.b+this.b*val.a;

return result;

}

public Complex divide(Complex val)//复数除法

{

Complex result = new Complex();

result.a = (this.a * val.a+this.b*val.b)/(val.a*val.a+val.b*val.b);

result.b = (this.b * val.a-this.a*val.b)/(val.a*val.a+val.b*val.b);

return result;

}

public double getReal()//取复数的实部

{

return this.a;

}

public double getimage()//取复数的虚部

{

return this.b;

}

}

class TestComplex{

public static void main(String[] args)

{

Complex complex1 = new Complex(2.0,4.0);

Complex complex2 = new Complex(3.0,-1.0);

System.out.println("复数1："+ complex1.Print()+" 其实部："+complex1.getReal()+"虚部："+complex1.getimage());

System.out.println("复数2："+ complex2.Print()+" 其实部："+complex2.getReal()+"虚部："+complex2.getimage());

System.out.println("复数1与复数2之和为"+complex1.add(complex2).Print());

System.out.println("复数1与复数2之差为"+complex1.subtract(complex2).Print());

System.out.println("复数1与复数2之积为"+complex1.multiply(complex2).Print());

System.out.println("复数1除以复数2之商为"+complex1.divide(complex2).Print());

}

}

运行结果：

3.14 声明一个有理数类RationalNum。要求提供有理数的四则运算，以分数形式输出有理数和以浮点数形式输出有理数等方法。

class RationalNumber

{

int numerator;//分子

int denominator;//分母

public RationalNumber()

{

numerator = Integer.MIN_VALUE;//即-2147483648

denominator = Integer.MIN_VALUE;

}

public RationalNumber(int a, int b) throws Exception//构造方法

{

if (b == 0)

{

throw new Exception("发生分母为0的异常，分母不能为0");

}

else

{

this.numerator = a;

this.denominator = b;

}

}

public int getNumerator()//返回分子

{

return numerator;

}

public int getDenominator()//返回分母

{

return denominator;

}

public void setRational(int fenzi, int fenmu)//设置分子分母

{

this.numerator = fenzi;

this.denominator = fenmu;

}

public RationalNumber add(RationalNumber r)//有理数加法

{

int a = this.numerator* r.getDenominator() + this.denominator* r.getNumerator();

int b = this.denominator * r.getDenominator();

RationalNumber result = new RationalNumber();

result.setRational(a,b);

result.yuefen();//约分

return result;

}

public RationalNumber subtract(RationalNumber r)//有理数减法

{

int a = this.numerator* r.getDenominator() - this.denominator* r.getNumerator();

int b = this.denominator * r.getDenominator();

RationalNumber result = new RationalNumber();

result.setRational(a, b);

result.yuefen();//约分

return result;

}

public RationalNumber multiply(RationalNumber r)//有理数乘法

{

int a = this.numerator * r.getNumerator();

int b = this.denominator * r.getDenominator();

RationalNumber result = new RationalNumber();

result.setRational(a, b);

result.yuefen();//约分

return result;

}

public RationalNumber divide(RationalNumber r)

{

r.setRational(r.getDenominator(), r.getNumerator());//分子分母颠倒

RationalNumber result = this.multiply(r);//与颠倒后的有理数相乘

result.yuefen();//约分

return result;

}

public void yuefen()//约分，没有使用求最大公约数函数，此处还可使用，请读者自行编程

{

int a = Math.abs(this.numerator);// 分子

int b = Math.abs(this.denominator);// 分母

int small = a < b ? a : b;

for (int i = 2; i <= small; i++)

{

while ((a % i == 0) && (b % i == 0))

{

a = a / i;

b = b / i;

}

}

if (this.numerator < 0)

this.numerator = -a;

else

this.numerator = a;

if (this.denominator < 0)

this.denominator = -b;

else

this.denominator = b;

}

public String toString()//返回该有理数的分数表示形式

{

if (this.numerator == 0)

return"0";

else

return this.numerator + "/" + this.denominator;

}

public double toDouble()// 返回该有理数的浮点数形式,注意技巧

{

double a = (1.0 * this.numerator) / (this.denominator * 1.0);

return a;

}

}

class TestRational

{

public static void main(String[] args)

{

RationalNumber r1 = null;

RationalNumber r2 = null;

try

{

r1 = new RationalNumber(5, -105);//生成两个有理数对象

r2 = new RationalNumber(8, 18);

}

catch (Exception e)//异常处理

{

System.out.println( e.toString() );

}

System.out.print("有理数1：" + r1.toString());

r1.yuefen();

System.out.println("，约分后 = " + r1.toString());

System.out.print("有理数2：" + r2.toString());

r2.yuefen();

System.out.println("，约分后 = " + r2.toString());

RationalNumber resultAdd = r1.add(r2);// 相加

System.out.print(r1.toString() + " + " + r2.toString() + " = ");

System.out.println(resultAdd.toString() + " = " + resultAdd.toDouble());

RationalNumber resultSubtract = r1.subtract(r2);//相减

System.out.print(r1.toString() + " - " + r2.toString() + " = ");

System.out.println(resultSubtract.toString() + " = "+ resultSubtract.toDouble());

RationalNumber resultMultiply = r1.multiply(r2);// 相乘

System.out.print(r1.toString() + " × " + r2.toString() + " = ");

System.out.println(resultMultiply.toString() + " = "+ resultMultiply.toDouble());

RationalNumber resultDivide = r1.divide(r2);//相除

System.out.print(r1.toString() + " ÷ " + r2.toString() + " = ");

System.out.println(resultDivide.toString() + " = "+ resultDivide.toDouble());

}

}

运行结果：

上面的约分如果使用最大公约数法，则代码为：

public int gcd(int a1, int b1)//求最大公约数

{

int c1;

do {

c1 = a1 % b1;

a1 = b1;

b1 = c1;

}

while (b1 > 0);

return a1;

}

public void yuefen_gcd()//约分函数，注意与上面不使用最大公约数函数的方法比较{

int a = Math.abs(this.numerator);// 分子

int b = Math.abs(this.denominator);// 分母

int gcdvalue;

gcdvalue = this.gcd(a,b);//调用求最大公约数函数

if (gcdvalue>1)

{a = a / gcdvalue;//约分

b = b / gcdvalue;}

if (this.numerator < 0)

this.numerator = -a;

else

this.numerator = a;

if (this.denominator < 0)

this.denominator = -b;

else

this.denominator = b;

}