Java面向对象程序设计实训试验参考指导书.doc

Java面向对象程序设计实训试验参考指导书

Java面向对象程序设计
实验指导书

适用专业：计算机网络技术
执 笔 人：周辉奎

南昌工学院信息学院 编
二〇一三年十月

目 录

实验项目一 Java开发环境搭建 1
实验项目二 Java语言基础 8
实验项目三 Java语言面向对象基础 21
实验项目四 图形用户界面的设计 39
实验项目五 异常处理 44

实验项目一 Java开发环境搭建

一、实验目的和要求：
（一）目的：
1、熟悉安装JDK、JRE；
2、熟悉环境变量配置；
3、熟悉Eclipse；
4、掌握命令提示符运行第一个java程序。
（二）要求：
1、认真做好实验前的各项准备工作，熟悉实验内容和机器操作流程。
2、遵守实验室规章制度和实验课堂教学纪律。
3、认真完成实验任务，填写实验报告。
二、实验时数：2学时
三、实验器材：
操作系统：Windows XP操作系统
应用系统：Eclipse
四、实验内容或步骤：
Java开发环境搭建
1、Java JDK安装
单击Java JDK安装包，然后弹出提示框，点击下一步，直到选择安装目录如图1所示，将安装目录放在E:\Java\\，然后继续下一步。
图1 设定JDK安装目录
JDK（Java开发工具）安装完成后，系统会自动安装JRE（Java 运行时环境），更改JRE的安装目录，将其与JDK放在同一目录下，如图2所示。

图2 设定JRE安装目录
安装完成后，出现如图2所示界面。

图3 Java环境安装结束界面
2、配置环境变量
Java JDK安装完成后，并不能立即使用，还需要配置相关环境变量。右键单击我的电脑à属性弹出如下对话框，选择高级à环境变量。
图4 系统高级属性对话框
首先，在系统变量中新建一个JAVA_HOME变量，该变量的值为JDK的安装目录。在此为E:\Java\\。（与前面安装时指定目录一致）

图4 JAVA_HOME环境变量设置
注意：变量值后不需要加任何符号。
然后在系统变量中查找path变量，如果存在，则将JDK安装目录下的bin文件夹添加其后，多个目录以分号隔开，如图5所示。如果不存在则新建一个，然后将bin目录放进去即可是E:\Java\\bin;

图5 在path变量中添加Java bin目录
新建classpath环境变量，该变量的值为JDK安装目录下lib目录，在此为：;%JAVA_HOME%\lib。如图6所示。

图6 classpath环境变量设定
配置完成后，单击开始à运行，输入cmd，如图7所示，确定，打开命令行窗口。

图7 打开命令行窗口的命令
在命令行窗口中输入java –version命令，显示安装的Java 版本信息，如图8所示，则表明java JDK、 JRE安装成功。

图8 Java JDK、 JRE安装测试结果
在命令行窗口中输入javac命令，显示安装javac的一系列选项参数，如图9所示，则表明java开发环境搭建成功。

图9 Java环境测试结果

【附录】利用命令提示符来运行Java程序：
1、。
【操作步骤】开始——运行——cmd，一步步按以下输入（注意：类名和编译文件名必须大小写一致）

说明：
javac命令表示编译；
java命令表示运行。

【总结】开发Java程序之前的JDK、JRE安装及环境配置
一、先安装JDK、JRE，安装时必须都在同一个目录，假设在E:\Java\\。
安装完，用命令提示符测试安装是否正确。
开始——运行——cmd—— java –version，如果显示JDK版本，则安装正确。
二、配置环境变量
1、右击我的电脑à属性，选高级à环境变量。
2、在系统变量中新建一个变量名为JAVA_HOME，变量值为 E:\Java\\
3、在系统变量中查找path变量，如果存在，则将JDK安装目录下的bin文件夹添加其后，多个目录以分号隔开，E:\Java\\bin;
4、新建classpath环境变量，变量值为 ;%JAVA_HOME%\lib
环境变量配置完，用命令提示符测试配置是否正确。
开始——运行——cmd—— javac，如果显示javac的一系列选项参数，则表明java开发环境搭建成功。
五、注意事项：
1、注意使用javac命令编译源程序。
2、注意使用java命令运行程序。
六、练习项目及思考题：
1、如何搭建java开发环境。
实验项目二 Java语言基础

