《计算概论》课程第十九讲 C 程序设计语言应用

Size: px

Start display at page:

Download "《计算概论》课程第十九讲 C 程序设计语言应用"

津皑尚
4 years ago
Views:

1 Java 高级技术课程第二讲 Java 语言的面向对象特性 (2) 李戈北京大学信息科学技术学院软件研究所 2010 年 3 月 21 日

2 课程助教 : 前言黎育龙 ( @pub.ss.pku.edu.cn) 标题 :Java 高级技术 + 题目请不要把作业发到我的信箱 ; 新的课程网站用户名 : 学号 ; 密码 : 学号什么叫多态? 什么叫重载?

3 多态性多态性在程序中同一符号或名字在不同情况下具有不同解释的现象称为多态性 ; 如何确定某个符号的含义绑定 (binding) 将一个名字与它的特性相关联的过程名字 : 变量名方法名特性 : 类型实现体最常见的绑定 : 确定变量的类型和确定方法调用所调用的实现体 ;

4 多态性根据绑定时机的不同, 可以将多态性分为两种最基本的形式 : 编译时多态性是指在绑定的过程在程序编译阶段即可完成 ( 静态绑定 ) 主要通过使用重载机制获得运行时多态性是指绑定的过程必须等到程序动态运行时才能够完成 ( 动态绑定 ) 主要通过继承 + 重定义机制获得

5 编译时多态性

6 方法重载编译时多态性的实现重载是指在一个类的成员方法中有多个名字相同但参数列表不同的方法一个类的成员方法中如果有多个名字相同, 但参数列表不同的方法, 我们就称这些方法为互为重载的方法互为重载的方法要求 : 方法名字必须相同 ; 参数列表必须不同 ; 覆盖的条件 : 方法名字必须相同 ; 参数列表必须相同 ; 方法返回值必须相同 ;

7 方法重载 // 根据学生的名字查找学生, 返回学生在数组中的下标, 如果没有该学生则返回 -1 public static int find(int start, String name) {...; // 根据学生的第 scoreindex 门课程的分数是否处在 scoremin 和 scoremax( 包括这两个数 ) 之间查找学生, 从学生数组的 start 下标开始查找, 返回第一个满足条件的学生的下标, 如果没有满足条件的学生, 返回 -1 public static int find(int start, int scoreindex, int scoremin, int scoremax) {...; // 根据学生三门课程的平均分数是否处在 scoremin 和 scoremax( 包括这两个数 ) 之间查找学生, 从学生数组的 start 下标开始查找, 返回第一个满足条件的学生的下标, 如果没有满足条件的学生, 返回 -1 public static int find(int start, int scoremin, int scoremax) {...;

