PowerPoint Presentation

Transcription

1 第 3 章 类 类的继承和接口

2 3.1 类 3.2 包的创建和使用 源文件结构 3.3 类的继承和多态 3.4 接口和接口的实现 3.5 内部类和匿名内部类

3 3.1 类 1 Java 中类的定义格式 : [ 类的修饰符 ] class 类名 [extends 父类名 ]{ 变量声明 ; 构造方法定义 ; 其他方法定义 ;

4 2 创建一个类的对象的格式 : 类名对象名 =new 构造函数 ( 实际参数 ); 3 在类外部访问类的变量或者调用类的方法的格式 : 对象名. 变量名 对象名. 方法名 ( 实际参数 )

5 3.1.1 类的修饰符 1. 类访问权限修饰符 :public ( 公共的 ) public 类可以被任何其他类使用 ; default 类 (class 前无修饰符 ) 只能在它所在的包中访问 一个 Java 源文件包含几个类的定义时, 只能有一个 public 类, 且文件名与该类完全一致

6 2.abstract( 抽象的 ) abstract 修饰不完整的类 ( 抽象类 ), 该类中含有没有方法体的抽象方法, 这些抽象方法必须在其非抽象子类实现 抽象类没有具体实例

7 3.final( 最终的 ) final 用于修饰最终类 final 类不能有子类, 即无法被继承

8 3.1.2 类的成员 有以下三种类型的成员 : 1 域 (field) 类中声明的变量称为域, 用来描述类的属性或状态 一个类的域可以时基本数据类型, 也可以是其他类的对象等

9 2 方法 (method) 定义该类对象所具有的行为 3 内部类定义在一个类里面的类

10 3.1.3 域 域的访问控制修饰 符和其他修饰符 1. 域的初始化 一个类中如果没有定义构造方法, 则编译器会自动生成一个没有参数的构造方法, 用来初始化类对象, 并将类中变量自动初始化为该类的默认值 :

11 整型初始化为 0; 实型初始化为 0.0f 0.0d; 逻辑型初始化为 false; 字符型初始化为 \u0000 ; 类对象初始化为 null, 表明引用不指向任何内存地址

12 例 3.1 定义类和使用类对象 public class TestBirthday { public static void main(string args[]) { Birthday obj1=new Birthday(); obj1.show(); Birthday obj2=new Birthday(1990,11,12); obj2.show();

13 class Birthday { int year, month, day; // 分别表示年月日 Birthday( ) { Birthday(int year, int month, int day) { this.year=year; //this 代表对象本身 this.month=month; this.day=day; void show(){ System.out.println(" 出生年月 :"+year+" 年 +month+" 月 "+day+" 日 ");

14 2. 声明其它类对象作为一个类的域 类的域 ( 变量 ) 可以是基本数据类型, 也可以是其他类的对象

15 例 3.2 类对象作为类的域 //TestPerson.java public class TestPerson { public static void main(string args[]) { Person obj=new Person(" 张三 ", ' 男 ', new Birthday(1988,8,8), 1.75); obj.show(); System.out.println("======== 改变类中变量的取值 =========="); obj.name=" 王立 "; obj.birth=new Birthday(1988,1,20); obj.birth.show(); obj.show();

16 //Person.java public class Person { String name; char sex; Birthday birth; double height; Person(String name, char sex, Birthday birth, double height) { this.name=name; this.sex=sex; this.birth=birth; this.height=height;

17 void show() { System.out.println(" 姓 System.out.println(" 性 birth.show(); System.out.println(" 性 名 :"+name); 别 :"+sex); 别 :"+height); //Birthday.java public class Birthday {

18 3. 域的访问控制 类的内部 : 类的域在类的里面都是可见的, 类中的所有方法都可以使用他们 类的外部 : 访问权限修饰符 在类的外部, 类中域的可见性由关键字 public private protected 来控制 这些关键字限定了该类的具体对象在类的外部对域的访问权限

19 Java 中类成员 ( 域和方法 ) 共有 4 种访问权限 : public: 可以被任何类访问 private: 只能被所属的类访问 protected: 可以被所在的类 同一包的其他类和不同包的子类访问 ; 缺省的 : 只能被同一包的类访问

20 例 3.3 在类的外部试图访问和修改该类的私有域将出现编译错误 //TestPerson.java public class TestPerson { public static void main(string args[]) { Person obj=new Person(" 张三 ", ' 男 ', new Birthday(1988,8,8), 1.75); obj.show(); System.out.println("======== 改变类中变量的取值 =========="); obj.name=" 王立 "; obj.birth=new Birthday(1988,1,20); obj.birth.show(); obj.show();

21 //Person.java public class Person { private String name; char sex; Birthday birth; double height; Person(String name, char sex, Birthday birth, double height) { this.name=name; this.sex=sex; this.birth=birth; this.height=height;

22 void show() { System.out.println(" 姓 System.out.println(" 性 birth.show(); System.out.println(" 性 名 :"+name); 别 :"+sex); 别 :"+height); //Birthday.java public class Birthday {

23 4. 封装和公开 面向对象的程序设计中, 通过类和类成员的访问控制级别的限定, 较好地解决了封装和公开的问题 在实际中最好把类中的成员变量用 protected 或 private 修饰, 使数据得到了封装 为了访问和修改这些数据, 必须提供 public 或 protected 的成员方法来获取或者设置

24 通常获取和设置 private 成员变量的方法命名采用以下形式 : [public protected] 变量类型 get 变量名 (){ return 变量名 ; =========================== [public protected] void set 变量名 ( 类型参数名 ) { 合法性检查并赋值 ; ===========================

25 5. 静态域 (static) 用 static 修饰的变量 静态变量 ( 静态域 ) 静态变量不属于任何一个类的具体对象, 而是所有对象共享 访问静态变量 : 类名. 静态变量 对象名. 静态变量

26 例 3.4 static 变量的含义和使用 //TestCar.java public class TestCar { public static void main(string args[]) { Car obj1=new Car(); Car obj2=new Car(); Car obj3=new Car();

27 System.out.println(" 创建 Car 类对象的个数 :"); System.out.println("Car.counter="+Car.counter); System.out.println("obj1.counter="+obj1.counter); System.out.println("obj2.counter="+obj2.counter); System.out.println("obj3.counter="+obj3.counter);

28 //Car.java public class Car { public static int counter=0; public Car() { counter++;

29 6. 最终域 (final) 若类的成员变量用 final 修饰, 则表明该变量一旦被初始化后就不能重新再赋值, 所以 final 修饰的变量通常是程序中不能改变的常量, 叫做最终域 通常,Java 中的 final 变量 常量, 用 static 修饰, 这样使用时直接用类名做前缀, 定义格式如下 : public static final 类型常量名 = 初始值 ;

30 7. 域的声明格式 类的域 ( 成员变量 ) 的声明格式 : [public protected private] [static] [final] [transient] [volatile] 类型变量名 ; [public protected private] // 访问权限 [static] [final] // 静态的 // 最终的 [transient] // 瞬态的 串行化对象时将忽略它 ( 第 6 章 ) [volatile] // 易逝的 用于修饰多个并发线程的共享变量 ( 第 4 章 )

31 3.1.4 静态方法 抽象方法和最终方法 1. 方法的访问控制修饰符 与变量一样 public private protected 缺省的 ( 没有访问控制修饰符 )

32 2. 静态 (static) 方法 与 static 变量一样, 静态方法不属于类的具体对象, 而是整个类的类方法 如果一个方法的运行与对象的状态 ( 对象变量的值 ) 无关, 那么该方法就应该声明为静态方法 调用静态方法的两种格式 : 类名. 静态方法 对象名. 静态方法

33 这里注意 : 静态方法中只能处理静态变量 静态方法中只能调用静态方法 静态变量和静态方法不能有 this 引用

34 例 3.5 静态方法中不能使用非静态量 方法 //UseStaticVar.java public class UseStaticVar { public int x=9; public static void main(string args[]) { System.out.println("x="+x); add(1); System.out.println("x="+x); public void add(int x) { this.x+=x;

35 程序的修改方法 : 通过类的对象访问 x 和调用 add 方法 UseStaticVar obj=new UseStaticVar(); obj.x; obj.add(1);

36 程序的修改方法 : 增加修饰符 public static int x=9; public static void add(int x) { this.x+=x;

37 3. 最终 (final) 方法 final 可用来修饰类中的方法, 称为最终方法 这样可以防止子类覆盖从父类继承而来的方法

38 4. 抽象 (abstract) 方法 用 abstract 修饰的方法, 称为抽象方法, 抽象方法只有方法头, 没有方法体, 而以一个分号结束 例如, public abstract double area(double x,double y); 抽象方法的声明通常出现的抽象类和接口中 显然, 方法修饰符 abstract 和 final 不可能同时使用

39 5. 方法的定义格式 方法的定义格式如下 : [public protected private] // 访问控制级别 [static] // 类方法 [final abstract] // 不能同时使用 [native] // 本地方法 [synchronized] // 同步方法返回值类型方法名 ( 参数列表 ) [throws 异常 ] {.;

40 3.1.5 构造方法 1. 构造方法规则 构造方法名字必须与类名相同 ; 构造方法一定不能有返回值类型 ; 访问控制修饰符 : public protected private 缺省的

41 构造方法不能用 static 修饰 ; 类中无任何构造方法, 编译器会自动生成无参数的构造方法 ; 类中定义构造方法, 编译器不会自动生成默认构造方法 ; 构造方法可以重载 重载的构造方法可以通过 this() 实现互相调用, 但必须是第一条语句 ; 子类的构造方法可以通过 super() 调用其直接父类的构造方法, 但必须是第一条语句

42 2. 构造方法的重载 例 3.6 构造方法的重载和相互调用 //TestBirthday.java public class TestBirthday { public static void main(string args[]) { Birthday obj1=new Birthday(); System.out.println(obj1.toString()); Birthday obj2=new Birthday(1990,11,12); System.out.println(obj2.toString());

43 //Birthday.java public class Birthday { private int year, month, day;// 分别表示年月日 public Birthday( ) { public Birthday(int year) { this(); this.year=year;

44 public Birthday(int year, int month) { this(year); this.month=month; public Birthday(int year, int month, int day) { this(year, month); this.day=day; public String tostring() { return " 出生年月 :"+year+" 年 "+month+" 月 "+day+" 日 ";

45 3.1.6 关键字 this 类定义中使用 this, 当创建该类的对象后,this 代表类对象自身 : this. 变量名 this. 方法名 静态变量和静态方法不能通过 this 做前缀来使用 重载的构造方法通过 this() 相互调用, 但必须是第一条语句

46 例 3.7 this 的使用 方法 1 //TestBirthday.java public class TestBirthday { public static void main(string args[]) { Birthday obj=new Birthday(1990,11,12); System.out.println(obj.toString()); String str=obj.setyear(1988).setmonth(8).setday(28). tostring(); System.out.println(str);

47 //Birthday.java public class Birthday { // 第 3~26 行与例 3.6 一样 public Birthday setyear(int year) { this.year=year; return this; public Birthday setmonth(int month) { this.month=month; return this; public Birthday setday(int day) { this.day=day; return this;

48 例 3.7 this 的使用 方法 2 //TestBirthday.java public class TestBirthday { public static void main(string args[]) { Birthday obj=new Birthday(1990,11,12); System.out.println(obj.toString()); obj.setyear(1988); obj.setmonth(8); obj.setday(28); String str=obj.tostring(); System.out.println(str);

49 //Birthday.java public class Birthday { // 第 3~26 行与例 3.6 一样 public void setyear(int year) { this.year=year; public void setmonth(int month) { this.month=month; public void setday(int day) { this.day=day;

50 3.1.7 抽象和封装 Java 编程的首要任务之一就是创造新的数据类型 类, 并描述这些数据类型对象之间的交互 抽象 : 通过对现实世界一类对象的共同属性和特征进行抽象, 并用计算机语言描述和实现, 从而解决许多实际问题

51 封装 : 通过包组织 设定类的访问权限和类成员的访问权限, 实现数据的封装 通过对象的封装, 实现了模块化和信息隐藏, 有利于程序的可移植性和安全性, 同时也有利于对复杂对象的管理

52 3.1.8 对象的清除 对象的生命周期分为三个阶段 : 生成 :new 运算符开辟内存空间, 构造方法完成对象初始化 ; 使用 : 利用对象名做前缀访问对象的变量, 调用对象的方法 ; 清除 : 不再使用的对象称为垃圾内存, 需要清除从而释放内存空间

53 垃圾自动收集机制 : Java 中清除无用对象所占据的内存空间是通过内存垃圾自动收集机制实现的 垃圾收集器自动扫描对象的动态内存区, 对所引用的对象加标记, 然后把没有引用的对象作为垃圾收集起来并释放内存

54 3.2 包的创建和使用 源文件结构 包 包 (package) 文件夹 包用来把一些相关的类 接口放在一起的组织结构 它是一个相对独立的软件单元, 可以理解为放置这些类和接口的文件夹

55 例如 : java.lang 包 java.applet 包 java.awt 包 java.io 包 javax.swing 包等包中也可以有子包, 例如 : java.awt.event 包

56 一个包中的类的完全限定名是 : 包名. 子包名. 类名 包的名字都小写 包名具有层次 分隔用句点例如,java.lang.Sytem 类 java.applet.applet 类 java.awt.graphics 类 java.util.arrays 类

57 3.2.2 创建包和使用包中的类 1. 创建包 包语句格式 : package 包名. 子包名 ; 包语句必须是 Java 源文件中的第一条语句 ( 除注释行外 ) 没有包定义语句, 则 java 认为它在缺省包 ( 没有包名的包 ) 中

58 例 3.8 创建包 //Birthday.java package mylib.myclasses; public class Birthday { private int year, month, day;// 分别表示年月日 public Birthday( ) {

59 public Birthday(int year) { this(); this.year=year; public Birthday(int year, int month) { this(year); this.month=month;

60 public Birthday(int year, int month, int day) { this(year, month); this.day=day; public String tostring() { return " 出生年月 :"+year+" 年 "+month+" 月 "+day+" 日 ";

61 public Birthday setyear(int year) { this.year=year; return this; public Birthday setmonth(int month) { this.month=month; return this;

62 public Birthday setday(int day) { this.day=day; return this;

63 2. 导入包中的类 import 包名. 类名 ; import 包名.*; 如果没有 import 语句, 也可以使用类的完全限定名 : 包名. 类名特别注意 : 在程序中导入用户自定义包中的类, 必须设置 classpath 环境变量的值, 指明导入类的出处, 否则编译出错

64 例 3.9 使用包中的类 //Test.java import mylib.myclasses.birthday; public class Test { public static void main(string args[]) { Birthday obj=new Birthday(1990,11,12); System.out.println(obj.toString());

65 String str=obj.setyear(1988).setmonth(8).setday(28). tostring(); System.out.println(str);

66 3.2.3 源文件结构和程序说明文档的生成 1. 源文件结构 源文件只能有一个公共类 (public class), 可包含多个非公共类 源文件名必须与公共类名完全相同 文件的后缀名为 java

67 创建包 (package) 的语句必须位于源文件的第 1 行 有导入 (import) 语句, 必须位于包语句和类声明之间 包语句和导入语句后是类的声明 ( 类头 ) 和放在花括号中的类体

68 类体中包含类的变量声明 构造方法定义和方法定义, 他们都放在类声明后面的花括号中 可以按任意顺序列出, 但通常类中先声明变量 后定义构造方法 再定义其他方法

69 没有导入语句, 则程序中使用该类的完全限定名 : 包名. 类名

70 2. 生成程序说明文档 文档注释 : /** 文档注释 */ 文档注释写在类声明 变量声明和方法定义的前面, 分别对类 变量和方法作出说明

71 文档注释可以对方法参数 返回值等进行说明 返回类型说明

72 在命令行使用 : javadoc 源程序名.java 可从 java 源程序中提取这些文档注释, 并生成具有 JavaAPI 文档风格的程序说明文档

73 例 3.10 生成文档注释 package mylib.myclasses.mygraph; /**MyPoint 类用来创建平面坐标系中的一个点 (x,y) */ public class MyPoint {

74 /** 点的 x 坐标 */ protected int x; /** 点的 x 坐标 */ protected int y; /** 构造方法, 点坐标值设置为 (0,0)*/ public MyPoint( ) { System.out.println(" 调用 MyPoint 类的无参数构造方法 ");

75 /** 构造方法, 创建一个坐标值为 (x,y) 的点 x 点的 x 坐标 y 点的 y 坐标 */ public MyPoint(int x,int y) { this.x=x; this.y=y;

76 /** 设置点的 x 坐标 x 用来给类中变量 x 赋值 */ public void setx(int x) { this.x=x; /** 得到点的 x 坐标 该方法返回点的 x 坐标 */ public int getx() { return x;

77 /** 设置点的 y 坐标 y 用来给类中变量 y 赋值 */ public void sety(int y) { this.y=y; /** 得到点的 y 坐标 该方法返回点的 y 坐标 */ public int gety() { return y;

78 /** 返回点坐标的字符串表示 (x,y) 该方法返回字符串 */ public String tostring() { return "("+x+","+y+")";

79 3.3 类的继承和多态 系 类的包含关系和继承关 当一个类定义中包含另一个类的实例时, 就是类的包含关系, 通常称为 HAS-A 关系 对象之间还有一种 IS-A 的关系, 在面向对象的程序设计中, 称为继承关系

80 汽车的 HAS-A 关系

81 水果的 IS-A 关系

82 在面向对象的程序设计中, 在设计对象模型时, 首先需要区分继承关系和包含关系 通过设计好的类层次结构, 利用类间的继承关系可以提高程序代码的重用性和程序的可扩展性

83 义 类成员的继承和重新定 1. 定义子类的格式 定义类 A 的子类 B 的格式 : [ 类的修饰符 ] class B extends A { 类的变量定义 ; 构造方法定义 ; 方法定义 ;

84 如果一个类没有使用关键字 extends 显示的指明其父类,Java 中默认其父类是 Object 类 Object 类是类层次结构的根,Java 中所有的类从根本上都继承自这个类 Object 类是 Java 中唯一没有父类的类 Object 类在 java.long 包中

85 2. 类成员的继承 子类继承某个父类后 : 子类便拥有了父类的所有非私有 (private) 变量和方法 如果子类有多个间接父类, 子类继承所有间接父类的非私有变量和方法

86 3. 子类添加成员 继承的目的是为了扩展父类 子类通过加入自己的变量和方法来实现其特有的属性和行为 子类比它的父类大 ( 成员更多 ), 但子类更具特殊性, 针对更具体的对象

87 4. 重新定义从父类继承来的成 员 变量隐藏和方法覆盖 子类可以把从父类继承来的不需要或者不恰当的变量和方法重新定义 变量隐藏 当父类的变量不适合子类时, 子类可以把从父类继承来的同名变量重新定义 这时子类可以通过以下的方式引用父类的同名变量 : super. 变量名

88 方法覆盖 如果从父类继承来的方法不能满足子类的功能要求, 子类可以重写该方法, 即方法覆盖 这时子类可以通过以下的方式调用父类的同名方法 : super. 方法名 ()

89 5. 方法覆盖的规则 子类覆盖父类的同名方法时, 必须满足 : 覆盖方法的返回类型 方法名称 参数列表必须与原方法的相同 覆盖方法不能比原方法访问性差 ( 即访问权限不允许缩小 ) 覆盖方法不能比原方法抛出更多的异常 被覆盖的方法不能是 final 类型, 因为 final 修饰的方法是无法覆盖的

90 被覆盖的方法不能为 private, 否则在其子类中只是新定义了一个方法, 并没有对其进行覆盖 被覆盖的方法不能为 static, 因为静态方法是在编译的时候把静态方法和类的引用类型进行匹配

91 6. 方法重载和方法覆盖的区别 方法的重载 : 指同一个类中定义多个同名方法, 它们的参数列表不同, 但可以有不同的返回值类型 重载方法调用时根据其参数类型 个数和顺序来区分

92 方法覆盖 : 子类把继承来的方法重新定义, 方法头一样, 但方法体不同, 即方法实现的功能不同, 从而满足子类自己的特殊要求

93 覆盖和重载的不同 : 方法覆盖要求参数列表必须一致, 而方法重载要求参数列表必须不一致 方法覆盖要求返回类型必须一致, 方法重载对此没有要求 方法覆盖只能用于子类覆盖父类的方法, 方法重载用于同一个类中的所有方法 ( 包括从父类中继承而来的方法 )

94 方法覆盖对方法的访问权限和抛出的异常有特殊的要求, 而方法重载在这方面没有任何限制 父类的一个方法只能被子类覆盖一次, 而一个方法可以在所有的类中可以被重载多次

95 例 3.11 点类 MyPoint 扩展到圆类 MyCircle //MyCircle.java package mylib.myclasses.mygraph; public class MyCircle extends MyPoint { protected int radius;// 声明圆的半径 public MyCircle( ) { System.out.println(" 调用 MyCircle 类的无参数构造方法 ");

96 public MyCircle(int x,int y, int radius) { /*super(x,y); // 调用父类有两个整型参数的构造方法 */ this.x=x; this.y=y; this.radius=radius;

97 public void setradius(int radius) { if(radius>0)// 确保半径不被修改为负数 this.radius=radius; public int getradius() { return radius; public double area() { return Math.PI*radius*radius;

98 public String tostring() { // 覆盖父类的方法 return " 圆心 :"+super.tostring()+"; 半径 :"+radius;

99 例 3.12 测试例 3.11 中的 MyCircle 类 //TestMyCircle.java import mylib.myclasses.mygraph.mycircle; public class TestMyCircle { public static void main(string args[]) {

100 MyCircle obj=new MyCircle(10,10,5); System.out.println(obj.toString()); System.out.println(" 圆的面积 : "+obj.area());

101 obj.setx(5); //obj.x=5; obj.sety(15); //obj.y=15; obj.setradius(10); //obj.radius=10; System.out.println(obj.toString()); System.out.println(" 圆的面积 : "+obj.area());

102 3.3.3 子类对父类构造方法的 调用 关键字 super 在子类中使用 super 做前缀可以引用被子类隐藏的父类的变量以及被子类覆盖的父类的方法 ; 子类构造方法中可以通过 super( 实际参数 ) 调用父类的构造方法, 但必须时第一条语句

103 关键字 super 的使用规则 : super. 变量名引用被子类隐藏的父类中的变量 ; super. 方法名调用被子类覆盖的父类中的方法 ; super( 参数 ) 子类构造方法中调用父类构造方法 注意, 构造方法中 this() 和 super() 只能使用其一

104 例 3.13 圆类 MyCircle 扩展到球类 MySphere //MySphere.java package mylib.myclasses.mygraph; public class MySphere extends MyCircle { protected int z; public MySphere( ) { System.out.println(" 调用 MySphere 类的无参数构造方法 ");

105 public MySphere(int x,int y, int z, int radius) { /*super(x,y,radius); // 调用父类有 3 个整型参数的构造方法 */ this.x=x; this.y=y; this.z=z; this.radius=radius;

106 public void setz(int z) {// 设置球心的 z 坐标 this.z=z; public int getz() { // 得到球心的 z 坐标 return z; public double area() { // 覆盖父类的同名方法, 求球的表面积 :4*Math.PI*r*r return 4*Math.PI*radius*radius;

107 public double volume() { // 子类添加的求球的体积的方法 :4*Math.PI*r*r*r/3 return 4*Math.PI*Math.pow(radius,3)/3; public String tostring() { // 覆盖父类的同名方法, 满足子类的要求 return " 球心 :"+"("+x+","+y+","+z+")"+"; 半径 :" +radius;

108 例 3.14 测试球类 MySphere //TestMySphere.java import mylib.myclasses.mygraph.mysphere; public class TestMySphere { public static void main(string args[]) {

109 MySphere obj=new MySphere(); obj.setx(5); obj.sety(15); obj.setz(25); obj.setradius(5); System.out.println(obj.toString()); System.out.println(" 球的面积 : "+obj.area()); System.out.println(" 球的体积 : "+obj.volume());

110 3.3.4 父类和子类对象的转换 Java 语言允许父类对象和子类的对象之间可进行类型转换 没有继承关系的类对象之间不可以进行类型转换 在继承链中, 子类向父类转换称为 向上转换, 父类向子类转换称为 向下转换 向上转换可以自动完成 ; 而向下转换必须采用强制类型转换, 即 ( 子类名 ) 父类对象

111 向上转换 : 子类向父类转换 MyCircle obj1=new MyCircle(8,8,5); MyCircle obj2=new MySphere(8,8,8,10); 当子类实例赋值给父类对象 obj2 后, obj2 引用的实际上是子类实例, 但通过 obj2 只能引用与父类同名的那些成员

112 向下转型 父类向子类转换 MyCircle obj1=new MyCircle(8,8,5); MySphere obj3=(mysphere) obj1; 注意 : 不能直接将父类的对象强制转换为子类类型, 只能将向上转型后的子类对象再次转换为子类类型, 如 MyCircle obj2=new MySphere(8,8,8,10); MySphere obj3=(mysphere) obj2;

113 例 3.15 运行多态性 父类和子类对象的转换 //TestMySphere.java import mylib.myclasses.mygraph.*; public class Test2 { public static void main(string args[]) { System.out.println("================="); MyPoint obj1=new MyPoint(1,1); System.out.println("\t"+obj1.toString());

114 System.out.println("================="); obj1=new MyCircle(2,2,2); System.out.println("\t"+obj1.toString()); if(obj1 instanceof MyCircle){ MyCircle obj2=(mycircle)obj1; System.out.println("\t 圆的面积 : "+obj2.area());

115 System.out.println("================="); obj1=new MySphere(3,3,3,3); System.out.println("\t"+obj1.toString()); if(obj1 instanceof MySphere) { MySphere obj3=(mysphere)obj1; System.out.println("\t 球的表面积 : "+obj3.area()); System.out.println("\t 球的体积 : "+obj3.volume());

116

117 例 :Java 程序运行的多态性 public class Demo { public static void main(string[] args){ // 借助多态, 一个主人可以给多个动物喂食 Master ma = new Master(); ma.feed(new Animal(), new Food()); ma.feed(new Cat(), new Fish()); ma.feed(new Dog(), new Bone()); // Master 类 class Master{ public void feed(animal an, Food f){ an.eat(f);

118 // Animal 类及其子类 class Animal{ public void eat(food f){ System.out.println(" 我是一个小动物, 正在吃 " + f.getfood()); class Cat extends Animal{ public void eat(food f){//cat 类覆盖了 Animal 类的 eat() 方法 System.out.println(" 我是一只小猫咪, 正在吃 " + f.getfood()); class Dog extends Animal{ public void eat(food f ){//Dog 类覆盖了 Animal 类的 eat() 方法 System.out.println(" 我是一只狗狗, 正在吃 " + f.getfood());

119 // Food 及其子类 class Food{ public String getfood(){ return 食物 "; class Fish extends Food{ public String getfood(){//fish 类覆盖了 Food 类的 getfood() 方法 return " 鱼 "; class Bone extends Food{ public String getfood (){//Bone 类覆盖了 Food 类的 getfood() 方法 return " 骨头 ";

120 运行结果 : 我是一个小动物, 正在吃事物我是一只小猫咪, 正在吃鱼我是一只狗狗, 正在吃骨头

121 3.3.5 抽象类和最终类 面向对象的程序设计中, 通常会定义一种表示抽象概念且不能被实例化的类, 其作用是为派生类提供一个恰当的父类, 这样的类就称为抽象类 从继承性的角度看, 它处于类层次关系的上层, 通常作为父类

122 1. 抽象类 (abstract) 抽象方法是只有方法头 没有方法体 如果一个类包含抽象方法, 则该类必须声明为 abstract 抽象类中还可以定义变量 构造方法和其它非抽象方法 没有具体实现父类所有抽象方法的子类仍然要声明为抽象类 抽象类不能创建具体实例

123 例 3.16 抽象类派生具体子类 //Animal.java package mylib.ani;// 创建 mylib.ani 包 public abstract class Animal { String str; public Animal(String s) { str=s; public abstract void eat(); // 抽象方法

124 //Horse.java package mylib.ani; public class Horse extends Animal { public Horse(String s) { super(s); public void eat() { System.out.println(" 马吃草 ");

125 //Pig.java package mylib.ani; public class Pig extends Animal{ public Pig(String s) { super(s); public void eat() { System.out.println(" 猪吃饲料 ");

126 例 3.17 测试运行多态性 //Test.java import mylib.ani.animal; import mylib.ani.horse; import mylib.ani.pig;

127 public class Test { public static void main(string args[]) { Horse h1=new Horse(" 马 "); Pig p1=new Pig(" 猪 "); h1.eat(); p1.eat();

128 System.out.println("==== 多态性 ===="); //Animal a=new Animal(); // 非法, 抽象类不能实例化 Animal a1=new Horse( 马 ); //Animal 类型的引用, 引用的是 Horse 实例 Animal a2=new Pig(" 猪 "); //Animal 类型的引用, 引用的是 Pig 实例 a1.eat(); a2.eat();

129 2. 最终类 (final) 最终类用 final 关键字修饰, 通常处在类层次结构中的底层 final 类通常是完成一定标准功能的类, 如 java.lang 中的 Math 类 final 类不能派生子类, 通常这是出于安全考虑, 如 java.lang 中的 String 类 类的修饰符 abstract 和 final 不可能同时修饰一个类

130 3.4 接口和接口的实现 接口概述 在面向对象的程序设计中, 类的继承可以分为单继承和多继承两种 如果一个类只能有一个直接父类, 称为单继承 如果一个类可以有多个直接父类, 称为多继承 Java 语言只支持类的单继承, 所以 Java 中类间的层次是树状结构, 而不是网状结构 这使得类间的关系相对简单, 简化了程序的结构, 但这种单继承并不能很好地描述现实问题

131 链 : 例如, 在某个项目开发中有如下一个继承 A -> B -> C -> D -> E, 如果需要为 C D E 类添加某些通用的功能, 同时不影响它们的父类 A 和 B 最简单的方法是让 C 类再继承另外一个父类, 然而 Java 是一种单继承的语言, 不能再让 C 类继承另外一个父类 此时, 可以通过接口 (interface) 来实现多继承

132 接口用 interface 关键字来声明 接口中只能定义静态常量和抽象方法 抽象方法只有方法头, 没有方法体 接口可以看做是 一种特殊的抽象类, 它比抽象类更加 抽象 接口只规定一个类必须完成的功能, 而不规定功能的具体实现方法 与类的继承类似, 接口也可以继承, 但 Java 中接口可以多继承, 即一个接口可以同时继承多个接口 同样, 一个类可以实现多个接口, 这就实现了与类的多继承相似的功能

133 3.4.2 自定义接口和实现接口 1. 如何自定义接口 定义接口 : [public] interface 接口名称 [extends 父接口名列表 ] { // 静态常量 [public][static][final] 数据类型变量名 = 常量值 ; // 抽象方法 [public][abstract] 返回值类型方法名 ( 参数列表 );

134 定义接口时, 常量和方法的修饰符可以省略 ; 但在类中具体实现接口的抽象方法时, 方法的修饰符不可以省略 和类一样, 接口也可以通过 extends 表示继承关系, 子接口继承父接口所有的属性和方法 不同的是, 接口支持多继承, 一个子接口可以同时继承多个父接口

135 例 3.18 定义接口 MyInterface, 接口中有一个常量 G=88 和抽象方法 show( ) 接口保存为 MyInterface.java, 并将编译后的字节码文件 MyInterface.class 放到 mylib.myclasses 包中

136 例 3.18 定义接口 //MyInterface.java package mylib.myclasses; public interface MyInterface { // 接口没有构造方法, 不能实例化 public static final double G=88; public abstract void show();

137 2. 如何实现接口 一个类实现接口的定义格式如下 : [ 修饰符 ] class 类名 [extends 父类名 ] implements 接口 A, 接口 B, { 类的成员变量和成员方法 ; 为接口 A 中的所有方法编写方法体, 实现接口 A; 为接口 B 中的所有方法编写方法体, 实现接口 B; 一个类实现接口后, 接口中的成员就被该类所拥有, 因此在单继承的情况通过实现多个接口达到了多继承的目的, 增加了类的功能

138 例 3.19 定义类 A, 演示类 A 如何实现例 3.18 中自定义的 MyInterface 接口 并将编译后的字节码文件 A.class 放到 mylib.myclasses 包中

139 例 3.19 实现接口 //A.java package mylib.myclasses; public class A implements MyInterface { String str; public A(String s) { str=s; public void show() { // 实现接口中的方法 System.out.println(str+ : G= +G); // 访问从接口继承而来的变量

140 3. 接口的多态使用 例 3.20 编写应用程序, 使用例 3.19 中的类 A, 演示接口的多态使用

141 例 3.20 接口多态 //Test.java import mylib.myclasses.a; import mylib.myclasses.myinterface; public class Test { public static void main(string args[]) { A obj1=new A( 类 A: ); // 创建 A 类的实例 obj1.show(); // 调用类 A 实现的接口中的方法 System.out.println("obj1.G="+obj1.G);

142 System.out.println("===== 接口的运行时多态 ======"); MyInterface obj2=new A( 类 A: ); // 接口类型的引用 obj2.show();// 根据引用的实际实例, 调用类 A 的 show 方法 System.out.println("obj2.G="+obj2.G);

143 3.4.3 Java 类库中的接口实现举例与类一样,Java 根据接口的相关性把接口也组织到不同的包中

144 在 java.awt.event 包中,KeyListener 是专门对键盘事件 (KeyEvent) 做出相应的接口 KeyListener 包含三个响应不同的抽象方 法 public interface KeyListener { public void keytyped(keyevent e);// 敲击时执行 public void keypressed(keyevent e);// 键压下时执行 public void keyreleased(keyevent e);// 键释放时执行

145 在 java.awt.event 包中,KeyEvent 是专门针对键盘事件而编写的类 KeyEvent 类的 getkeychar() 可以获取所敲击键盘代表的字符 例如, 敲击键盘字符键 r, 该方法返回字符 r

146 为了在小程序响应键盘事件, 需要通过 addkeylinstener 方法实现小程序对键盘的监听, 该方法是小程序从其间接父类 Component 继承而来 : public void addkeylistener(keylistener Listen); 由于接口不能被实例化, 所以方法参数 Listen 是 KeyListener 接口的引用,Listen 实际引用的是实现 KeyListener 的类对象

147 例如, 在对接口引用时, 实际引用的是实现该接口的类对象 : Handler handler = new MyHander(); public class MyHandler implements Handler{ public void Hellp(){ System.out.println( my Handler implements );

148 例 3.21 键盘事件 //TestKeyListener.java import java.applet.applet; import java.awt.graphics; import java.awt.color; import java.awt.event.keyevent; import java.awt.event.keylistener;

149 public class TestKeyListener extends Applet implements KeyListener { Color clr; public void init() { addkeylistener(this); // 增加对键盘事件的监听,this 代表小程序本身

150 public void keytyped(keyevent e) {// 实现接口中的抽象方法 if(e.getkeychar()=='r' e.getkeychar()=='r') clr=color.red; else if(e.getkeychar()=='g' e.getkeychar()=='g') clr=color.green; elseif(e.getkeychar()=='b' e.getkeychar()=='b') clr=color.blue; else clr=color.black; setbackground(clr);

151 public void keyreleased( KeyEvent e ) { public void keypressed( KeyEvent e ) {

152 3.5 内部类和匿名内部类 内部类 : 内部类 内部类是定义在一个类的类体中的类 内部类也可以包含变量和方法 内部类像外部类的变量和方法一样, 也是外部类的成员之一

153 则 : 1. 外部类访问内部类成员 外部类和内部类成员的相互访问的规 与外部类的变量和方法一样, 内部类可以直接访问外部类的成员 ( 包括 private 成员 ); 外部类不能直接使用外部类的成员, 但外部类通过创建内部类的实例来访问内部类的成员

154 内部类及成员的修饰符, 含义与前面讲过的类似 : public protected private static abstract final

155 内部类用 static 修饰 表明它是外部类的静态成员, 没有外部类实例时, 能够访问它

156 例 3.22 外部类和内部类成员的相互访问 //A.java package mylib.outin; public class A { // 外部类 A private String outstr; public A(String s) { outstr=s;

157 public void outmethod() { // 访问内部类成员的方法 B b1=new B(); // 创建内部类实例 System.out.println(" 内部类的变量 :"+b1.instr); b1.inmethod();

158 public class B { // 内部类 B public String instr=" 内部类的变量 "; public void inmethod() {// 访问外部类成员的方法 System.out.println(" 外部类的变量 :"+outstr);

159 2. 在外部类之外访问内部类的成员 因为内部类是外部类的成员, 如果内部类的访问权限是公有的, 可以用下面的方式访问内部类的成员 : 先创建外部类实例 A a=new A(" 外部类 A"); 通过外部类实例再创建内部类对象 A.B b=a.new B(); 通过内部类对象访问内部类中的成员 ( 但必须具备相应的访问权限 )

160 例 3.23 外部类之外访问内部类成员 //TestAB.java import mylib.outin.a; public class TestAB { public static void main(string args[]) { A a=new A( 外部类 A ); // 创建类 A 的实例 a a.outmethod(); // 调用类 A 的方法

161 System.out.println("==== 创建内部类实例 ===="); A.B b=a.new B(); // 通过外部类实例 a 创建内部类实例 b System.out.println( b.instr= +b.instr); // 访问内部类变量 b.inmethod(); // 调用内部类的方法

162 3. 利用内部类实现键盘事件处理 一个类实现接口必须为接口中的所有抽象方法编写方法体 如果接口中的方法比较多, 那么分别实现这些抽象方法是的程序代码增加很多 如果通过内部类来处理事件响应, 可以减少程序代码和增加程序的可读性

163 Java 中提供了键盘适配器 KeyAdapter 类, 该类通过添加空方法体实现了 KeyListener 接口中的 3 个抽象方法, 其定义如下 : Public class KeyAdapter implements KeyListener{ public void keytyped(keyevent e) public void keypressed(keyevent e) public void keyreleased(keyevent e)

164 例 3.24 用内部类实现键盘事件处理 //TestKeyListener.java import java.applet.applet; import java.awt.*; import java.awt.event.*; public class TestKeyListener extends Applet { Color clr;

165 public void init() { addkeylistener(new MyType()); // 增加对键盘事件的监听, 内部类 MyTpye 实现了 KeyListener 接口 class MyType extends KeyAdapter { // 定义内部类处理键盘事件

166 public void keytyped(keyevent e) { // 覆盖父类方法, 处理键盘敲击事件 if(e.getkeychar()=='r' e.getkeychar()=='r') clr=color.red; else if(e.getkeychar()=='g' e.getkeychar()=='g') clr=color.green; else if(e.getkeychar()=='b' e.getkeychar()=='b') clr=color.blue;

167 else clr=color.black; setbackground(clr);

168 3.5.2 匿名内部类 1. 什么是匿名内部类? 匿名内部类就是没有名字的内部类

169 例 3.25 匿名内部类的定义和使用 //Test.java public class Test { public static void main(string args[]) { Y b=new Y(); // 创建类 Y 的对象 b b.showy(); // 调用类 b 的方法

170 // 定义类 X class X { public void showx() { System.out.println(" 类 X 的方法 ");

171 // 定义类 Y class Y { // 定义匿名内部类, 它是类 X 的子类, 实例化赋值给 X 的对象 a X a=new X( ) { public void showx() { // 覆盖父类 X 的同名方法 System.out.println(" 匿名内部类 (X 的子类 ) 的方法 "); ;// 这里必须有分号

172 public void showy() { a.showx(); // 通过父类 X 的对象 a 调用匿名子类的 showx() 方法

173 处理 2. 利用匿名内部类实现键盘事件 匿名内部类是定义在一个表达式范围里的类, 可以用来给对象赋值, 更多的时候用来在事件处理中作为方法的参数 匿名内部类经常用在 Java 的各种事件处理中

174 例 3.26 匿名内部类处理键盘事件 //TestKeyListener.java import java.applet.applet; import java.awt.*; import java.awt.event.*; public class TestKeyListener extends Applet { Color clr;

175 public void init() {// 增加对键盘事件的监听 addkeylistener( new KeyAdapter() { // 定义并实例化匿名内部类 public void keytyped( KeyEvent e ) { // 覆盖 KeyAdapter 类的 keytyped 方法 if(e.getkeychar()= ='r' e.getkeychar()= ='R') clr=color.red;

176 else if(e.getkeychar()= ='g' e.getkeychar()= ='G') clr=color.green; else if(e.getkeychar()= ='b' e.getkeychar()= ='B') clr=color.blue; else clr=color.black; setbackground(clr); );