一、实验目的和要求：
（一）目的：
1、 了解Java 的数据类型；
2、 掌握各种变量的声明方式；
3、 理解运算符的优先级；
4、 掌握Java 基本数据类型、运算符与表达式、数组的使用方法；
5、 理解Java 程序语法结构，掌握顺序结构、选择结构和循环结构语法的程序设计方法；
6、 通过以上内容，掌握Java 语言的编程规则。
（二）要求：
1、编写一个声明Java 不同数据类型变量的程序；
2、编写一个使用运算符、表达式、变量的程序；
3、编写一个使用Java 数组的的程序；
4、编写表达式语句、复合语句的程序；
5、编写使用不同选择结构的程序；
6、编写使用不同循环结构结构的程序。
二、实验时数：6学时
三、实验器材：
操作系统：Windows XP操作系统
应用系统：Eclipse
四、实验内容或步骤：
1、
(1) ，源代码如下。
　　public class EXP2_1 {
　　　public static void main(String args[]) {
　　　　byte b=0x55;
　　　　short s=0x55ff;
　　　　int i=1000000;
　　　　long l=0xffffL;
　　　　char c='a';
　　　　float f=;
　　　　double d=;
　　　　boolean B=true;
　　　　String S="这是字符串类数据类型";
　　　　("字节型变量 b = "+b);
　　　　("短整型变量 s = "+s);
　　　　(" 整型变量 i = "+i);
　　　　("长整型变量 l = "+l);
　　　　("字符型变量 c = "+c);
　　　　("浮点型变量 f = "+f);
　　　　("双精度变量 d = "+d);
　　　　("布尔型变量 B = "+B);
　　　　("字符串类对象 S = "+S);
　　　}
}
(2) 编译并运行该程序， 所示。

图

2、 了解变量的使用范围
(1) 文件，通过本程序了解变量的使用范围，源代码如下。
　　public class EXP2_2 {
　　　static int i=10;
　　　public static void main(String args[]) {
　　　　{
　　　　　int k=10;
　　　　　("i="+i);
　　　　　("k="+k);
　　　　}
　　　　("i="+i);
　　　　("k="+k);//编译时将出错，已出k的使用范围
　　　}
　　}
(2)
　　 所示。因为变量k 在方法块中声明，在方法块之外它是不存在的，所以编译时会出错。

图
(3) 修改上面的程序
(4) 成功运行该程序
思考： 程序说明了什么问题？
3、 使用关系运算符和逻辑运算符
(1) 建立使用关系运算符和逻辑运算符的程序文件，源代码如下。
　　class EXP2_3 {
　　　public static void main(String args[]) {
　　　　int a=25, b=20, e=3, f=0;
　　　　boolean d=a<b;
　　　　("a=25,b=20,e=3,f=0");
　　　　("因为关系表达式 a<b 为假，所以其逻辑值为 ： "+d);
　　　　if (e!=0 && a/e>5)
　　　　　("因为e 非0 且a/e 为8 大于5，所以输出 a/e＝ "+a/e);
　　　　if (f!=0 && a/f>5)
　　　　　("a/f = "+a/f);
　　　　else
　　　　　("因为f 值为0，所以输出 f = "+f);
　　　}
　　}
(2) 编译并运行该程序， 所示。

