何对象存在, 所以, 如果不将它设置为类相关的, 则没有办法得到任何的对象, 也就无法调用这个 main() 方法知识准备 :static 变量的引用方法 1. 通过对象定位变量在节中我们定义了 StaticTest 类, 并在类中定义了 static 变量现在我们通

Size: px

Start display at page:

Download "何对象存在, 所以, 如果不将它设置为类相关的, 则没有办法得到任何的对象, 也就无法调用这个 main() 方法知识准备 :static 变量的引用方法 1. 通过对象定位变量在节中我们定义了 StaticTest 类, 并在类中定义了 static 变量现在我们通"

旻孙
5 years ago
Views:

1 第 7 章高级类特性本章详细介绍 static 变量方法和初始化段的概念和用法 ;final 数据方法和类的用法 ; 抽象类和接口的概念, 以及它们之间的联系和区别 ; 多态概念以及内部类的概念和用法 ; 最后, 对一些常用的修饰符做了一个简单的总结 7.1 static 关键字知识准备 :static 概述通常我们在创建一个类时, 是在描述那个类的对象的外观与行为只有用 new 创建那个类的对象, 数据存储空间才被分配, 其方法才供外界调用但是有如下两种情形 : 第一种是只想为特定域分配单一的存储空间, 不考虑究竟创建多少个对象, 甚至根本就不用创建任何对象 ; 另一种是, 希望某个方法不与包含它的类的任何对象关联在一起, 也就是说即使没有创建对象, 也可以调用这个方法通过 static 关键字可以满足这两方面的需要使用时, 在声明类的成员如方法属性乃至自由代码块前面加上 static 这个修饰符 : public class StaticTest { // 静态变量 static int i = 27; // 静态方法 static void staticmethod(){ StaticTest.i++; 实例变量用于描述单个实例的状态, 而类变量用于描述类的状态, 和具体的实例无关实例方法用于操作实例变量并维护特定实例的状态, 而类方法并不了解单个实例的状态在 Java 中,static 最常用在 Java 应用程序的入口方法 main() 前面, 用于修饰 main() 方法, 表示 main() 方法是一个类方法我们在执行一个应用程序的时候, 解析器将会寻找这个 main() 方法, 之所以将它设置为类方法, 是因为在调用这个 main() 方法之前, 还没有任

何对象存在, 所以, 如果不将它设置为类相关的, 则没有办法得到任何的对象, 也就无法调用这个 main() 方法 7.1.

main(string args[]) { StaticTest st1 = new StaticTest(); StaticTest st2 = new StaticTest(); System.out.println(st1.i + st2.

2 何对象存在, 所以, 如果不将它设置为类相关的, 则没有办法得到任何的对象, 也就无法调用这个 main() 方法知识准备 :static 变量的引用方法 1. 通过对象定位变量在节中我们定义了 StaticTest 类, 并在类中定义了 static 变量现在我们通过创建对象来引用它 : public class StaticTest { static int i = 27; public static void main(string args[]) { StaticTest st1 = new StaticTest(); StaticTest st2 = new StaticTest(); System.out.println(st1.i + st2.i); 现在, 尽管我们创建了两个 StaticTest 对象, 但它们仍然只占据 StaticTest.i 的一个存储空间这两个对象都共享同样的 i 此时,st1.i 还是 st2.i 都有同样的值通过类名直接引用我们可以直接通过类名来引用 static 变量, 这对非静态成员是不行的例如, 语句 StaticTest.i++; 引用 static 变量的首选方式是通过类名调用, 一方面这样强调了变量的 static 结构, 另一方面在某些时候也方便了编译器进行优化类似的逻辑也应用于静态方法, 我们可以像调用其他方法一样通过一个对象来引用, 或者可以通过特殊语法形式 ClassName.method() 加以引用注意 : 静态方法中只能调用类中的静态成员 7.2 final 关键字在 Java 的类方法和变量前面可以加上 final 关键字,final 关键字表示它修饰的类方法或变量不可被改变知识准备 :final 数据 16

第 7 章高级类特性 final 数据可以是编译时不改变值的常量, 因为在 Java 中不能使用 const 保留字来定义常量, 所以在需要使用常量的场合, 可以使用 final 关键字来修饰比如 : final int CONST_VAR=30; 在对这个常量进行定义的时候, 必须对其进行赋值变量的值一旦初始化后, 就不能被改变如果 final 变量是引用类型的变量,

3 第 7 章高级类特性 final 数据可以是编译时不改变值的常量, 因为在 Java 中不能使用 const 保留字来定义常量, 所以在需要使用常量的场合, 可以使用 final 关键字来修饰比如 : final int CONST_VAR=30; 在对这个常量进行定义的时候, 必须对其进行赋值变量的值一旦初始化后, 就不能被改变如果 final 变量是引用类型的变量, 那么代表你不能改变这个变量的引用一旦引用被初始化指向一个对象, 就无法再把它改为指向另一个对象但是可以改变这个变量所引用的对象的属性我们来看下面这个例子源文件 :TestFinal.java class Aclass { private int a; // 构造器 public Aclass() { a = 100; public void seta(int thea) { a = thea; public int geta() { return a; // 定义一个类来测试 final 应用变量 public class TestFinal { final Aclass aclass = new Aclass(); public static void main(string[] args) { TestFinal tf = new TestFinal(); tf.aclass.seta(1); System.out.println(tf.aClass.getA()); 在这个例子中, 我们定义了一个类 Aclass, 这个类有一个实例变量 a, 并且有相应的存取方法来对它进行存取然后, 在类 TestFinal 中, 我们定义了一个 final 的应用类型的变量 aclass, 这个变量的引用是不能被改变的, 但是, 我们可以修改这个引用变量指向的对象属性, 我们通过调用实例的 seta 方法来修改它的实例变量 a, 这个时候这个静态引用变量指向的对象的属性值被修改成了 1 17

4 在编程实践中, 我们还经常使用静态常量, 也就是同时用 static 和 final 来修饰变量一个既是 static 又是 final 的域只占据一段不能改变的存储空间提示 : 根据 Java 命名规范, 如果在编译的时候, 就可以确定 final 变量的值, 那么, 此常量的名字应该都大写, 并且指出完整含义, 如果需要用几个单词描述, 那么单词之间用 _ 来分隔, 例如 : static final int MAX_TAX_RATE = 20; 相反的, 在下面情况下可以不使用上面的命名规则 : final 变量无法在编译的时候就获得值, 而必须在执行的时候才能得到值比如, 我们在节的示例中的 final 变量 aclass: final Aclass aclass = new Aclass(); 在编译的时候, 程序不会执行 new 动作来实例化一个 Aclass, 并赋值给 aclass, 所以, 就没有使用上面的命名规则来给 final 变量命名知识准备 :final 方法 final 关键字可以将方法锁定, 以防任何继承类修改它的含义, 确保在继承中使方法的行为保持不变, 并且不会被覆盖比如, 下面的例子中, 类 B 编译不会通过, 因为它试图覆盖父类中的一个 final 方法父类 : public class A{ public final void methoda(){ // 子类 : public class B extends A { // 此处报错, 因为它试图覆盖父类中的静态方法 public void methoda() { 如果将父类 A 中的 methoda() 改成 private 的, 代码如下父类 : public class A { private final void methoda() { 子类 : public class B extends A { // 此处不报错, 因为它只定义了一个 methoda() public void methoda() 18

5 第 7 章高级类特性 { 注意, 类 A 中的 methoda(), 它的访问修饰符为 private, 此时, 方法 methoda() 被隐式指定为 final 由于无法取用 private 方法, 所以也就无法覆盖它因此, 类 B 中的 methoda() 只是新定义的一个方法而不是覆盖父类的方法所以, 此时编译这个程序将不会报错知识准备 :final 类如果将 final 关键字放至类的定义之前, 则将这个类的整体定义为 final 这样的类不可以被继承, 比如 java.lang.math 如果不希望你的类被继承, 可以将类定义为 final 类, 该类的设计永远不需要做任何变动, 也不会存在子类注意 : final 类中所有的方法都隐式指定为 final, 因为无法覆盖它们在 final 类中可以给方法添加 final 修饰词, 但这不会有任何意义 7.3 抽象类知识准备 :abstract 概述抽象的概念我们其实并不陌生, 抽象其实就是从众多的事物中抽取出共同的本质性的特征, 而舍弃其非本质的特征例如苹果香蕉生梨葡萄桃子等, 它们共同的特性就是水果得出水果概念的过程, 就是抽象的过程在编写一个对象的时候, 我们会将某一类事物的共同特征抽象出来, 编写一个框架类在这个类中我们可能会对一些类的方法进行定义, 但是并不具体实现而是将这些方法的实现放到它的子类中去, 不同的子类可以用不同的方式来实现这些方法, 这样可以增强类设计的灵活性比如, 我们定义了一个表示制作手机图标的基础图形的类 IconShape, 这个类有一些属性, 还有一个用于计算图标面积的方法, 但是, 对于不同形状的图标, 计算方式是不同的, 我们不能将所有形状图标的计算方式都放入这一个类中, 那样这个类将很大很混乱通过关键字 abstract, 我们可以在父类 IconShape 中不实现这个方法, 而将它的实现放到子类中去这样不同的子类就可以以不同的方式实现父类中的抽象方法从上面的讨论中可以看出来, 我们有时候只是定义某些类的框架作为导出类的通用接口, 但不具体实现, 而将具体实现放到子类中去完成这个时候, 我们可以将这个类定义为 abstract 的, 而将没有实现的方法声明为 abstract 19

6 问 : 抽象类可以被实例化吗? 答 : 不可以, 因为 abstract 类中具有没有被实现的方法, 所以, 抽象类不能被实例化知识准备 :abstract class 包含抽象方法的类叫做抽象类定义方法如下 : public abstract class IconShape { /* 成员变量声明 */ // 抽象方法 public abstract double iconarea(); 在类名之前加 abstract 关键字, 就可以将一个类定义为抽象类在抽象类中定义抽象方法是在方法返回值类型之前加上关键字 abstract 抽象方法只需要声明, 不需要实现如果一个类中定义了一个或多个抽象方法, 那么这个类必须被限定为抽象类但是反过来, 抽象类里面并非一定要有抽象方法比如当你定义了一个类, 但是又不想让它被直接实例化的时候, 可以使用抽象类的方法来实现子类继承抽象类时, 语法和继承普通父类相同例如 : public class Circle extends IconShape { public double radius;// 半径 public static final double PI = 3.1; /** 实现父类抽象方法 : 求圆形面积 */ public double iconarea () { return PI * radius * radius; 注意 : 子类必须覆盖所有抽象方法才能被实例化, 否则这个子类还是个抽象类总结一下, 在以下任一条件成立时, 类必须定义成抽象类 : 类中有至少一个抽象方法类继承了父类中的抽象方法, 但是至少有一个抽象方法没有实现类实现了某个接口, 但没有全部实现接口中的方法任务一 :abstract 实例 150

7 第 7 章高级类特性 1. 任务描述完成节中 IconShape 抽象类的定义和继承的实例, 要求有完整的类的定义及对象初始化 2. 技能要点掌握抽象类和抽象方法的定义掌握继承抽象类的方法, 掌握继承抽象类全部抽象方法和部分抽象方法时子类定义的区别 3. 任务实现过程 (1) 首先我们定义一个用来表示各种图标形状的类 IconShape, 这个类有两个抽象方法, 一个用于返回图形的形状, 一个用于返回图形的面积源文件 :IconShape.java public abstract class IconShape { private String color; /** * 得出面积 */ public abstract double iconarea (); /** * 得到形状 */ public abstract String gettype(); // 用于设置 / 获取颜色属性的方法 public String getcolor() { return color; public void setcolor(string thecolor) { color = thecolor; 注意, 这是一个抽象类, 不能直接实例化它 (2) 编写类, 代码如下源文件 :IconSquare.java public abstract class IconSquare extends IconShape { protected double a, b; public IconSquare() { 151

8 this.a = 0.0; this.b = 0.0; public IconSquare (double i, double j) { this.a = i; this.a = j; /** * 实现父类中的抽象方法 */ public double iconarea () { return a*b; 这是一个表示长方形的类我们注意到, 这个类继承了父类 IconShape, 在父类的基础上新增了一些属性及相应的方法在此类中实现了父类中的 iconarea() 方法, 返回长方形面积但是并没有实现父类中另一抽象方法 gettype(), 也许需要子类进一步细化图形是长方形还是正方形所以, 此类也要定义为 abstract 抽象类当然, 这里只是为了让大家理解继承抽象类的机制, 在实际操作中不需要这样细化 (3) 再编写一个类表示圆形代码如下源文件 :IconCircle.java public class IconCircle extends Shapes { private double radius; public static final double PI = 3.1; public IconCircle() { this.radius = 0.0; public IconeCircle(double r) { this.radius = r; /** * 实现父类的抽象方法 */ public double iconarea() { ; return PI * radius * radius 152 public String gettype() { return " 圆 ";

9 第 7 章高级类特性 public static void main(string args[]) { IconCircle ic = new IconCircle(6); System.out.println(" 图标形状 :" + sc.gettype()); System.out.println(" 图标面积 :" + sc.iconarea()); IconCircle 类也继承了类 IconShapes, 并且覆盖了父类中的两个抽象方法但它对抽象方法 iconarea() 的实现方式和 IconSquare 是不一样的创建抽象类和抽象方法很有用, 它们可以使类的抽象性明确, 让使用者明白如何使用它们, 而且抽象类还是很有用的重用工具注意 : 区分没有实现的方法和空方法, 下面这个方法是没有实现的方法 : public int methoda(); 而下面这个方法是空方法体的方法 : public int methodb() { 没有实现的方法可以用 abstract 来修饰, 而空方法体方法却不能使用 abstract 来修饰, 它已经实现了方法, 只是在这个方法中什么动作也没有做而已 7.3. 知识拓展 : 模板设计模式有时候, 我们会碰到另外的一种情况, 比如, 银行利息的计算, 都是利率乘以本金和存款时间, 但是, 各种存款方式计算利率的方式都不同, 一般而言, 定期的存款利率比活期的利率要高 ; 而定期的时间越长, 它的利率也越高因此, 在设计银行账户这个类的时候, 可以将计算利息这个方法定义成抽象方法, 然后, 再在各种不同类型账号的子类中具体实现这个方法但是, 对于这个方法而言, 有更好的一种设计思路 : 将这个方法中计算利息的算法骨架搭建出来, 而对于一些细节, 推迟到子类中来实现这种设计的好处是, 避免了子类设计中的随意性我们来看上面这个思路的实现方式源文件 :LoanAccount.java abstract class LoanAccount { // 利息 private double interest; // 本金 private double fund; 153

10 public double calculateinterest() { // 用于计算利息的算法 : 本金 * 利率, // 但是利率的算法实现并没有在这个类中实现 interest = getfund() * getinterestrate(); System.out.println(interest); return interest; public void setfund(double fund) { this.fund = fund; public double getfund() { return this.fund; /** * 不同的存款类型有不同的利率, 因此不在这个父类中实现利率的计算方法, 而将它放到子类中实现 */ protected abstract double getinterestrate(); 对于刚才讨论的银行的账户的例子, 我们可以给所有类型的账户定义一个超类 LoanAccount, 在这个超类中, 有一个用于计算利息的方法 caculateinterest(), 已经将它的算法写好了, 这个方法返回一个本金 * 利率的值但是, 因为其中的利率根据存款类型的不同而不同, 所以没有具体实现获得利率的方法, 而是将这个获得利率的方法放到子类中去实现, 根据不同的子类, 设计出不同的获得利率的方法下面是继承了这个抽象类的一个子类 : class AccountA extends LoanAccount{ // 只需要实现父类中没有实现的用于获取利率的抽象方法 public double getinterestrate(){ return 10.0; 在这个子类中, 没有加上自己的属性, 它只是简单地实现了父类中的抽象方法 getinterestrate, 这样, 这个类就成了一个完整的账户类了可以使用以下的方式来使用这个类 : 源文件 :TestAccount.java public class TestAccount { /** 本金 * */ public static void main(string args[]) { AccountA account = new AccountA(); 15

11 第 7 章高级类特性 account.setfund(100.0); account.calculateinterest(); 7. 接口在 Java 中,interface 关键字使抽象的概念更向前迈进了一步, 因为 interface 关键字产生一个完全的抽象类接口接口是方法声明和常量值定义的集合在抽象类中, 有些方法被实现, 而有些方法只有方法的声明, 没有方法的具体实现 ( 抽象方法 ), 而在接口中, 没有提供任何具体的实现一个接口可以理解为 : 所有实现了该特定接口的类都应该长这样 Java 中不支持多重继承, 即一个类只能有一个父类, 即使是抽象类单继承使得程序简单且易于管理, 但是有一定的局限性接口可以很好地解决单继承的缺点, 一个类可以实现多个接口 7..1 知识准备 : 接口的定义接口的定义和类的定义相似, 分为接口声明和接口体和类定义不同的是, 接口的定义不使用关键字 class, 而是用另外一个关键字 interface, 接口定义的基本格式如下 : <modifier> interface <name>[extends <superinterface>] { [<attribute_declarations>] [<abstract_method_declarations>] 在接口中也可以定义常量, 但是不能有变量接口的成员属性都会被自动加上 public static 和 final, 而对于接口中的方法, 也会自动将它设置为 public 接口中的方法只需要声明, 不需要方法体, 即 { 和抽象类中的抽象方法不一样, 这些没有被实现的方法不需要加上关键字 abstract 来将它声明为抽象方法我们来看一个接口的定义源文件 :ScreenBrightness.java public interface ScreenBrightness { public int DEFAULT_BRIGHTNESS = 10; void brightup (); void brightdown (); 155

12 我们定义了接口 ScreenBrightness 来表示手机屏幕的亮度在这个接口中, 定义了一个接口属性 DEFAULT_BRIGHTNESS, 用来表示屏幕默认亮度 ; 定义了两个方法 : 用于表示增加亮度的 brightup() 和用于表示降低亮度的 brightdown() 在前面我们说过, 接口的属性将会被自动加上 public static final 修饰, 所以, 我们编写一个应用程序来验证它源文件 :TestScreenBrightness.java public class TestScreenBrightness { public static void main(string[] args) { System.out.println(ScreenBrightness. DEFAULT_BRIGHTNESS); 对于 static 的属性, 可以采用类名. 属性名来直接调用, 这里类名可以替换为接口名所以, 在这个类的 main() 方法中, 使用接口. 属性名称来访问接口的方法, 编译并运行后, 将向控制台打印出如下的信息 : 10 它就是接口中我们定义的属性 DEFAULT_BRIGHTNESS 的值从中也可以看出, 接口的属性确实已经被加上了 public static 关键字那么, 如何验证它还被自动加上了 final 关键字呢? 很简单, 只需在 TestScreenBrightness 的 main() 方法中写一条语句, 试图修改 DEFAULT_BRIGHTNESS 的值, 看看会发生什么结果就可以了 : DEFAULT_BRIGHTNESS = 15; 重新编译这个程序, 将会出现如下的错误 : TestScreenBrightness.java:5: cannot assign a value to final variable DEFAULT_BRIGHTNESS ScreenBrightness. DEFAULT_BRIGHTNESS = 10; 1 error 显然, 属性 MIN_BRIGHTNESS 确实已经被加上了 final 修饰符 7..2 知识准备 : 使用接口对于抽象类, 我们在子类中用 extends 来继承它但是, 对于接口, 在子类中必须要用另外一个关键字 implements 来实现它一个类可以继承一个父类, 并且同时实现一个或多个接口, 多个接口之间用, 来分隔开类实现接口的语法格式如下 : <modifier> class <name> [ extends <superclass> ] [implements <interface> [,<interface>]* ] { <declarations> * 一个实现了接口的类必须实现该接口的所有方法, 即为这些方法提供方法体或者, 将没有实现的方法定义为抽象的方法, 此时, 类也必须定义为抽象类 156

13 第 7 章高级类特性在 Java 中, 一个类只能继承一个父类, 也就是说,Java 不支持多继承但是, 一个类可以实现多个接口通过接口, 可以模拟实现多继承 7..3 任务二 : 使用接口的例子 1. 任务描述设计一个类, 用来设置手机的屏幕亮度及铃音音量要求该类实现多个接口 2. 技能要点掌握接口的定义和接口的使用体会接口模拟实现多继承的作用 3. 任务实现过程 (1) 首先我们定义一个用于表示屏幕亮度调节的接口 ScreenBrightness 源文件 :ScreenBrightness.java public interface ScreenBrightness { public int DEFAULT_BRIGHTNESS = 10; void brightup (); void brightdown (); 这个接口定义了一个接口属性 DEFAULT_BRIGHTNESS, 用来表示屏幕默认亮度 ; 定义了两个方法 : 用于表示增加亮度的 brightup () 和用于表示降低亮度的 brightdown () (2) 定义另外一个用于表示手机音量的接口 Volume 源文件 :Volume.java public interface Volume { public int DEFAULT_VOLUME = 5; void volumeup (); void volumedown (); 这个接口定义了一个接口属性 DEFAULT_ VOLUME, 用来表示默认音量 ; 定义了两个方法 : 用于表示增加音量的 volumeup () 和用于表示降低音量的 volumedown () (3) 定义 MobileSet 类, 实现 ScreenBrightness,Volume 源文件 :MobileSet.java Public class MobileSet implements ScreenBrightness,Volume{ public int brightness ; public int volume ; public MobileSet(){ 157

14 this.brightness = DEFAULT_BRIGHTNESS; this.volume = DEFAULT_VOLUME; // 实现 ScreenBrightness 中的方法 public void brightup (){ this.brightness++; public void brightdown (){ this.brightness--; // 实现 Volume 中的方法 public void volumeup (){ this.volume++; public void volumedown (){ this.volume--; public static void main(string[] args) { MobileSet ms = new MobileSet(); ms.brightup(); ms.volumedown(); 在这个类中, 我们同时实现了 ScreenBrightness 和 Volume 这两个接口, 然后, 在这个类中将两个接口中的方法实现, 使该类拥有调节手机屏幕亮度和手机音量的双重功能这样, 就实现了多继承的功能注意 : 接口中的方法默认是 public 的, 所以类在实现接口方法时一定要用 public 来修饰 7.. 知识准备 : 接口的扩展接口和类类似, 也可以从一个父接口中派生接口的继承也是使用 extends 关键字来完成的接口继承的基本语法如下 : <modifier> interface <name> [ extends <super_interface>,<super_interface>]{ [<attribute_declarations>] [<abstract_method_declarations>] 和类继承类似, 继承的接口也具有了父接口的特性和类的继承不同的是, 在接口的继承中, 可以继承多个接口, 只需要将继承的各个接口用逗号, 隔开就可以了通过继承, 可以很容易地在接口中添加新的方法声明, 还可以通过继承在新接口中组合数个接口 158

15 第 7 章高级类特性我们可以将任务二中的接口实现改为接口继承我们定义了一个新的接口 MobileSet, 让它同时继承接口 ScreenBrightness 和 Volume : Public interface MobileSet extends ScreenBrightness,Volume{ void showdata(); 在这个接口中, 除了从 ScreenBrightness 和 Volume 继承的方法外, 在这里新增了一个方法 :showdata(), 用于显示设置的数据这样就通过接口的组合扩展出了一个新的接口现在, 我们可能对 Java 中的继承方式有了更深的了解 : 所谓 Java 不支持多继承, 指的是不支持类的多继承 7..5 技能扩展任务 : 抽象类与接口 1. 任务描述学习了这两节内容后, 对比总结抽象类和接口的概念和使用特点的异同, 如表 7-1 所示表 7-1 抽象类与接口的异同抽象类接口相同对象不能直接实例化, 通过多态性, 可以由其子类实例化不相同包含一般方法抽象方法常量变量可以由构造方法抽象类可以实现多个接口继承时, 单继承会有局限包含常量或抽象方法不能有构造方法接口不能继承一个抽象类解决单继承带来的局限 2. 技能要点清晰地梳理抽象类和接口的概念体会抽象类和接口的使用场合 3. 任务实现过程在 Java 中, 继承体现的是 is a 的关系, 而接口体现的则是 has a 聚合的含义接口可以说是特殊的抽象类, 从开发上讲应优先使用接口, 因为接口运行了多继承机制 7.5 多态 159

16 7.5.1 知识准备 : 多态概述在面向对象的程序语言中, 多态是继数据抽象和继承之后的第三种基本特征在 Java 中, 对象变量是多态的一个类型为 Aclass 的变量既可以指向类型为 Aclass 的对象, 又可以指向 Aclass 的任何子类的对象实际上多态的作用是消除类型之间的耦合关系现在假设有一个类 Aclass, 由它派生了一个子类 Bclass, 那么, 我们可以将子类 Bclass 的对象赋给父类变量 : Aclass a = new Bclass(); 这其实体现了 Java 中的所谓替换原则 (substitution principle) : 无论何时, 只要程序需要一个父类对象, 那么就可以用一个子类对象来替代它这种能力也叫动态绑定多态带来的一个明显好处就是 : 以多态的形式来传递参数, 增强了参数类型的灵活性例如, 我们需要在类 CardManager 中添加一个方法, 该方法根据传入的对象输出手机名片中的电话号码其中类 FriendCard 的对象代表朋友的名片 ; 类 ColleagueCard 的对象代表同事的名片其中 FriendCard 和 ColleagueCard 均为 Card 的子类可以这样来定义这个方法 : class CardManager{ public void getfriendnumber (FriendCard fc){ // 根据参数 fc 的 number 属性输出朋友的电话号码 public void getcolleaguenumber (ColleagueCard cc){ // 根据参数 cc 的 number 属性输出同事的电话号码如果使用多态的概念, 我们只要定义一个方法来计算就可以了 : public class CardManager { public int getnumber (Card c) { // 根据参数 c 的 number 属性输出该名片的电话号码如果输出一个名片的电话号码, 只需将名片的对象当作参数传递给这个方法, 如果放置一个朋友的名片, 只需将对应的对象当作参数传递给这个方法在使用多态传递参数的时候, 有一个问题需要注意 : 一个对象只能有一种确切的数据类型, 如果将一个变量声明为父类的引用类型, 那么, 即使它引用的对象是某个子类的对象, 编译器也只是将这个对象当作父类型对象因此, 若一个引用类型变量声明为父类的类型, 但实际引用的是子类对象, 那么该变量就不能再访问子类中添加的属性和方法 160

17 第 7 章高级类特性比如, 我们用 Card 来声明一个变量, 然后再将这个变量指向 FriendCard, 这个时候就不能用这个变量来调用子类 FriendCard 特有的方法或属性了 : Card c; C = new FriendCard (); c.showname();// 调用 FriendCard () 类中的方法错误除了父类和子类之间的这种多态机制外, 接口和实现它的类之间也可以像父类和子类一样实现多态机制, 只需将接口看成实现它的类的父类即可, 对此, 不再赘述知识准备 :instanceof 运算符 Java 语言的多态性机制导致了引用变量的声明类型和其实际引用对象的类型可能不一致为更准确地鉴别一个对象的真正类型,Java 语言引入了 instanceof 操作符, 其使用格式为 : < 引用类型变量 > instanceof < 引用类型 > 这是一个 boolean 类型的表达式, 指出对象是否是特定的一个实例当 instanceof 左侧的引用类型变量所引用对象的实际类型是其右侧给出的类型或其子类类型时, 整个表达式的结果为 true, 否则为 false 我们来看一个例子, 请看下面这些类的关系 ( 类 Student 和 Teacher 派生自 Person): public class Card{ public class FriendCard extends Card{ public class ColleagueCard extends Card{ 现在可以改造上一节的 CardManager 类中的 getnumber() 方法, 接收一个 Card 类型参数, 然后再在运行时根据传入的参数类型来做不同的操作此时, 就可以用 instanceof 来对输入的参数作判断 : public void getnumber (Card c){ if(c instanceof FriendCard) {//statement 1 if(c instanceof ColleagueCard) {//statement 知识准备 : 引用类型数据转换 161

18 在讲述数据类型的时候, 我们已经知道, 各种简单数据类型之间是可以进行相互转换的, 有些转换可以通过系统自动完成, 而有些转换必须在程序中通过强制转换来完成而对于引用类型, 也有一个相互转换的机制同样的, 在引用类型数据进行转换的时候, 分为自动转换和强制转换两种情况将子类的实例转换为父类的实例总是可行的, 因为子类的实例也是父类的实例把父类对象转换为子类对象时, 必须使用强制类型转换, 为使转换成功, 必须确保转换的对象是子类的一个实例当从子类转换成父类的时候 ( 或者实现类转换成接口, 下同 ), 转换可以自动完成, 比如 FriendCard 是 Card 的子类, 如果将一个 FriendCard 对象赋给一个 Card 类型的变量, 造型会自动完成当从父类转换成子类的时候 ( 或者接口转换成实现类 ), 必须使用强制造型, 比如, 需要将一个 Card 对象赋给一个 FriendCard 类型变量的时候, 必须使用强制类型转换对象的强制转换可以使用运算符 () 来完成, 格式如下 : SuperClass sup = new SubClass(); SubClass sub = (SubClass)sup; 需要注意的是, 无论是自动造型还是强制造型, 都只能用在有继承关系的对象之间并不是任意的父类类型数据都可以被造型为子类类型, 只有多态情况下, 原本就是子类类型的对象被声明为父类的类型, 才可以通过转换恢复其本来面目, 否则会在程序运行时出错所以进行转换时确保该对象是另一个类的实例, 可以利用 instanceof 运算符来完成比如,Card 类有两个子类 :FriendCard 和 ColleagueCard, 还有一个单独的类 Test 我们来看下面的代码片断 : Test t = new Test(); Card c = new FriendCard(); ColleagueCard cc = (ColleagueCard)c;// 将会出现运行时错误 FriendCard fc = (FriendCard)t;// 编译时就会报错, 因为 Test 类和 FriendCard 之间没有任何的继承关系此时, 可以先使用 instanceof 来判断要转换的对象是否为可以转换的类型, 例如 : Card c = FriendCard(); if(c instanceof ColleagueCard){ ColleagueCard cc = (ColleagueCard)c; 这样就可以避免出现运行时错误总结起来, 父类对象与和子类对象的转化需要注意如下的原则 : (1) 子类对象可以被视为是其父类的一个对象 (2) 父类对象不能当成是其某一个子类的对象 (3) 如果一个方法的形式参数定义的是父类对象, 那么调用这个方法时, 可以使用子类对象作为形式参数 162

19 第 7 章高级类特性 () 如果父类对象引用指向的实际是一个子类对象, 那么这个父类对象的引用可以用强制类型转换转化成子类对象的引用在转换之前要使用 instanceof 运算符进行判断 7.6 内部类内部类有时也称为嵌套类 (nested class), 是定义在一个类内部的类, 它可以是其他类的成员, 也可以在一个语句块的内部定义内部类的概念是在 JDK1.1 中被引入的引入内部类, 主要有以下一些考虑 :. 一个内部类的对象能够访问创建它的对象的实现, 包括私有数据对于同一个包中的其他类来说, 内部类能够隐藏起来匿名内部类可以方便地用在回调方法 (Callback Method) 中, 典型应用是图形编程中的事件处理在最初, 内部类看起来像是一种代码隐藏机制, 但是随着学习的深入你将了解到, 内部类远不止如此, 它了解外围类, 并能与之通信学会使用内部类, 是掌握 Java 高级编程的一部分, 它可以让你更优雅地设计程序结构知识准备 : 内部类定义内部类是定义在一个外围类的内部这里所谓的类的内部, 指的是在类定义的两个大括号之间, 定义如下 : public class OuterClass{ // 可以在这个类的内部的任何地方定义内部类内部类可以定义在类中的任何位置, 甚至方法体中也可以定义内部类但是要注意, 下面的放在同一个程序文件 A.java 中的类 B 不是类 A 的内部类, 这是刚开始接触内部类的程序员比较容易引起混乱的地方 : public class A{ //statements class B{ //statements 这两个类虽然写在用一个文件中, 但它们之间是两个独立的类, 它们之间并没有什么联系将这个类文件编译之后, 会产生两个 class 文件 :A.class 和 B.class 163

20 可以将一个内部类定义成一个静态内部类, 只需要在内部类定义前面加上 static 关键字例如 : 源文件 :Outer.java public class Outer{ private int a = 5; // 定义一个内部类, 名为 "Inner" public class Inner { // 内部类可以有私有属性 private int i=1; public void innermethod(){ System.out.println( "a=" + a + ", i=" + i ); public void testtheinner() { Inner i = new Inner(); i. innermethod(); 在这个 Outer 类中定义了一个内部类, 这个内部类可以访问外部类的私有属性编译这个 Outer.java, 将会产生两个 class 文件 :Outer.clas 和 Outer$Inner.class, 前面一个类文件是 Outer 类文件, 后面一个是内部类类文件, 它用 $ 来分隔开内部类和外部类我们可以看到, 在 Outer 类内部使用到内部类时, 与使用普通类没什么不同但是在 Outer 类范围以外的其他应用中, 实例化内部类必须首先有一个外部类实例存在, 然后通过外部类实例来实例化内部类 : Outer.Inner in=new Outer().new Inner(); 当然, 如果内部类是 static 的, 也可以用下面方法 : Outer.Inner in=new Outer.Inner(); 我们来看一下, 假设现在需要在另一个应用程序中使用刚才定义的类 Outer 的内部类 Inner, 我们该如何来实现? 请看下面代码 : 源文件 :TestInner.java public class TestInner { public static void main(string[] args) { Outer.Inner oi = new Outer ().new Inner(); oi. innermethod(); 编译并运行这个程序, 将在控制台上打印出 :a=5, i=1 和一般的类不同, 内部类可以使用 protected 和 private 来修饰, 以限制在它的外部类以外的地方对它的访问, 比如, 上面的 Outer 中的 Inner 内部类就可以定义成如下的样子 : 16 public class Outer{

21 第 7 章高级类特性 private class Inner { 此时, 就不能在 Outer 的范围之外使用 Inner 类了知识准备 : 局部内部类 Inner 类也可以定义在方法的内部, 或者类的一个自由块中, 此时, 内部类是一个局部的内部类, 只能在方法体或者自由块中使用局部内部类不能有访问说明符, 因为它不是外部类的一部分 ; 但是它可以访问当前代码块内的常量, 以及此外部类的所有成员在类外不可直接访问局部内部类, 以保证局部内部类对外是不可见的注意 : 如果要在方法体中定义的局部内部类中使用方法的局部变量 ( 如方法的参数 i), 需要将这个局部变量定义为 final 的任务三 : 局部内部类 1. 任务描述设计一个类 Outer, 该类方法 test 中定义局部内部类 LocalClass, 在内部类中定义方法 localtest 尝试内部类与外部类方法的互相调用, 体会局部内部类的使用方法 2. 技能要点掌握局部内部类的定义掌握局部内部类与外部类方法间的调用关系 3. 任务实现过程 (1) 定义一个类 Outer, 在这个类中定义了一个方法 test(), 在它的方法体内定义了一个局部内部类 LocalClass, 这个内部类只能在这个方法体内使用 (2) 在此类中定义一个方法来调用方法 localtest(), 输出语句显示方法被调用 localtest() 方法中试图调用 test 的入口参数 i, 编译器将会出现类似下面的错误 ( 将 i++ 前的注释去掉后的错误 ): final Outer.java:10: local variable i is accessed from within inner class; needs to be declared 1 error System.out.println("i="+i);; ^ 165

22 如果将方法 test() 的参数 i 加上 final 就可以了 ublic class Outer { public void test(int i) { class LocalClass { public void localtest() { System.out.println(" 局部内部类的方法被调用 "); // System.out.println("i="+i); // 错 (2) 在方法 test() 中可直接初始化局部内部类 LocalClass LocalClass lc = new LocalClass(); lc.localtest(); (3) 外部类 Outer 不可直接访问局部内部类 LocalClass,Outer 类对象调用 test() 方法间接访问内部类完整程序如下 : public class Outer { public void test(int i) { class LocalClass { public void localtest() { System.out.println(" 局部内部类的方法被调用 "); // System.out.println("i="+i); // 错 LocalClass lc = new LocalClass(); lc.localtest(); public static void main(string[] args) { Outer o = new Outer(); o.test(1); 7.6. 知识准备 : 匿名内部类内部类的另外一个比较特别的地方就是, 可以不用给它指定一个类名, 就可以直接拿来使用, 这就是匿名内部类匿名内部类可以看做是一种特殊的局部内部类, 它是通过匿名类实现接口如果恰好只要创建一个局部内部类的对象, 可以使用匿名内部类 ( 肯定存在于一个表达式中 ) 这个用法经常用在图形界面的事件处理中示例代码如下: public class AnInnerTest { // 我们首先定义一个接口 interface AnInfc { public void printinfo() ; 166 public static void main(string[] args) { AnInnerTest a = new AnInnerTest(); AnInfc af = a.testan(); af.printinfo();

23 第 7 章高级类特性 public AnInfc testan (){ //AnInfc 为接口, 此处返回该接口的一个实现类的实例 return new AnInfc(){ public void printinfo() { System.out.println("anonymous class"); ; 满足下面的一些条件, 使用匿名内部类是比较合适的 : 只用到类的一个实例类在定义后马上用到类非常小 (Sun 推荐是在行代码以下 ) 给类命名并不会导致你的代码更容易被理解使用匿名内部类时, 要记住以下几个原则 : 匿名内部类不能有构造方法匿名内部类不能定义任何静态成员方法和类匿名内部类不能是 public,protected,private,static 只能创建匿名内部类的一个实例一个匿名内部类一定是在 new 的后面, 用其隐含实现一个接口或实现一个类因匿名内部类为局部内部类, 所以局部内部类的所有限制都对其生效任务四 : 匿名内部类练习 1. 任务描述在上一节的例子中已经通过实现接口的形式使用了匿名内部类现设计程序使用继承抽象类的形式使用匿名内部类 2. 技能要点掌握匿名内部类的使用方法 3. 任务实现过程 public class AnInnerTest { interface AnInfc { public void printinfo() ; public static void main(string[] args) { Person p = new Person("Alex"){ public void printinfo() { System.out.println("name " + this.getname()); ; 167

24 // 调用该抽象方法 p.printinfo(); abstract class Person{ private String name; public Person(String n){name = n; protected String getname() {return name; protected void setname(string name) {this.name = name; public abstract void printinfo(); 知识准备 : 内部类特性内部类是一个复杂的应用, 除了上面提到的一些特点外, 它还有以下一些特点 : (1)Inner class 可以声明为抽象类, 因此可以被其他的内部类继承, 也可以声明为 final 类型 (2) 和外层类不同,Inner class 可以声明为 private 或 protected (3)Inner class 可以声明为 static 类型, 但此时就不能再使用外层封装类的非 static 的成员变量 () 非 static 的内部类中的成员不能声明为 static 类型, 只有在顶层类或 static 的内部类中才可声明 static 成员 7.7 修饰符的适用范围我们已经学习了不少的修饰符, 如用于访问控制的 public protected private 等, 现在将这些修饰符适用的地方作一个简单的总结, 如表 7-2 所示其中,public protected Default 和 private 是互斥的修饰符, 它们只能选择其中之一作为某个特征的修饰符, 其他几个都可以混合使用 protected 和 private 可以用于修饰内部类表 7-2 修饰符适用范围关键字 class 属性方法构造器自由块内部类 public Y Y Y Y Y protected Y Y Y Y Default Y Y Y Y Y Y private Y Y Y Y final Y Y Y Y abstract Y Y Y static Y Y Y Y 168

25 第 7 章高级类特性 7.8 本章小结通过本章的学习, 读者们详细了解了 static 关键字及 final 关键字的用法 ; 了解了 Java 中重要的概念抽象及接口, 并对其用法有了基本掌握本章介绍了多态的概念和用法, 对数据类型转换做了进一步剖析, 本章还重点介绍了内部类的定义和种类, 这是在 Java 高级编程中很重要的概念相信通过本章的学习, 大家对 Java 的理解上了一个台阶, 本章所述的内容还有很深的挖掘空间, 大家通过进一步学习, 会逐步编写出规范而优雅的程序课后练习题一选择题 1. 下列描述错误的是 ( ) A. 一个匿名内部类必须声明为 final B. 一个匿名内部类可以声明为 private C. 一个匿名内部类可以实现多个接口 D. 一个匿名内部类可以访问它所在的外部类中的私有成员变量 2. 以下说法正确的是 ( ) A.static 可以修饰所有的方法, 包括构造器 B.static 可以用来修饰自由块 C.static 修饰的变量只能被 static 方法使用 D. 类的 static 不能通过类的实例访问 3. 下列描述正确的是 ( ) A. 用 final 修饰的方法不能重载 B. 如果一个类中有 abstract 方法就必须声明为 abstract 类 C.abstract 类中至少有一个 abstract 方法 D.static 方法中不能处理非 static 的数据. 下列描述正确的是 ( ) A. 程序中需要父类对象的地方都可以用子类对象替代 B. 程序中需要子类对象的地方都可以用父类对象替代 C. 父类引用指向子类对象时可以访问子类中的方法 D. 父类引用指向子类对象时可以访问子类中重写的方法 5. 下列描述正确的是 ( ) A. 接口在定义时跟类一样都是用关键字 class. B. 一个类只能继承一个父类但是可以实现多个接口 169

26 C. 用 final 修饰的类不能被继承 D. 在接口中定义的方法都是 public 的二简答题 1. 简述 static 关键字的用法 2. 简述 final 关键字的用法 3. 简述抽象类和接口的区别三编程题 1. 创建一个抽象类 Instrument, 里面包含一个抽象方法 play(), 再创建一个 Wind 类, Wind 继承 Instrument 类, 并实现了抽象方法 play() 创建一个 Wind 类的对象, 让一个 Instrument 类的引用指向它 2. 在某个包内创建一个接口, 内含三个方法, 然后在另一个包中实现此接口 170

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