8 判断下列方式是否为重载方法重载 public int function(int x) { public int function(string x) { public int function(int x) { public String function(int x) { public static int function(int x) { private void function(int x) { public final int function(int x) { private void function(int x) {......

9 由于方法重载带来的多态性方法重载带来了编译时多态性在使用了方法重载的程序中, 通常在编译时才能够确定 : 对于一个方法调用表达式确定它所调用的是哪个方法体

10 必须搞懂的一个问题 (1) // SuperClass.java public class SuperClass { public void method(superclass obj1, SuperClass obj2) { System.out.println("SuperClass.method(SuperClass, SuperClass)"); // SubClass.java class SubClass extends SuperClass { public void method(superclass superobj, SubClass subobj) { System.out.println("SubClass.method(SuperClass, SubClass)"); public void method(subclass subobj, SuperClass superobj) { System.out.println("SubClass.method(SubClass, SuperClass)"); public void method(subclass subobj1, SubClass subobj2) { System.out.println("SubClass.method(SubClass, SubClass)");

11 必须搞懂的一个问题 (2) // OverloadDemo.java public class OverloadDemo { public static void main(string[] args) { SuperClass superobj = new SuperClass(); SubClass subobj = new SubClass(); SuperClass superrefertosub = subobj; // 第一组调用 superobj.method(superobj, superobj); superobj.method(subobj, subobj); superobj.method(superrefertosub, superrefertosub); // 第二组调用 subobj.method(superobj, superobj); subobj.method(subobj, subobj); subobj.method(superrefertosub, superrefertosub); // 第三组调用 superrefertosub.method(superobj, superobj); superrefertosub.method(subobj, subobj); superrefertosub.method(superrefertosub, superrefertosub);

12 // SuperClass.java public class SuperClass { public void method(superclass obj1, SuperClass obj2) { System.out.println("SuperClass.method(SuperClass, SuperClass)"); // SubClass.java class SubClass extends SuperClass { public void method(superclass superobj, SubClass subobj) { System.out.println("SubClass.method(SuperClass, SubClass)"); public void method(subclass subobj, SuperClass superobj) { System.out.println("SubClass.method(SubClass, SuperClass)"); public void method(subclass subobj1, SubClass subobj2) { System.out.println("SubClass.method(SubClass, SubClass)"); // OverloadDemo.java public class OverloadDemo { public static void main(string[] args) { SuperClass superobj = new SuperClass(); SubClass subobj = new SubClass(); SuperClass superrefertosub = subobj; // 第一组调用 superobj.method(superobj, superobj); superobj.method(subobj, subobj); superobj.method(superrefertosub, superrefertosub); // 第二组调用 subobj.method(superobj, superobj); subobj.method(subobj, subobj); subobj.method(superrefertosub, superrefertosub); // 第三组调用 superrefertosub.method(superobj, superobj); superrefertosub.method(subobj, subobj); superrefertosub.method(superrefertosub, superrefertosub);

13 编译时的绑定方法调用表达式调用了哪个方法体? 先确定被调用方法体可能存在的类 ; 也就是说, 在哪个类的成员方法中寻找再对比方法调用表达式中给出的参数与哪个方法体所给出的参数列表最接近 ;

14 // SuperClass.java public class SuperClass { public void method(superclass obj1, SuperClass obj2) { System.out.println("SuperClass.method(SuperClass, SuperClass)"); // SubClass.java class SubClass extends SuperClass { public void method(superclass superobj, SubClass subobj) { System.out.println("SubClass.method(SuperClass, SubClass)"); public void method(subclass subobj, SuperClass superobj) { System.out.println("SubClass.method(SubClass, SuperClass)"); public void method(subclass subobj1, SubClass subobj2) { System.out.println("SubClass.method(SubClass, SubClass)"); // OverloadDemo.java public class OverloadDemo { public static void main(string[] args) { SuperClass superobj = new SuperClass(); SubClass subobj = new SubClass(); SuperClass superrefertosub = subobj; // 第一组调用 superobj.method(superobj, superobj); superobj.method(subobj, subobj); superobj.method(superrefertosub, superrefertosub); // 第二组调用 subobj.method(superobj, superobj); subobj.method(subobj, subobj); subobj.method(superrefertosub, superrefertosub); // 第三组调用 superrefertosub.method(superobj, superobj); superrefertosub.method(subobj, subobj); superrefertosub.method(superrefertosub, superrefertosub);

15 // SuperClass.java public class SuperClass { public void method(superclass obj1, SuperClass obj2) { System.out.println("SuperClass.method(SuperClass, SuperClass)"); 第一问 : // SubClass.java class SubClass extends SuperClass { public void method(superclass superobj, SubClass subobj) { System.out.println("SubClass.method(SuperClass, SubClass)"); public void method(subclass subobj, SuperClass superobj) { System.out.println("SubClass.method(SubClass, SuperClass)"); public void method(subclass subobj1, SubClass subobj2) { System.out.println("SubClass.method(SubClass, SubClass)"); // OverloadDemo.java public class OverloadDemo { public static void main(string[] args) { SuperClass superobj = new SuperClass(); SubClass subobj = new SubClass(); SuperClass superrefertosub = subobj; // 第一组调用 superobj.method(superobj, superobj); superobj.method(subobj, subobj); superobj.method(superrefertosub, superrefertosub); // 第二组调用 subobj.method(superobj, superobj); subobj.method(subobj, subobj); subobj.method(superrefertosub, superrefertosub); // 第三组调用 superrefertosub.method(superobj, superobj); superrefertosub.method(subobj, subobj); superrefertosub.method(superrefertosub, superrefertosub); 如果子类不提供参数类型为 <SubClass, SubClass> 的第四个方法, 会出现什么结果呢?

16 // SuperClass.java // SubClass.java class SubClass extends SuperClass { public void method(superclass superobj, SubClass subobj) { System.out.println("SubClass.method(SuperClass, SubClass)"); public void method(subclass subobj, SuperClass superobj) { System.out.println("SubClass.method(SubClass, SuperClass)"); public void method(subclass subobj1, SubClass subobj2) { 第二问 : System.out.println("SubClass.method(SubClass, SubClass)"); public void method(superclass obj1, SuperClass obj2) { System.out.println("SubClass.method(SuperClass, SuperClass)"); // OverloadDemo.java public class OverloadDemo { public static void main(string[] args) { SuperClass superobj = new SuperClass(); SubClass subobj = new SubClass(); SuperClass superrefertosub = subobj; // 第一组调用 superobj.method(superobj, superobj); superobj.method(subobj, subobj); superobj.method(superrefertosub, superrefertosub); // 第二组调用 subobj.method(superobj, superobj); subobj.method(subobj, subobj); subobj.method(superrefertosub, superrefertosub); // 第三组调用 superrefertosub.method(superobj, superobj); superrefertosub.method(subobj, subobj); superrefertosub.method(superrefertosub, superrefertosub); 如果子类再提供一个参数类型为 <SuperClass, SuperClass> 的第四个方法, 会出现什么结果呢?

17 关于重载的总结方法重载带来了编译时多态性在使用了方法重载的程序中, 通常在编译时才能够确定 : 对于一个方法调用表达式确定它所调用的是哪个方法体如何在编译时确定方法调用表达式调用了哪个方法体? 先确定被调用方法体可能存在的类 ; 也就是说, 在哪个类的成员方法中寻找再对比方法调用表达式中给出的参数与哪个方法体所给出的参数列表最接近 ;

18 运行时的多态性

19 什么是运行时的多态性 Java 语言允许祖先类类型的引用变量引用后代类类型的对象实例例如, 类 GraduateStudent 是类 Student 的子类, 下述语句合法 : Student obj = new GraduateStudent(); 同理, 可将后代类类型的引用变量隐式类型转换为祖先类类型的引用变量, 例如 : GraduateStudent objone = new GraduateStudent(); Student objtwo = objone; 可见, 在编译时声明为某个类型的引用变量在运行时引用的对象实例不一定是该类型的对象实例 ;

20 运行时多态性的实现继承 + 重定义

21 方法重定义什么是方法重定义在特殊类中对继承来的属性或服务进行重新定义, 以覆盖原来的方法是指在子类定义一个与超类 ( 或祖先类 ) 的某个方法有完全相同接口的方法方法参数列表相同指参数的个数以及相应位置上的参数类型相同完全相同是指返回类型方法名和方法参数列表完全相同

22 什么是方法重定义对超类 SuperClass: public class SuperClass { public void method(int x, double y) { System.out.println("SuperClass -> method"); SubClassOne 中方法 method() 的定义 : public class SubClassOne extends SuperClass { public void method(int a, double b) { System.out.println("SubClassOne -> method"); SubClassTwo 中方法 method() 的定义 : public class SubClassTwo extends SuperClass { public int method(int x, double y) { System.out.println("SubClassTwo -> method"); return 1; // 以上哪个是正确的重定义?

23 关于方法重定义方法重定义必须满足多种约束 (1) 子类方法的名称参数签名和返回类型必须与父类相同 public class Base { public void method( ) { class Sub extends Base{ public int method( ) { return 0;

24 关于方法重定义方法重定义必须满足多种约束 (2) 子类方法不能缩小父类方法的访问权限, 但可以扩大访问权限 public class Parent { public void method() { public class Child extends Parent { private void method() {

25 关于方法重定义方法重定义必须满足多种约束 (3) 子类方法不能抛出比父类方法更多的异常前者抛出的异常必须和后者抛出的异常相同, 或前者抛出的异常是后者抛出异常的子类 ; class ExceptionA extends Exception{ class ExceptionB extends ExceptionA{ class ExceptionC extends ExceptionB{ public class Parent { void method() throws ExceptionB{ public class Child1 extends Parent { void method()throws ExceptionA { // 非法 public class Child2 extends Parent { void method()throws ExceptionC { // 合法

关于方法重定义方法重定义必须满足多种约束 (4) 父类的静态方法不能被子类重定义为非静态方法 ; 父类的非静态方法不能被子类重定义为静态方法 ; public class Base { public stacitc void method( ) public class SubBase extends Base {

26 关于方法重定义方法重定义必须满足多种约束 (4) 父类的静态方法不能被子类重定义为非静态方法 ; 父类的非静态方法不能被子类重定义为静态方法 ; public class Base { public stacitc void method( ) public class SubBase extends Base { public void method( ) //================================== public class Base { public void method( ) public class SubBase extends Base { public static void method( )

27 用于屏蔽继承成员类成员属性的重定义可以通过将继承的成员变量重定义为子类的私有成员变量实现屏蔽继承成员, 以使子类环境下不再提供该继承成员给使用者超类有如下成员数据 : public class SuperClass { public int value = 10; 屏蔽 : public class SubClass extends SuperClass { private double value = 20.0; // 如果反过来呢?( 将 private 覆盖为 public 呢?)

28 思考一下, 程序是否正确? // 对超类 SuperClass: class SuperClass { private void method(int x, double y) { System.out.println("SuperClass -> method"); //SubClassOne 中方法 method() 的定义 : class SubClassOne extends SuperClass { public void method(int a, double b) { System.out.println("SubClassOne -> method"); //SubClassTwo 中方法 method() 的定义 : class SubClassTwo extends SuperClass { public int method(int a, double b) { System.out.println("SubClassOne -> method"); return 0;

29 若则继承 + 重定义出现多态对于一个引用, 若其静态类型是某个父类 ; 且在运行时实际引用的对象实例的类型是其子类 ; SuperClass superref = new SubClass( ); 且被调用的方法 superref.method( ); 在子类中重定义了父类的方法 ; 程序将帮助你实现一个动作 : 利用父类的引用调用子类的方法这就是多态!

30 一个最简单而正统的例子 (1) 有超类 SuperClass: public class SuperClass { public void method( ) { System.out.println("SuperClass.method( )"); 子类 SubClass 重定义了 method() 方法 : public class SubClass extends SuperClass{ public void method( ) { System.out.println("SubClass.method( )"); 设有如下的声明 : SuperClass superobj = new SuperClass( ); SubClass subobj = new SubClass( ); 请判定下述语句的执行结果 : SuperClass superref = superobj; superref.method( );

31 一个最简单而正统的例子 (2) 有超类 SuperClass: public class SuperClass { public void method( ) { System.out.println("SuperClass.method( )"); 子类 SubClass 重定义了 method() 方法 : public class SubClass extends SuperClass{ public void method( ) { System.out.println("SubClass.method( )"); 设有如下的声明 : SuperClass superobj = new SuperClass( ); SubClass subobj = new SubClass( ); 请判定下述语句的执行结果 : SuperClass superref = subobj; superref.method( );

32 引用变量的静态类型换个说法将某个引用变量编译时声明的类型称为它的静态类型 ; 将某个引用变量在运行时实际引用的对象实例的类型称为它的动态类型 ; 运行时多态性某个引用变量的静态类型与其动态类型不同 ; 动态类型可能随使用环境的变化而变化 ;

33 这样做有什么意义呢?

34 一个简单的例子

35 经典的例子 class Shape { void draw() { System.out.println( Shape.draw()"); void erase() { System.out.println( Shape.erase()"); class Circle extends Shape { void draw() { System.out.println("Circle.draw()"); void erase() { System.out.println("Circle.erase()"); class Square extends Shape { void draw() { System.out.println("Square.draw()"); void erase() { System.out.println("Square.erase()"); class Triangle extends Shape { void draw() { System.out.println("Triangle.draw()"); void erase() { System.out.println("Triangle.erase()");

36 经典的例子 public static void main(string[] args) { Shape shape = new XXX( ); if( ) shape.draw(); else if ( ) shape.erase(); else ;

37 经典的例子 public class Shapes { public static Shape randshape() { switch((int)(math.random( ) * 3)) { default: case 0: return new Circle(); case 1: return new Square(); case 2: return new Triangle(); public static void main(string[] args) { Shape[] s = new Shape[9]; for(int i = 0; i < s.length; i++) s[i] = randshape(); for(int i = 0; i < s.length; i++) s[i].draw(); Circle.draw() Triangle.draw() Circle.draw() Circle.draw() Circle.draw() Square.draw() Triangle.draw() Square.draw() Square.draw()

38 经典的例子 public class Shapes { public static Shape randshape() { switch((int)(math.random( ) * 3)) { default: case 0: return new Circle(); case 1: return new Square(); case 2: return new Triangle(); public static void main(string[] args) { Shape shape = randshape(); if( ) shape.draw(); else if ( ) shape.erase(); else ; Circle.draw() Triangle.draw() Circle.draw() Circle.draw() Circle.draw() Square.draw() Triangle.draw() Square.draw() Square.draw()

39 还有个技术问题 : 如何判定绑定的结果?

40 试一下假定有如下超类 SuperClass: public class SuperClass { public void firstmethod( ) { secondmethod( ); public void secondmethod( ) { System.out.println("SuperClass.secondMethod()"); 在子类 SubClass 重定义了 secondmethod( ) 方法 : public class SubClass extends SuperClass{ public void secondmethod( ) { System.out.println("SubClass.secondMethod()"); 请判定下述语句的执行结果 : SubClass subobj = new SubClass( ); SuperClass superref = subobj; superref.firstmethod( );

41 public class SuperClass { public static void firstmethod() { System.out.println("SuperClass.firstMethod()"); public void secondmethod( ) { System.out.println("SuperClass.secondMethod()"); public class SubClass extends SuperClass{ public static void firstmethod() { System.out.println("SubClass.firstMethod()"); public void secondmethod( ) { System.out.println("SubClass.secondMethod()"); 请判定下述语句的执行结果 : SubClass subobj = new SubClass( ); SuperClass superref = subobj; superref.firstmethod( ); 再试一下 superref.secondmethod( );

42 import java.io.*; class SuperClass { public String var = "I'm in SuperClass"; class SubClass extends SuperClass { public String var = "I'm in SubClass"; public class StaticDTBDTest { 再再试一下 public static void main(string[] args) { SubClass subobj = new SubClass( ); SuperClass superref = subobj; System.out.println(superRef.var);

43 注意只有在满足以下条件时, 运行时实际调用的方法版本才与编译时确定的方法版本不同 : 1. 被调用的方法是非静态方法, 静态方法的调用不会产生运行时多态 ; 2. 被调用的方法在祖先类定义, 而且被后代类重定义 ; 3. 使用静态类型为祖先类的引用变量调用方法, 但它的动态类型却是后代类

44 动态绑定总结总之, 在将方法调用绑定到方法体时都经过两个步骤 : 一个步骤是在编译时静态完成的, 确定该方法调用的可访问且可应用的最精确方法 ; 另一个步骤是在运行时动态完成的, 根据对象引用的动态类型真正调用这个最精确方法重定义的版本 ;

45 实际上, 对每一个方法调用 : Java 的动态绑定在编译时都首先通过静态绑定过程确定该方法调用的可访问且可应用的最精确方法 ; 将有关这个最精确方法的信息被记录在编译后得到的字节码中 ; 在运行时,JVM 检查方法调用表达式的对象引用的动态类型, 调用这个最精确方法在该动态类型所对应的类中的方法体版本如果这个对象引用的动态类型与它的静态类型不同 ( 但肯定是静态类型的子类型 ), 而且这个动态类型所对应的类 ( 肯定是静态类型所对应的类的后代类 ) 重定义了这个最精确的方法, 那么在运行时实际调用的就是这个重定义了的方法

46 好好想想, 有没有问题? 谢谢!

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

《计算概论》课程 第十九讲 C 程序设计语言应用

《计算概论》课程第十九讲 C 程序设计语言应用