图
4、 使用数组
(1) 建立使用数组的程序，本程序建立了一个长度为5 的1 维数组，一个长度为12 的2 维数组，源代码如下。
　　public class EXP2_4 {
　　　public static void main(String args[]) {
　　　　int a[]=new int[5];
　　　　int arr1[][]=new int[3][4];
　　　　a[0]=10;
　　　　a[1]=10+a[0];
　　　　a[2]=30;
　　　　a[3]=40;
　　　　a[4]= a[1]+ a[2];
　　　　arr1[0][0]=0; arr1[0][1]=1; arr1[0][2]=2;
　　　　arr1[1][0]=3; arr1[1][1]=4; arr1[1][2]=5;
　　　　arr1[2][0]=6; arr1[2][1]=7; arr1[2][2]=8;
　　　　("a["+0+"] = "+a[0]);
　　　　("a["+1+"] = "+a[1]);
　　　　("a["+2+"] = "+a[2]);
　　　　("a["+3+"] = "+a[3]);
　　　　("a["+4+"] = "+a[4]);
　　　　("arr1("+0+","+0+") = "+arr1[0][0]);
　　　　("arr1("+0+","+1+") = "+arr1[0][1]);
　　　　("arr1("+0+","+2+") = "+arr1[0][2]);
　　　　("arr1("+1+","+0+") = "+arr1[1][0]);
　　　　("arr1("+1+","+1+") = "+arr1[1][1]);
　　　　("arr1("+1+","+2+") = "+arr1[1][2]);
　　　}
　　}
(2) 编译并运行程序， 所示。

图
5、 使用表达式语句与复合语句
(1) 建立包含表达式语句程序，源代码如下。
　　class EXP2_5{
　　　public static void main(String[] args) {
　　　　int k, i=3, j=4;
　　　　k=20*8/4+i+j*i;
　　　　("表达式（20*8/4+i+j*i）＝"+k);
　　　}
　　}
(2) 建立包含复合语句程序，源代码如下。
　　class EXP2_6{
　　　public static void main(String args[]) {
　　　　int k, i=3, j=4;
　　　　k=i+j;
　　　　("在复合块外的输出 k="+k);
　　　　{
　　　　　float f;
　　　　　f=j+;
　　　　　i++;
　　　　　("在复合块内的输出 f="+f);
　　　　　("在复合块内的输出 k="+k);
　　　　}
　　　　("在复合块外的输出 i="+i);
　　　}
　　}
(3) 编译并运行上述两个源程序，、 所示。
(4) 将变量i 在块内定义会怎样？改变其他变量的位置看看会发生什么变化。
思考：指出程序的复合结构以及变量的使用范围。

图

图
6、 使用选择语句
6.1、 使用if...else 语句
(1) 程序功能：使用if...else 语句构造多分支，判断某一年是否为闰年。闰年的条件是符合下面二者之一：能被4 整除，但不能被100 整除；能被4 整除，又能被100 整除。
(2) 编写源程序文件，代码如下。
　　public class EXP2_7 {
　　　public static void main(String args[]) {
　　　　boolean leap;
　　　　int year=2005;
　　　　if ((year%4==0 && year%100!=0) || (year%400==0)) // 方法1
　　　　　(year+" 年是闰年");
　　　　else
　　　　　(year+" 年不是闰年");
　　　　year=2008; // 方法2
　　　　if (year%4!=0)
　　　　　leap=false;
　　　　else if (year%100!=0)
　　　　　leap=true;
　　　　else if (year%400!=0)
　　　　　leap=false;
　　　　else
　　　　　leap=true;
　　　　if (leap==true)
　　　　　(year+" 年是闰年");
　　　　else
　　　　　(year+" 年不是闰年");
　　　　year=2050; // 方法3
　　　　if (year%4==0) {
　　　　　if (year%100==0) {
　　　　　　if (year%400==0)
　　　　　　　leap=true;
　　　　　　else
　　　　　　　leap=false;
　　　　　}
　　　　　else
　　　　　　leap=false;
　　　　}
　　　　else
　　　　　leap=false;
　　　　if (leap==true)
　　　　　(year+" 年是闰年");
　　　　else
　　　　　(year+" 年不是闰年");
　　　}
　　}
(3) 编译运行程序， 所示。

