PowerPoint Template

Size: px

Start display at page:

Download "PowerPoint Template"

社拜庞
5 years ago
Views:

1 第五章类和继承

2 主要内容提要创建类管理继承实现嵌套的类

3 创建类

4 声明类基本语法 : <modifier> class <class_name> { [<attribute_declaration>] [<constructor_declaration>] [<method_declaration>] 上面的语法中, 关键字 class 和 class_name 是必须的, 其它都是可选的

5 类的声明 public 类是可以公共访问的 abstract 类不能被实例化 final 类不能被子类化 extends super 类的父类 implements interface 由类实现的接口

6 类体类体中一般包含如下的内容 : 构造器 : 用于初始化类的新对象变量的声明 : 对象的状态方法的定义 : 对象的行为

7 声明成员变量在类体中定义的变量和方法称为成员问题 : 构造器是不是成员? accesslevel 声明成员的访问级别 static 声明一个类成员 final 声明为常量 transient 声明成员变量不应该被串行化 volatile 防止编译器在成员上执行某些优化 type name 变量的类型和名称

8 声明成员变量 accesslevel 通过指定四个访问级别 (public, protected, package, private) 之一, 可以控制哪些其它类可以访问成员变量, 对方法的访问也采用相同的方式 static 声明这是一个类变量而不是实例变量, 同样也可以用来声明类方法 final 声明这个成员的值不能修改, 相当于声明一个常量

9 声明成员变量 transient 表明成员变量不应该被串行化 volatile 防止编译器在成员上执行某种优化 type 与其它变量一样, 成员变量也必须有类型, 可以是原始类型, 也可以是引用类型 Name 成员变量的名称可以是任何合法的标志符, 成员变量不能与同一类中的其它成员变量同名

10 定义方法

11 定义方法和类的定义一样, 方法定义有两个主要部分 : 方法声明和方法体方法声明中必须有的成分是方法的名称, 返回类型和一对圆括号 () 下表显示方法声明可能具有的所有成分 :

12 方法声明的描述 accesslevel: 与成员变量一样, 通过四个访问级别之一, 可以控制哪些其它类可以访问此方法 static:static 声明这个方法是一个类方法, 而不是实例方法 abstract: abstract 声明这个方法是一个抽象方法

13 方法声明的描述 final: 声明此方法不能被子类覆盖 native: 声明用其它语言实现的方法 synchronized: 声明同步的方法, 并发运行的线程常常调用在相同的数据上进行操作的方法

14 方法声明的描述 returntype: 方法必须声明它的返回值的数据类型 methodname: 方法的名称, 可以是任何合法的标志符 (paramlist): 通过方法的参数向方法传递信息 [throws exceptions]: 如果方法中抛出任何被检查的异常, 则方法的声明必须指出这些异常的类型

15 static 关键字 static 关键字用于变量, 方法和嵌套类的声明 ; static 关键字说明变量或者方法是和类相关, 而不是和某个特定的实例相关 ; static 关键字说明的变量一般称为类变量 ; static 关键字说明的方法一般称为类方法

16 类变量被类中所有的实例分享 public class Count { private int serialnumber; public static int counter = 0; public Count() { counter++; serialnumber = counter;

17 类方法 public class Count{ private int serialnumber; private static int counter = 0; public static int gettotalcount() { return counter; public Count() { counter++; serialnumber = counter;

18 类方法 public class TestCounter { Public static void main(string[] args) { System.out.println( Number of counter is + Count.getTotalCount()); Count count1 = new Count(); System.out.println( Number of counter is + Count.getTotalCount()); 程序输出 : Output: Number of counter is 0 Number of counter is 1

19 问题? public class Count1{ private int serialnumber; private static int counter = 0; public static int gettotalcount() { return serialnumber; Compile error: Non-static variable serianumber cannot be Referenced from a static context

20 命名方法方法的名称可以是任何合法的标志符 ; 一般约定 : 方法的名称是动词 ; 可以大小写混合, 第一个字母大写, 每个内部单词的首字母大写例如 : tostring compareto setx getx

21 方法的命名通常, 方法的命名在它的类中是唯一的, 但是在三种情况下, 方法和类或者子类中的其它方法同名 : 覆盖方法 ; 隐藏方法 ; 名称重载

22 覆盖方法和隐藏方法如果子类中的一个实例方法与父类中的实例方法具有相同的标记和返回类型, 这被称为子类的方法覆盖了父类方法 ; 如果子类中的一个类方法与父类中的类方法具有相同的标记, 则子类方法隐藏父类方法 ; 具有相同的标记是指方法的名称, 参数数量和参数类型都相同

23 名称重载 Java 语言支持方法的名称重载 ; 在同一个类中的多个方法如果有不同的参数列表, 那么这些方法可以同名 public class DataArtist {... public void draw(string s) {... public void draw(int i) {... public void draw(float f) {...

24 为类提供构造器所有类至少有一个构造器 ; 构造器用于初始化类的新对象, 由 new 操作符调用 ; 构造器与类同名 ; 构造器不是方法, 不能有返回类型 ; Java 平台支持构造器的重载 ; 为类提供构造器的时候, 应该指出构造器的意义

25 访问控制 private 只有这个类可以使用这个构造器 ; protected 只有这个类的子类和相同包中的类可以使用这个构造器 ; public 任何类都可以使用这个构造器 ; 无说明符 - 只有同一个包中的类可以使用这个构造器

26 将信息传递给方法或者构造器在定义方法或者构造器时, 需要声明变量, 包括变量的数量和类型 ; public double computepayment(double loanamt, double rate, double futurevalue, int numperiods) { double I, partial1, denominator, answer; I = rate / 100.0; partial1 = Math.pow((1 + I), (0.0 - numperiods)); denominator = (1 - partial1) / I; answer = ((-1 * loanamt) / denominator) - ((futurevalue * partial1) / denominator); return answer;

27 参数类型方法或者构造器中的参数可以是任何的数据类型, 包括原始类型和引用类型 ; Java 语言不允许将方法传递给方法, 但是可以将对象传递给方法, 然后调用此对象的方法

28 参数名称参数的名称在它的作用范围内是唯一的 ; 参数不能与同一个方法或者构造器中的另一个参数同名, 也不能与同一方法中的局部变量或异常处理参数同名 ; 参数可以与类的成员变量同名, 称为参数隐藏了成员变量 public class Circle { private int x, y, radius; public void setorigin(int x, int y) {...

29 按值传递参数是按值传递的, 当方法或者构造器被调用时, 它们接受被传递的变量的值 ; 当参数是原始类型时, 按值传递意味着方法不能修改参数的值 ; 当参数是引用类型时, 按值传递意味着方法不能改变此对象的引用, 但是可以调用对象的方法并修改对象的某些变量

30 按值传递 example1 public class Pen { private int redvalue, greenvalue, bluevalue;... //This method does not work as intended. public void getrgbcolor(int red, int green, int blue) { red = redvalue; green = greenvalue; blue = bluevalue;

31 按值传递 example2 public class RGBColor { public int red, green, blue; public class Pen { private int redvalue, greenvalue, bluevalue;... public void getrgbcolor(rgbcolor acolor) { acolor.red = redvalue; acolor.green = greenvalue; acolor.blue = bluevalue;

32 从方法返回值定义方法时必须声明方法的返回类型, 在方法体中, 使用 return 语句返回一个值 ; 任何声明为 void 的方法都不返回值, 而且不能包含 return 语句 ; 任何声明不为 void 的方法都必须包含 return 语句

33 从方法返回值返回值的数据类型必须匹配方法声明的返回类型 public boolean isempty() { if (items.size() == 0) { return true; else { return false;

34 从方法返回对象方法也可以返回引用类型 ; 当方法使用一个类作为返回类型时, 返回的对象必须是返回类型指定的类或者它的子类 ; 方法的返回类型还可以是接口, 在这种情况下, 返回的对象必须实现指定的接口

35 从方法返回对象 example public Number returnanumber() {... returnanumber 方法可以返回 ImaginaryNumber, 但是不能返回

36 this 关键字在实例方法或者构造器中,this 引用当前对象, 也就是被调用的方法或者构造器所属的对象 ; 通过 this 关键字, 可以在实例方法或者构造器中引用当前对象的任何成员 ; 主要原因是 : 方法或者构造器的参数隐藏了对象的成员变量

37 this 关键字 example public class HSBColor { private int hue, saturation, brightness; public HSBColor (int hue, int saturation, int brightness) { this.hue = hue; this.saturation = saturation; this.brightness = brightness;

38 显式构造器调用在构造器中, 可以使用 this 关键字调用同一类中的另一个构造器, 称为显式构造器调用 ; 编译器仍然根据构造器的参数判断调用的是哪一个构造器 ; 显式构造器调用必须是构造器的第一行语句

39 显式构造器调用 example public class Rectangle { private int x, y; private int width, height; public Rectangle() { this(0, 0, 0, 0); public Rectangle(int width, int height) { this(0, 0, width, height); public Rectangle(int x, int y, int width, int height) { this.x = x; this.y = y; this.width = width; this.height = height;...

40 控制对类成员的访问在 Java 语言中, 可以通过访问说明符控制其它类对某个类的成员变量或者方法的使用 ; Java 语言支持四个用于变量和方法的访问级别 :private,protected,public 和 package

41 访问级别 Specifier Same class Same package subclass world private X package X X protected X X X X* public X X X

42 private 用 private 修饰的变量或者方法只能被该类访问和修改 ; private 修饰符用来声明类的私有成员, 它提供了最高的保护级别 ; private 就象个人私有的秘密

43 protected 用 protected 说明的变量或者方法可以被三种类引用 : 同一类 ; 子类 ; 在同一个包中的其它类 protected 修饰的成员就象家庭的秘密

44 package package 也称为缺省访问控制符, 说明它具有缺省的访问控制特性 ; package 说明该类只能被同一个包中的类访问和修改 Package 修饰的成员类似于朋友间的秘密

45 public public 声明的类, 可以被所有的其它类访问和引用, 也就是公共的 ; public 修饰符意味着公共的, 没有秘密

46 example

47 example package One; public class Alpha { //member variables private int iamprivate = 1; int iampackage = 2; //package access protected int iamprotected = 3; public int iampublic = 4; //methods private void privatemethod() { System.out.println("iamprivate Method"); void packagemethod() { //package access System.out.println("iampackage Method"); protected void protectedmethod() { System.out.println( iamprotected Method );

48 example public void publicmethod() { System.out.println("iampublic Method"); public static void main(string[] args) { Alpha a = new Alpha(); 程序的输出结果 : a.privatemethod(); iamprivate Method //legal a.packagemethod(); iampackage//legal Method a.protectedmethod(); iamprotected//legal Method a.publicmethod(); iampublic Method //legal System.out.println("iamprivate: iamprivate: " + a.iamprivate); 1 //legal System.out.println("iampackage: iampackage: " + a.iampackage); 2 //legal System.out.println("iamprotected: iamprotected: " + a.iamprotected); 3 //legal System.out.println("iampublic: iampublic: " + a.iampublic); 4 //legal

49 example package One; public class Alpha {... public boolean isequalto(alpha anotheralpha) { if (this.iamprivate == anotheralpha.iamprivate) { //legal return true; else { return false; 具有相同类型的对象可以访问彼此的私有成员? 因为访问控制是在 class 级别的, 而不是在对象级别, 特别是同一类中的实例

50 example package One; public class DeltaOne { public static void main(string[] args) { Alpha a = new Alpha(); //a.privatemethod(); //illegal a.packagemethod(); //legal 程序的输出结果 : a.protectedmethod(); //legal iampackage Method a.publicmethod(); //legaliamprotected Method //System.out.println("iamprivate: iampublic " + a.iamprivate); Method //illegal System.out.println("iampackage: iampackage: " + a.iampackage); 2 //legal System.out.println("iamprotected: iamprotected: " + a.iamprotected); 3 //legal iampublic: 4 System.out.println("iampublic: " + a.iampublic); //legal The next class, AlphaTwo,2

51 example package Two; import One.*; public class AlphaTwo extends Alpha { public static void main(string[] args) { Alpha a = new Alpha(); //a.privatemethod(); //illegal //a.packagemethod(); //illegal 程序的输出结果 : iampublic Method //a.protectedmethod(); //illegal a.publicmethod(); //legal iampublic: 4 //System.out.println("iamprivate: iamprotected " + a.iamprivate); Method //illegal iamprotected: 3 //System.out.println("iampackage: " + a.iampackage); //illegal //System.out.println("iamprotected: " + a.iamprotected); //illegal System.out.println("iampublic: " + a.iampublic); //legal AlphaTwo a2 = new AlphaTwo(); a2.protectedmethod(); //legal System.out.println("iamprotected: " + a2.iamprotected); //legal

52 example package Two; import One.*; public class DeltaTwo { public static void main(string[] args) { Alpha alpha = new Alpha(); //alpha.privatemethod(); //illegal //alpha.packagemethod(); //illegal //alpha.protectedmethod(); //illegal alpha.publicmethod(); //legal 程序输出结果 : iampublic Method iampublic: 4 //System.out.println("iamprivate: " + a.iamprivate); //illegal //System.out.println("iampackage: " + a.iampackage); //illegal //System.out.println("iamprotected: " + a.iamprotected); //illegal System.out.println("iampublic: " + a.iampublic); //legal

53 实例和类成员 public class AClass { public int instanceinteger = 0; public int instancemethod() { return instanceinteger; public static int classinteger = 0; public static int classmethod() { return classinteger; public static void main(string[] args) { AClass aninstance = new AClass(); AClass anotherinstance = new AClass(); aninstance.instanceinteger = 1; anotherinstance.instanceinteger = 2; System.out.println(anInstance.instanceMethod()); System.out.println(anotherInstance.instanceMethod());

54 实例和类成员 //System.out.println(instanceMethod()); //illegal //System.out.println(instanceInteger); //illegal //Refer to class members through the class... AClass.classInteger = 7; System.out.println(classMethod()); 程序输出 : //...or through an instance. 1 System.out.println(anInstance.classMethod()); 2 //Instances share class variables 7 aninstance.classinteger = 9; 7 System.out.println(anInstance.classMethod()); 9 System.out.println(anotherInstance.classMethod()); 9

55 实例成员除非另外声明, 类中声明的成员就是实例成员 ; 运行时系统为程序的每个实例创建每个实例变量的拷贝 ; 只能通过对实例的引用访问实例成员和调用实例方法

56 类成员类成员是通过 static 修饰符声明的, 运行时系统为每个类分配一个类变量, 而不管创建了多少个这个类的实例这个类的所有实例共享这个类的类变量的相同拷贝, 即可以通过实例也可以通过类本身访问变量相同的, 即可以通过类, 也可以通过实例引用来访问类方法注意 : 当程序修改类变量的值时, 此修改对所有实例有效

57 类成员和实例成员

58 实例方法和类方法实例方法可以访问当前对象的实例变量, 也可以访问类变量 ; 类的所有实例将分享实例方法的实现 ; 类方法不能访问实例变量 ; 类方法可以在类中直接引用, 不需要通过实例来引用类方法

59 实例和类成员的初始化可以在类成员变量或者实例成员变量的声明中进行初始化 ; 例如 : class BedAndBreakfast { static final int MAX_CAPACITY = 10; boolean full = false;

60 初始化的限制必须以一个赋值语句表达初始化方式 ; 初始化表达式不能调用任何被声明为抛出非运行时异常的方法 ; 如果初始化表达式调用一个抛出时异常的方法, 那么它不能进行错误恢复

61 使用静态初始化块 import java.util.resourcebundle; class Errors { static ResourceBundle errorstrings; static { try { errorstrings = ResourceBundle.getBundle("ErrorStrings"); catch (java.util.missingresourceexception e) { // error recovery code here

62 使用静态初始化块 errorstrings 资源绑定必须在一个静态初始化块中初始化, 这是因为如果找不到绑定,getBundle 方法可以抛出一个异常, 代码应该执行错误恢复 errorstrings 是一个类成员, 所以它不能在构造器中进行初始化 ; 静态初始化块以 static 关键字开头, 然后是封闭在 { 中间的代码类可以有任意数量的静态初始化块, 静态初始化块可以出现在类体中任何位置 ; 运行时系统确保静态初始化块和静态初始化器按它们在源代码中出现的次序调用

63 初始化实例成员 import java.util.resourcebundle; class Errors { ResourceBundle errorstrings; Errors() { try { errorstrings = ResourceBundle.getBundle("ErrorStrings"); catch (java.util.missingresourceexception e) { // error recovery code here 对于实例变量的初始化, 可以将初始化代码放在类的构造器中

64 问题 public class IdentifyMyParts { public static int x = 7; public int y = 3; IdentifyMyParts 类包含多少个类变量? 名称是什么? IdentifyMyParts 类包含多少个实例变量? 名称是什么?

65 问题 IdentifyMyParts a = new IdentifyMyParts(); IdentifyMyParts b = new IdentifyMyParts(); a.y = 5; b.y = 6; a.x = 1; b.x = 2; System.out.println("a.y = " + a.y); System.out.println("b.y = " + b.y); System.out.println("a.x = " + a.x); System.out.println("b.x = " + b.x); 以上代码的输出是什么? 程序输出结果 : a.y=5 b.y=6 a.x=2 b.x=2

66 管理继承在 Java 语言中, 每个类只能有一个直接父类 ; Object 类在 java.lang 中定义

67 类的层次结构在 Java 语言中,Object 类是所有类中最一般化的类 ; Object 类定义并且实现了每个类都需要的行为 ; 从 Object 类派生了许多类, 从这些类又派生了许多类, 从而构成了一个类层次结构

68 类的层次结构在这个类层次结构的顶层,Object 类是所有类中最一般化的类 ; 越接近这个层次结构底部的类提供越特殊化的行为 ; 越接近这个层次结构顶部的类提供越共性的行为 : 子类从另一个类派生出来 ; 父类指一个类的直接祖先或者它的任何祖先类 ; 每个类有且只有一个直接父类

69 类的层次结构子类从它的父类继承了所有的成员变量和方法 ; 子类可能不能访问继承的成员变量或者方法 ; 注意 : 构造器不是成员, 所以不能被子类继承

70 继承成员子类从父类中继承声明为 public 或者 protected 的成员 ; 子类如果和父类在同一个 package 中, 则子类从父类中继承声明为 package 或者没有修饰符的成员 ; 如果子类中声明的成员名和父类中的成员名相同的话, 则子类不继承这个成员名

71 隐藏成员变量子类中的成员变量隐藏父类中的同名变量 ; 在为成员变量命名的时候, 需要小心只隐藏需要隐藏的成员变量 ; 在 Java 语言中, 需要注意的是可以通过父类访问被隐藏的成员变量

72 覆盖方法如果子类中的一个实例方法与父类中的一个实例方法具有相同的名称和返回类型, 就称为子类方法覆盖了父类方法子类可以从父类中继承方法, 同时按照要求进行修改进行覆盖的方法与它所覆盖的方法具有相同的名称, 参数数量和类型以及返回类型覆盖方法的访问说明符允许的访问可以比被覆盖的方法多, 但是不能少

73 example public class Employee{ protected String name; protected double salary; protected Data birthdate; public String getdetails() { return name: + name + \n + salary: + salary; public class Manager extends Employee{ protected String department; public String getdetails() { return name: + name + \n + salary: + salary + \n + manager of: + department;

74 重载方法 Java 编程语言允许通过改变方法参数的数量和类型来重载方法, 也可以重载父类中的方法在编写与父类方法同名的方法时, 一定要注意检查返回类型和参数列表, 确保正确的重载或者覆盖

75 重载方法 public class MyClass { private int anint = 4; //Overrides tostring in Object class. public String tostring() { return "Instance of MyClass. anint = " + anint; //Overloads tostring method name to provide additional functionality. public String tostring(string prefix) { return prefix + ": " + tostring();

76 隐藏方法如果子类中定义的类方法与父类中的类方法具有相同的标记, 就称为子类方法隐藏了父类方法下面来看看覆盖和隐藏的区别 :

77 example public class Planet { public static void hide() { System.out.println("The hide method in Planet."); public void override() { System.out.println("The override method in Planet.");

78 example public class Earth extends Planet { public static void hide() { System.out.println("The hide method in Earth."); public void override() { System.out.println("The override method in Earth."); public static void main(string[] args) { Earth myearth = new Earth(); Planet myplanet = (Planet)myEarth; myplanet.hide(); myplanet.override(); 程序输出结果 : The hide method in Planet. The override method in Earth.

79 方法的覆盖和方法的隐藏实例方法不能覆盖静态方法 ; 静态方法不能隐藏实例方法

80 子类不能覆盖的方法子类不能覆盖父类中被声明为 final 的方法 ; 如果试图覆盖 final 方法, 则编译器会报错子类不能覆盖父类中的类方法

81 子类必须覆盖的方法子类必须覆盖父类中声明为 abstract 的方法 ; 否则子类本身必须是抽象的

82 隐藏成员变量在类中, 如果一个成员变量和父类中的成员变量同名, 即使类型不同, 那么子类中的成员隐藏父类中的成员在子类中, 不能通过简单名称引用父类中的成员变量, 必须通过 super 关键字

83 super 关键字如果父类中的成员变量被隐藏, 需要使用 super 关键字来引用 ; 同样, 如果子类方法覆盖了父类方法, 也需要使用 super 关键字来引用 ; 例如 : super.overriddenmethodname();

84 example public class Superclass { public boolean avariable; public void amethod() { avariable = true; 程序输出结果 : false public class Subclass extends Superclass { public boolean avariable; //hides avariable in Superclass true public void amethod() { //overrides amethod in Superclass avariable = false; super.amethod(); System.out.println(aVariable); System.out.println(super.aVariable);

85 调用父类的构造器在子类构造器中使用 super 调用父类的构造器 ; 如果存在显式的父类构造器调用, 则必须是子类构造器中的第一个语句 ; 如果构造器没有显式调用父类构造器, 那么 Java 运行时系统在执行此构造器中的任何语句之前自动调用父类的无参数构造器

86 example class AnimationThread extends Thread { int framespersecond; int numimages; Image[] images; AnimationThread(int fps, int num) { super("animationthread"); this.framespersecond = fps; this.numimages = num; this.images = new Image[numImages]; for (int i = 0; i <= numimages; i++) {... // Load all the images

87 使用 Object 的后代 Object 类位于类层次结构的顶端, 每个类都是 Object 类的直接或者间接后代 ; Object 类定义了所有类都必须有的基本状态和行为 : clone equals and hashcode finalize tostring getclass notify, notifyall, and wait

88 覆盖 Object 方法 Object 类中的这些方法声明为 final, 子类不可以覆盖这些方法 : getclass notify notifyall wait

89 clone 方法使用 clone 方法从一个现有的对象创建一个对象 ; acloneableobject.clone(); Object 对这个方法的实现检查当前对象是否实现了 Cloneable 接口, 如果此对象没有实现 Cloneable 接口, 那么此方法抛出一个 CloneNotSupportedException 异常使用 clone 最简单的方法是 : 在类的声明中添加 implements Cloneable

90 equals and hashcode 方法 equals 方法比较两个对象是否相等, 如果相等则返回 true; hashcode 方法返回的是值是一个 int, 它将对象映射到散列表中的存储桶, 一个对象必须总是产生相同的散列编码

91 finalize 方法 finalize 方法在对象被垃圾收集器收集前清楚对象 ; 系统自动调用 finalize 方法, 而且大多数类不需要覆盖它

92 getclass 方法 getclass 方法返回一个对象的类的运行时表示 ; 这个方法返回一个 Class 对象 ; 通过这个对象查询关于这个类的信息, 包括它的名称, 它的父类以及接口的信息等 void PrintClassName(Object obj) { System.out.println("The Object's class is " + obj.getclass().getname());

93 tostring 方法 tostring 方法返回对象的字符串表示 ; 可以使用 tostring 方法和 System.out.println 显示对象

94 final 关键字不能子类化一个 final class; 不能覆盖一个 final method; 声明为 final 的变量是常量的概念 ; 如果一个引用类型的变量声明为 final, 将出现什么问题?

95 final class 通过防止系统被改版来提高系统安全性, 要防止这种破坏, 可以将类声明为 final, 由此防止创建任何子类 ; 为了实现优良的面向对象程序设计, 例如 : final class ChessAlgorithm{

96 final 方法如果将整个类声明为 final 超出了需要, 可以将类的某些方法或者全部方法声明为 final; 在方法声明中使用 final 关键字标志这个方法不能被子类覆盖 ; 如果一个方法的实现不应该被修改, 而且对于保持对象的一致状态很重要, 则声明为 final 方法

97 抽象类有时定义的类表示一个抽象概念, 这样的类不应该被实例化 ; 将类声明为抽象类的办法是 : 在声明中的 class 关键字前使用 abstract 关键字, 如果试图对抽象类进行实例化, 编译器会显示错误信息, 例如 : abstract class Number {

98 抽象方法抽象类可以包含抽象方法, 即没有实现的方法 ; 抽象类可以以这种方式为它的子类定义一个完整的编程接口, 而且允许它的子类填充这些方法的实现细节 ; 抽象类应该提供至少一个方法的完整实现或者部分实现 ; 如果抽象类只包含抽象方法的声明, 那么它应该实现为接口

99 example 在一个面向对象的绘图应用程序中, 可以绘制圆矩形和直线等, 这些图形对象都有某些状态和行为, 可以利用这种相似性, 将它们声明为同一个父对象继承这些状态和行为

100 example abstract class GraphicObject { int x, y;... void moveto(int newx, int newy) {... abstract void draw();{ 抽象类不必包含抽象方法 ; class Circle extends GraphicObject { void draw() {... class Rectangle extends GraphicObject { void draw() { 如果一个类包含抽象方法, 或者没有为它的父类... 实现抽象方法, 这个类必须声明为抽象类

101 example 这个例子是计算公司的交通工具的消耗 : public abstract class Vehicle { public abstract double calcufuelefficiency(); public abstract double calctripdistance(); public class class Truck RiverBarge extends extends Vehicle Vehicle { { public public Truck(double RiverBarge(double max_load) max_load) { { public public double calcfuelefficiency() { { // calculate /* calculate the fuel the consumption fuel consumption of a truck of a at river a given barge load at a given load*/ public public double double calctripdistance() { { // calculate /* calculate the distance the distance of this of trip this on trip highway on river-ways */

102 问题 public class ClassA { public void methodone(int i) { public void methodtwo(int i) { public static void methodthree(int i) { public static void methodfour(int i) { public class ClassB extends ClassA { public static void methodone(int i) { public void methodtwo(int i) { public void methodthree(int i) { public static void methodfour(int i) { 哪些方法覆盖了父类中的方法? 哪些方法隐藏了父类中的方法? 其它方法做什么事情?

103 实现嵌套的类可以定义一个类为另一个类的成员, 这样的类称为嵌套的类定义 : 嵌套类是另一个的成员 class EnclosingClass {... class ANestedClass {...

104 example public class Outer1 { private int size; public class Inner { public void dostuff() { size ++; public void testtheinner() { Inner i = new Inner(); i.dostuff();

105 嵌套类的作用使用嵌套类来反映并实施两个类之间的关系 ; 当嵌套类只在包含它的类中有意义时, 或者它依赖于包含它的类来实现功能时例如 : 文本形状的光标, 只有在文本编缉时才有用 ; 存盘, 只有在文件打开的情况下才有用嵌套类可以访问包含它的类的成员, 即使这些成员是私有的

106 嵌套类的分类 class EnclosingClass {... static class StaticNestedClass {... class InnerClass {... 嵌套类可以声明为静态的或者非静态的 ; 有 static 修饰符说明的称为静态的嵌套类 ; 无 static 修饰符说明的称为内部类

107 嵌套类的特点静态的嵌套类与包含它的类相关联 ; 静态的嵌套类不能直接引用包含它的类中定义的实例变量或者实例方法, 只能通过对象来引用 ; 内部类与包含它的类的实例相关联, 可以直接访问此对象的实例变量和实例方法 ; 内部类因为和实例相关联, 所以它不能定义任何静态成员

108 两者的区别静态的嵌套类反映两个类之间的句法关系, 即在句法上一个类的代码出现在另一个类的代码内内部类反映两个类的实例之间的关系

109 嵌套类的其它问题嵌套类可以声明为 abstract 或者 final; 可以使用访问说明符来限制对嵌套类的访问 ; 任何嵌套类都可以在任何代码块中声明, 包括在方法体中声明

110 欢迎提问

OOP with Java 通知 Project 4: 4 月 18 日晚 9 点关于抄袭没有分数

OOP with Java Yuanbin Wu cs@ecnu OOP with Java 通知 Project 4: 4 月 18 日晚 9 点关于抄袭没有分数复习类的复用组合 (composition): has-a 关系 class MyType { public int i; public double d; public char c; public void set(double