图
思考：本程序中有几个选择语句，哪些具有嵌套关系？
6.2、 使用switch 语句
(1) 程序功能：在不同温度时显示不同的解释说明。
(2) 程序源代码如下。
　　class EXP2_8{
　　　public static void main(String args[]) {
　　　　int c=38;
　　　　switch (c<10?1:c<25?2:c<35?3:4) {
　　　　　case 1:
　　　　　　(" "+c+"℃ 有点冷。要多穿衣服。");
　　　　　case 2:
　　　　　　(" "+c+"℃ 正合适。出去玩吧。");
　　　　　case 3:
　　　　　　(" "+c+"℃ 有点热。");
　　　　　default:
　　　　　　(" "+c+"℃ 太热了!开空调。");
　　　　}
　　　}
　　}
(3) 编译运行程序， 所示。

图
7、 使用循环语句
7.1、 for 循环语句练习
(1) 程序功能：按5 度的增量打印出一个从摄氏温度到华氏温度的转换表。
(2) 程序源代码如下。
　　class EXP2_9{
　　　public static void main (String args[]) {
　　　　int h,c;
　　　　("摄氏温度＼ｔ华氏温度");
　　　　for (c=0; c<=40; c+=5) {
　　　　　h=c*9/5+32;
　　　　　("＼ｔ"+c+"＼ｔ"+h);
　　　　}
　　　}
　　}
(3) 编译并运行程序， 所示。

图
7.2、 while 循环语句练习
(1) 程序功能：运行程序后从键盘输入数字1/2/3 后，可显示抽奖得到的奖品；如果输入其它数字或字符显示“没有奖品给你!”。
(2) 程序源代码如下。
　　import .*;
　　class EXP2_10 {
　　　public static void main(String args[]) throws IOException {
　　　　char ch;
　　　　("按 1/2/3 数字键可得大奖!");
　　　　("按’Q’键可退出循环操作.");
　　　　while ((ch=(char)())!=' ') {
　　　　　(2); // 跳过回车键
　　　　　switch (ch) {
　　　　　　case '1':
　　　　　　　("恭喜你得大奖，一辆汽车!");
　　　　　　　break;
　　　　　　case '2':
　　　　　　　("不错呀，你得到一台笔记本电脑!");
　　　　　　　break;
　　　　　　case '3':
　　　　　　　("没有白来，你得到一台冰箱!");
　　　　　　　break;
　　　　　　case ‘q’:
(“欢迎下次再来！”);
(0);
　　　　　　default:
　　　　　　　("真不幸，你没有奖品!下次再来吧。");
　　　　　}
　　　　}
　　　}
　　}
(3) 编译源程序。
(4) 在命令提示符窗口运行程序，然后分别按1、2、3、r 所示。

图
7.3、 do…while 循环语句练习
(1) 程序功能：求1＋2＋…+100 之和，并将求和表达式与所求的和显示出来。
(2) 程序源代码如下。
　　class EXP2_11 {
　　　public static void main(String args[]) {
　　　　int n=1, sum=0;
　　　　do {
　　　　　sum+=n++;
　　　　}
　　　　while (n<=100);
　　　　("1+2＋...+100 ="+sum);
　　　}
　　}
（3）编译并运行程序， 所示。

图
7.4、 多重循环练习
(1) 输出九九乘法表的程序，源代码如下。
　　public class EXP2_12
　　{
　　　public static void main(String args[])
　　　{
　　　　int i,j,n=9;
　　　　(" * |");
　　　　for (i=1;i<=n;i++)
　　　　　(" "+i);
　　　　("\n---|");
　　　　for (i=1;i<=n;i++)
　　　　　("----");
　　　　();
　　　　for (i=1;i<=n;i++)
　　　　{
　　　　　(" "+i+" |");
　　　　　for (j=1;j<=i;j++)
　　　　　　(" "+i*j);
　　　　　();
　　　　}
　　　}
　　}

(2) 编译并运行程序， 所示。

五、注意事项：
1、注意Java集成开发环境Eclipse的使用。
2、注意Java程序编码方式及书写习惯。
六、练习项目及思考题：
1、观察输出的结果，发现九九表的行和列没有对齐，如何才能输出一张行列对齐的九九表？
实验项目三 Java语言面向对象基础

一、实验目的和要求：
（一）目的：
1、通过编程和上机实验理解Java语言是如何体现面向对象编程基本思想；
2、了解类的封装方法，以及如何创建类和对象；
3、了解成员变量和成员方法的特性；
4、掌握面向对象程序设计的方法；
5、了解类的继承性和多态性的作用；
6、了解接口的作用。
（二）要求：
1、 编写一个体现面向对象思想的程序；
2、 编写一个创建对象和使用对象的方法的程序；
3、 编写一个显示当前日期和时间的程序；
4、 编写不同成员变量修饰方法的程序；
5、 编写不同成员方法修饰方法的程序；
6、 编写体现类的继承性（成员变量、成员方法、成员变量隐藏）的程序；
7、 编写体现类的多态性（成员方法重载、构造方法重载）的程序；
8、编写体现接口功能的程序。
二、实验时数：12学时
三、实验器材：
操作系统：Windows XP操作系统
应用系统：Eclipse
四、实验内容或步骤：
1、 ，使用类的成员变量来表示事物的属性和状态，使用类的成员方法来提供对成员变量的访问或修改
(1) 程序功能：设计一个用来描述汽车的类，使用类的非静态成员变量来表示汽车的车主姓名、当前的速率和当前方向盘的转向角度，使用类的非静态成员方法来表示改变汽车的速率和停车两个操作。
(2) 程序源代码如下。
public class EXP3_1 {
private String ownerName; //车主姓名
private float curSpeed; //当前车速
private float curDirInDegree; //当前方向盘转向角度
public EXP3_1(String ownerName){
=ownerName;
}
public EXP3_1(String ownerName, float speed, float dirInDegree){
this(ownerName);
=speed;
=dirInDegree;
}
public String getOwnerName() { //提供对车主姓名的访问
return ownerName;
}
public float getCurDirInDegree() { //提供对当前方向盘转向角度的访问
return curDirInDegree;
}
public float getCurSpeed() { //提供对当前车速的访问
return curSpeed;
}
public void changeSpeed(float curSpeed) { //提供改变当前的车速
= curSpeed;
}
public void stop(){ //提供停车
=0;
}
}
(3) 编译源程序。
2、 创建类的对象，使用对象的方法（类的非静态方法）来访问或修改对象的变量（类的非静态变量）
(1) 创建类EXP3_1的对象，在调用类的构造函数时指定对象的变量的初始值，以后再使用对象的方法来访问或修改对象的变量的值。
(2) 程序代码如下。
public class EXP3_2 {
public static void main(String[] args){
EXP3_1 car=new EXP3_1("成龙",200f,25f);
("车主姓名: "+());
("当前车速: "+());
("当前转向角度: "+());
(80);
("在调用changeSpeed(80)后,车速变为: " + ());
();
("在调用stop()后, 车速变为: "+());
}
}
(3) 编译并运行，。

图
3、 编写显示当前时间和日期的程序
(3) 程序功能：该程序通过使用一个自定义类Time，实现显示当前日期和时间的功能。
(4) 程序代码如下。
import ;
class Time {
　　　private Calendar t;
　　　private int y, m, d, hh, mm, ss;
　　　Time (){
　　　　t=();
　　　　y=();
　　　　m=()+1;
　　　　d=();
　　　　hh=();
　　　　mm=();
　　　　ss=();
　　　}
　　　public String getDate() {
　　　　return y+" 年"+m+"月"+d+"日";
　　　}
　　　public String getTime() {
　　　　return hh+" 时"+mm+"分"+ss+"秒";
　　　}
　　}
　　public class EXP3_3{
　　　public static void main(String[] args){
　　　　Time t=new Time();
　　　　("当前日期："+());
　　　　("当前时间："+());
　　　}
　　}
(5) 编译并运行，。

图
4、 使用修饰符来限定类的成员变量或成员方法的属性
　　有时需要公开一些变量和方法，有时需要禁止其他对象使用变量和方法，这时可以使用修饰符来实现这个目的。
　　常用的修饰符如下：
　　　public private protected package static final transient volatile
　　 所示。
访问权限修饰符
类
子类
包
所有类和包
public
√
√
√
√
private
√

protected
√
√
√

package
√

√

表
(1) 程序功能：通过两个类StaticDemo、EXP3_4 说明静态变量/方法与实例变量/方法的区别。
(2) 程序源代码如下。
　　class StaticDemo {
　　　static int x;
　　　int y;
　　　public static int getX() {
　　　　return x;
　　　}
　　　public static void setX(int newX) {
　　　　x = newX;
　　　}
　　　public int getY() {
　　　　return y;
　　　}
　　　public void setY(int newY) {
　　　　y = newY;
　　　}
　　}
　　public class EXP3_4 {
　　　public static void main(String[] args) {
　　　　("静态变量x="+());
　　　　("实例变量y="+()); //非法，编译时将出错
　　　　StaticDemo a= new StaticDemo();
　　　　StaticDemo b= new StaticDemo();
　　　　(1);
　　　　(2);
　　　　(3);
　　　　(4);
　　　　("="+());
　　　　("="+());
　　　　("="+());
　　　　("="+());
　　　}
　　}
(3) 对上面的源程序进行编译，。

图
(4) 将源程序中的出错语句删除或使用解释符//隐藏起来，例如，//("实例变量y="+());
(5) 重新编译并运行该程序，。

图
5、 调用方法时参数传递的练习
　　在其它语言中，函数调用或过程调用时参数有传值调用和传地址调用之分。在Java 中，方法中的参数传递可以分为传值调用或对象方法调用等方式。传值调用即传递的参数是基本数据类型，调用方法时在方法中将不能改变参数的值，这意味着只能使用它们。对象调用是指先调用对象，再调用对象的方法，这种方式可以修改允许存取的成员变量。所以，如果不想改变参数的值，可以采用传值调用的方法。如果想改变参数的值，可采用对象调用的方法，间接修改参数的值。
、编写一个传值调用的程序
(1) 程序功能：程序首先给整型变量x 和y 赋一个初值10，然后使用传值调用方式调用方法ff1对x 和y 做乘方及输出x 和y 的乘方值，最后再输出x 和y 的乘方值。
(2) 程序源代码如下。
　　class EXP3_5 {
　　　public static void main(String[] args) {
　　　　int x=10, y=10;
　　　　ff1(x, y);
　　　　("x="+x+", y="+y);
　　　}
　　　static void ff1(int passX, int passY) {
　　　　passX=passX*passX;
　　　　passY=passY*passY;
　　　　("passX="+passX+", passY="+passY);
　　　}
　　}
(3) 编译并运行，。

图

、编写一个调用对象方法的程序
(1) 程序功能：通过调用对象的方法在方法调用后修改了成员变量的值。
(2) 程序源代码如下。
　　class EXP3_6 {
　　　public static void main(String[] args) {
　　　　Power p=new Power();
　　　　(10,10);
　　　　("方法调用后 x="++", y="+);
　　　}
　　}
　　class Power{
　　　int x=10, y=10;
　　　void ff2(int passX, int passY) {
　　　　("初始时 x="+x+", y="+y);
　　　　x=passX*passX;
　　　　y=passY*passY;
　　　　("方法调用中 x="+x+", y="+y);
　　　}
　　}
　　(3) 编译并运行，。

图
6、 类的继承性练习
　　新类可从现有的类中产生，并保留现有类的成员变量和方法并可根据需要对它们加以修改。新类还可添加新的变量和方法。这种现象就称为类的继承。
　　当建立一个新类时，不必写出全部成员变量和成员方法。只要简单地声明这个类是从一个已定义的类继承下来的，就可以引用被继承类的全部成员。被继承的类称为父类或超类（superclass），这个新类称为子类。
　　Java 提供了一个庞大的类库让开发人员继承和使用。设计这些类是出于公用的目的，因此，很少有某个类恰恰满足你的需要。你必须设计自己的能处理实际问题的类，如果你设计的这个类仅仅实现了继承，则和父类毫无两样。所以，通常要对子类进行扩展，即添加新的属性和方法。这使得子类要比父类大，但更具特殊性，代表着一组更具体的对象。继承的意义就在于此。
6.1、 创建将被继承的类
(1) 程序源代码如下。
　　public class EXP3_7
　　{
　　　protected String xm; //具有保护修饰符的成员变量
　　　protected int xh;
　　　void setdata(String m,int h) //设置数据的方法
　　　{
　　　　xm =m;
　　　　xh = h;
　　　}
　　　public void print() //输出数据的方法
　　　{
　　　　(xm+", "+xh);
　　　}
　　}
(2) 编译源程序。
6.2、 创建将被继承的类
(1) 程序功能：通过EXP3_7类产生子类EXP3_8，其不仅具有父类的成员变量xm（姓名）、xh（学号），还定义了新成员变量xy（学院）、xi（系）。在程序中调用了父类的print 方法，同时可以看出子类也具有该方法。
(2) 程序源代码如下。
　　class EXP3_8 extends EXP3_7{
　　　protected String xy;
　　　protected String xi;
　　　public static void main(String args[]){
　　　　EXP3_7 p1 = new EXP3_7();
　　　　("李四",12321) ;
　　　　();
　　　　EXP3_8 s1 = new EXP3_8() ;
　　　　("张三",12345); //调用父类的成员方法
　　　　="成都信息工程学院"; //访问本类的成员变量
　　　　="计算机系"; //访问本类的成员变量
　　　　();
　　　　(+", "++", "+);
　　　}
　　}
(4) 编译并运行，。

图
6.3、 了解成员方法的覆盖方式
　　通过继承子类可以继承父类中所有可以被子类访问的成员方法，但如果子类的方法与父类方法同名，则不能继承，此时称子类的方法覆盖了父类的方法，简称为方法覆盖（override）。方法覆盖为子类提供了修改父类成员方法的能力。例如，子类可以修改层层继承下来的Object 根类的toString 方法，让它输出一些更有用的信息。下面的程序显示了在子类Circle 中添加toString 方法，用来返回圆半径和圆面积信息。
(1) 编写覆盖Object ，源代码如下。
　　class Circle {
　　　private int radius;
　　　Circle(int r) {
　　　　setRadius(r);
　　　}
　　　public void setRadius(int r) {
　　　　radius=r;
　　　}
　　　public int getRadius() {
　　　　return radius;
　　　}
　　　public double area() {
　　　　return *radius*radius;
　　　}
　　　public String toString() {
　　　　return "圆半径："+getRadius()+" 圆面积："+area();
　　　}
　　}
　　public class EXP3_9{
　　　public static void main(String args[]) {
　　　　Circle c=new Circle(10);
　　　　("\n"+());
　　　}
　　}
(2) 编译并运行，。

图
6.3、 this、super和super()的使用
(1) 程序功能：程序功能：说明this、super 和super()的用法。程序首先定义Point（点）类，然后创建点的子类Line（线）。最后通过LX3_10 类输出线段的长度。程序中通过super(a,b)调用父类Point 的构造方法为父类的x 和y 赋值。在子类Line 的setLine方法中，因为参数名和成员变量名相同，为给成员变量赋值，使用this 引用，告诉编译器是为当前类的成员变量赋值。在length 和toString 方法中使用父类成员变量时，使用super 引用，告诉编译器使用的是父类的成员变量。
(2) 程序源代码如下。
　　class Point {
　　　protected int x, y;
　　　Point(int a, int b) {
　　　　setPoint(a, b);
　　　}
　　　public void setPoint(int a, int b) {
　　　　x=a;
　　　　y=b;
　　　}
　　}
　　class Line extends Point {
　　　protected i