Microsoft Word - G3_BK_Ch06-8.doc

Transcription

1 第 6 章抽象類別 125 第二篇 抽象与接口之应用 围棋国宝吴清源说 : 整体 和谐与创新 是棋艺的真谛 接口 就像红绿灯及斑马线, 创造了交通的和谐与秩序

2 126 Android 的對象技術 (OOP)

3 第 6 章抽象類別 127 Android 的對象技術教材下載

4 128 Android 的對象技術 (OOP) 第 6 章 抽象类别 (Abstract Class) 6.1 抽象类别与继承体系 6.2 从抽象类别 衍生 出具体类别 6.3 Android 的抽象类别之例 6.4 抽象函数之妙用 : 预设行为 6.5 Android 预设行为之例 6.6 抽象函数之妙用 : 反向调用 6.7 Android 反向调用之例 6.8 应用于 C/C++

5 第 6 章抽象類別 抽象类别与继承体系 在前面各章里, 介绍过类别继承体系, 例如 : 图 6-1 Android 的 View 类别体系 这是人们利用天赋的抽象 (Abstraction) 能力, 将对象加以分门别类, 所以这 个继承关系中的父类 (Super-class) 又称为抽象类别 (Abstract Class) 抽象 一词的 相对名词是 具象 或称为 具体 (Concrete), 所以继承关系中的子类 (Subclass) 又称为具体类别 (Concrete Class) 具体类别 一般类别是具体而完整的, 每一个函数都有完整的实作 (Body) 部份, 我们可 以随意拿它来创建对象 这是大家已经熟悉的类别了 这样的一般类别就是刚才 提过的具体类别了

6 130 Android 的對象技術 (OOP) 抽象类别 抽象类别的来源是 : 洞悉及分离出 变 ( 或差异 ) 的部分与 不变 ( 或共同 ) 的部份 ; 然后抽掉差异部份, 而留下共同部分, 并以类别表示之, 就成为抽象类别了 ; 由于已经抽掉一些部分, 所以抽象类别的本质是不完整的, 预留一些有待填补的空间 例如, 建房子时, 师傅都会预留一些卡榫, 可做未来衔接点 例如, 从具体类别抽掉某些函数的实作 (Body) 部分, 这些函数就称为抽象函数 (Abstract Function), 而含有抽象函数的类别就称为抽象类别 (Abstract Class) 了 例如 : /* jx06-01 */ abstract class SalesPerson { private String name; private String sex; protected float BasicFee; protected float Discount; public SalesPerson(String na, String sx){ name = na; sex = sx; public void SetFee(float basic_fee, float disc){ BasicFee = basic_fee; Discount = disc; public abstract float GetTotal(); public abstract void display(); public class JMain { public static void main(string[] args) { /* Can not create objects... SalesPerson alice = new SalesPerson("Alice", "Male"); alice.setfee(2000f, 0.8f); alice.display(); */ 其中,GetTotal() 和 display() 函数的实作部份被抽掉了, 所以是抽象函数 (Abstract Function) 在 Java 里禁止你拿抽象类别来创建对象, 会要求你使用

7 第 6 章抽象類別 131 abstract 关键词来区别一般类别与抽象类别 而且使用 abstract 关键词来区别一般函数与抽象函数 由于 SalesPerson 类别的 GetTotal() 和 display() 函数欠缺实作部份, 如果也拿它创建对象 alice, 并调用其 display() 函数, 如下之指令 : alice.display(); 则会发生严重问题 : 计算机执行到此指令的时候, 将找不到实作指令, 而无法执行了 6.2 从抽象类别 衍生 出具体类别 也许你会说道 : 这种抽象类别是没有用的! 其实不然, 就像老子在数千年前 已经说过, 像房子的中间 门 窗皆是虚的空间的, 才能供人们进出 居住与透 透空气 其积极效果是 : 日后依新环境的条件而加以调整 充实, 创造出多样化 的用途 例如畚箕的中间是空 虚的, 才能装泥土 垃圾等各式各样的东西 此 外, 畚箕的空无, 创造了畚箕的再利用性 (Reusability), 装完了泥土, 倒掉之后, 还可拿来装垃圾等, 不断重复使用之, 一直到坏掉为止 抽象类别就如同一间空房子, 添加一些家具 ( 如函数的实作部份 ), 就能让人 住得愉快了 在 Java 里, 使用子类 (Subclass) 来填补函数的实作部份 例如, 我 们可以写个具体类别来填补的 SalesPerson 抽象类别的空缺部分, 如下 : /* jx06-02 */ abstract class SalesPerson { protected String name; protected String sex; protected float BasicFee; protected float Discount; public SalesPerson(String na, String sx){ name = na; sex = sx; public void SetFee(float basic_fee, float disc){ BasicFee = basic_fee; Discount = disc;

8 132 Android 的對象技術 (OOP) public abstract float GetTotal(); public abstract void display(); class SalesEngineer extends SalesPerson { public SalesEngineer(String na, String sx){ super(na, sx); public float GetTotal(){ return super.basicfee * super.discount; public void display() { System.out.println("SalesEngineer: " + name + " Fee: " + this.gettotal()); public class JMain { public static void main(string[] args) { SalesEngineer alice = new SalesEngineer("Alice", "Male"); alice.setfee(2000f, 0.8f); alice.display(); 这个简单的范例, 说明了两个重要动作 : 抽象 将一般类别的变异部份抽掉, 留下来的稳定部分, 称为抽象类别 (Abstract Class) 衍生 从有预留而不完整的抽象类别, 加添些特殊功能, 成为具体类别 (Concrete Class), 再创建对象 抽象类别, 并非具体的类别, 不能用来创建对象, 看似无用的东西 其实它可衍生出无数个具体子类, 可创建出无数种对象来!抽象类别中的抽象 ( 即 abstract) 函数内容常是空的, 能虚怀若谷, 让应用程序师不断充实它, 其子孙类别就个个精明能干!抽象类别发挥无用之用的效果, 衍生 之动作则更进一步地发挥这种效果 人们易于得意骄傲, 不易虚怀若谷 同样地, 易于创造具体类 别, 而不易创造出抽象类别 不过, 当您懂得善藉眼前的 无用 来换取长远的 有用 时, 创造与使用抽象类别就易如反掌了

9 第 6 章抽象類別 Android 的抽象类别之例 Android 是应用框架, 而抽象类别又是应用框架的主角, 所以 Android 里含 有各式各样的抽象类别 例如 BroadcastReceiver 和 Service 两个皆是抽象类别 BroadcastReceiver 与 Service Activity 是息息相关的 : Activity 好像是应用程序的眼睛, 提供与 User 互动之窗 BroadcastReceiver 好像是耳朵, 接收来自各方的 Intent 讯息 Service 好像是手, 提供符合 Intent 意图之服务 由于 BroadcastReceiver 和 Service 两者都定义了抽象函数, 它们的子类一定要覆写之, 才能补充它们刻意留下来的 不足 之处 请看下述范例程序 : 操作情境 : 1. 此程序一开始, 画面出现两个按钮如下 : 2. 按下 <call_service> 按钮, 暂停 15 秒 : 3. 等待 15 秒后, 委托 Alarm Manager 发出 intent 对象 当 BroadcastReceiver 接

10 134 Android 的對象技術 (OOP) 到 intent 对象时, 就启动 NotifyService, 此服务会回传字符串, 显示于 ac01 画面的 Title 区域 : 4. 按下 <Exit>, 程序就结束了 撰写步骤 : Step-1: 建立 Android 项目 :Fx01 Step-2: 撰写 BroadcastReceiver 的子类 :AlarmReceiver, 其程序码如下 : // AlarmReceiver.java 程序码 package com.misoo.pkzz; import android.content.broadcastreceiver; import android.content.context; import android.content.intent; public class AlarmReceiver extends BroadcastReceiver public void onreceive(context context, Intent intent) { context.startservice(new Intent(context, NotifyService.class));

11 第 6 章抽象類別 135 Step-3: 撰写 Service 的子类 :NotifyService, 其程序码如下 : // NotifyService.java 程序码 package com.misoo.pkzz; import android.app.service; import android.content.intent; import android.os.ibinder; public class NotifyService extends protected void oncreate() { ac01 app = ac01.getapp(); app.btevent("from public IBinder onbind(intent intent) { return null; Step-4: 撰写 Activity 的子类 :ac01, 其程序码如下 : // ac01.java 程序码 package com.misoo.pkzz; import java.util.calendar; import android.app.activity; import android.app.alarmmanager; import android.app.pendingintent; import android.content.intent; import android.os.bundle; import android.widget.button; import android.view.view; import android.view.view.onclicklistener; public class ac01 extends Activity implements OnClickListener{ private static ac01 appref = null; private Button btn, btn2; private boolean k = protected void oncreate(bundle icicle) { super.oncreate(icicle); appref = this; setcontentview(r.layout.cs); btn = (Button)findViewById(R.id.call_service); btn.setonclicklistener(this); btn2 = (Button)findViewById(R.id.exit); btn2.setonclicklistener(this); public static ac01 getapp() { return appref; public void btevent( String data ) { settitle(data); public void onclick(view arg0) {

12 136 Android 的對象技術 (OOP) if(arg0 == btn){ settitle("waiting... Alarm=15"); Intent intent = new Intent(ac01.this, AlarmReceiver.class); PendingIntent p_intent = PendingIntent.getBroadcast(ac01.this, 0, intent, 0); Calendar calendar = Calendar.getInstance(); calendar.settimeinmillis(system.currenttimemillis()); calendar.add(calendar.second, 15); // Schedule the alarm! AlarmManager am = (AlarmManager)getSystemService(ALARM_SERVICE); am.set(alarmmanager.rtc_wakeup, calendar.gettimeinmillis(), p_intent); if(arg0 == btn2){ Intent intent = new Intent(ac01.this, AlarmReceiver.class); PendingIntent p_intent = PendingIntent.getBroadcast(ac01.this, 0, intent, 0); AlarmManager am = (AlarmManager)getSystemService(ALARM_SERVICE); am.cancel(p_intent); finish(); Step-5: 执行之 说明 : 1. BroadcastReceiver 抽象类别里定义了 onreceive() 抽象函数 所以子类 AlarmReceiver 就将之补充起来, 如下的 onreceive() 函数 public void onreceive(context context, Intent intent) { context.startservice(new Intent(context, NotifyService.class), null); 2. 同样地,Service 抽象类别里定义了 onbind() 抽象函数 所以子类 NotifyService 就将之补充起来, 如下的 onbind() 函数 public IBinder onbind(intent intent) { return null; 如此,NotifyService 就成为具体类别了

13 第 6 章抽象類別 抽象函数之妙用 : 预设行为 在前面第 6.2 节里, 抽象类别 SalesPerson 的抽象函数 GetTotal() 和 display(), 它们的实作指令部份都是从缺的 所以该抽象类别 ( 即 SalesPerson) 的子类 必须 补足这个欠缺, 才能成为一个具体类别 子类开发者的负担是蛮重的 如果将一些预设 (Default) 的实作部份加到抽象类别里, 则其子类就可选择要 不要修正这个预设实作部份, 这样可以减轻子类开发者的负担 例如下述之范例 : 其程序码如下 : /* Shape.java */ import java.awt.color; import java.awt.graphics; public abstract class Shape { Graphics m_gr; public Shape(Graphics gr) { m_gr = gr; public void onpaint(){ m_gr.setcolor(color.black); m_gr.fillrect(10,30, 200,100); public void paint() { onpaint(); // drawing background /* Bird.java */ import java.awt.color; import java.awt.graphics;

14 138 Android 的對象技術 (OOP) public class Bird extends Shape { Graphics m_gr; public Bird(Graphics gr) { super(gr); m_gr = gr; public void onpaint(){ super.onpaint(); // drawing a bird m_gr.setcolor(color.cyan); m_gr.drawarc(30,80,90,110,40,100); m_gr.drawarc(88,93,90,100,40,80); m_gr.setcolor(color.white); m_gr.drawarc(30,55,90,150,35,75); m_gr.drawarc(90,80,90,90,40,80); /* JMain.java */ import java.awt.graphics; import javax.swing.jframe; import javax.swing.jpanel; class JP extends JPanel { public void paintcomponent(graphics gr){ super.paintcomponents(gr); Shape bird = new Bird(gr); bird.paint(); public class JMain extends JFrame{ public JMain(){ settitle(""); setsize(350, 250); public static void main(string[] args) { JMain frm = new JMain(); JP panel = new JP(); frm.add(panel); frm.setdefaultcloseoperation(jframe.exit_on_close); frm.setvisible(true);

15 第 6 章抽象類別 139 此程序画出两只海鸥如下图 : 其中的抽象类别 Shape 的 paint() 和 onpaint() 函数都含有预设的实作指令 具 体类别 Bird 的设计者选择如下 : 不覆写 ( 即不修正 )paint() 函数 直接使用预设行为, 所以减轻了负担 覆写 ( 即修正 )onpaint() 函数 重用 (Reuse) 了预设行为, 也减轻了部分的 负担 此程序执行时, 主程序的指令 :bird.paint() 调用子类 Bird 的 paint(), 但是 Bird 并没有 paint() 函数, 于是采用父类 Shape 的预设 paint() 函数 此预设函数调用 onpaint(), 就反向调用了子类的 onpaint() 请注意, 是父类 paint() 调用子类的 onpaint(); 并不是父类 onpaint() 来调用子类的 onpaint() 反而是子类 onpaint() 调用父类的 onpaint()

16 140 Android 的對象技術 (OOP) 6.5 Android 预设行为之例 Android 是应用框架, 而在抽象类别里摆上一些预设行为又是应用框架的主要技俩, 所以 Android 里不仅含有各式各样的抽象类别, 而且也有各式各样的预 设行为 例如在 View 父类 ( 或称抽象类别 ) 里就定义了 ondraw() 函数 Button 又 从 View 类别继承而得到 ondraw() 函数 最后, 我们还可以撰写新类别去继承 Button 类别, 仍然继承而得 ondraw() 函数 在这个继承体系里的每一层级皆可覆 写这继承而来的 ondraw() 函数, 形成预设行为了 例如下述的范例程序 : 操作情境 : 1. 此程序一开始, 画面出现两个按钮如下 : 2. 如果按下 <Exit> 按钮, 程序就结束了 撰写步骤 : Step-1: 建立 Android 项目 :Fx02

17 第 6 章抽象類別 141 Step-2: 撰写 Activity 的子类 :ac01, 其程序码如下 : /* ac01.java */ package com.misoo.pkaz; import android.app.activity; import android.graphics.color; import android.os.bundle; import android.view.view; import android.view.view.onclicklistener; import android.widget.linearlayout; public class ac01 extends Activity implements OnClickListener { private okbutton ok_btn; private exitbutton public void oncreate(bundle savedinstancestate) { super.oncreate(savedinstancestate); setcontentview(r.layout.main); LinearLayout layout = new LinearLayout(this); layout.setorientation(linearlayout.vertical); ok_btn = new okbutton(this); ok_btn.setonclicklistener(this); LinearLayout.LayoutParams param = new LinearLayout.LayoutParams(ok_btn.get_width(), ok_btn.get_height()); layout.addview(ok_btn, param); exit_btn = new exitbutton(this); exit_btn.setonclicklistener(this); exit_btn.settext("exit"); exit_btn.settextcolor(color.blue);

18 142 Android 的對象技術 (OOP) exit_btn.settextsize(25); exit_btn.setbackgroundresource(r.drawable.icon2); LinearLayout.LayoutParams param2 = new LinearLayout.LayoutParams(80, 55); param2.topmargin = 5; param2.leftmargin = 5; layout.addview(exit_btn, param2); setcontentview(layout); public void onclick(view v) { if(v == ok_btn) settitle("ok"); else if(v == exit_btn) finish(); Step-3: 撰写 Button 的子类 :okbutton, 其程序码如下 : /* okbutton.java */ package com.misoo.pkaz; import android.content.context; import android.graphics.canvas; import android.graphics.color; import android.graphics.paint; import android.widget.button; public class okbutton extends Button{ public okbutton(context ctx){ super(ctx); super.settext(" K"); super.settextsize(30); protected void ondraw(canvas canvas) { super.ondraw(canvas); Paint pa = new Paint(); pa.setcolor(color.yellow); canvas.drawcircle(30, 25, 17, pa); pa.setcolor(color.red); canvas.drawcircle(30, 25, 15, pa); pa.setcolor(color.yellow); canvas.drawcircle(30, 25, 12, pa); public int get_width(){ return 90; public int get_height(){ return 60;

19 第 6 章抽象類別 143 Step-4: 撰写 Button 的子类 :exitbutton, 其程序码如下 : /* exitbutton.java */ package com.misoo.pkaz; import android.content.context; import android.graphics.canvas; import android.widget.button; public class exitbutton extends Button { public exitbutton(context ctx){ protected void ondraw(canvas canvas) { super.ondraw(canvas); 说明 : 1. 我们在撰写 okbutton 类别时, 面对 Button 的预设行为, 可重复利用 (Reuse) 它, 也可以不用它 2. 因之, 我们有三种选择 : ( 一 ) 并不覆写 ondraw() 函数 这表示 ondraw() 函数的预设行为适合于 okbutton 类别, 直接继承 Button 父类的 ondraw() 函数就行了 ( 二 ) 完全覆盖掉父类的预设行为 这表示 ondraw() 函数的预设行为不适合于 okbutton 类别, 而且不想去重复利用 (Reuse) 它 ( 三 ) 重复利用 (Reuse) 它, 并且修正它 调用父类的预设行为 ( 如画出图画的背景 ), 在增添新的行为, 达到修正预设行为之目的 3. 例如,okButton 类别采取上述的第 ( 三 ) 种做法 既调用预设的行为绘出一个白色按钮, 而且自己画出彩色的图案 4. 再如,exitButton 类别采取上述的第 ( 一 ) 种做法 虽然表面上有覆写的形式, 但也只是调用父类的预设行为而已 所以,exitButton 的 ondraw() 函数是多 余的 可删去之

20 144 Android 的對象技術 (OOP) 6.6 抽象函数之妙用 : 反向调用 当子类继承父类, 而且覆写 (Override) 父类的函数时, 就可以产生反向调用 的现象, 也就是父类的函数调用子类的函数 虽然父类 ( 前辈 ) 创建时, 子类 ( 晚辈 ) 常常尚未创建;但是前辈有时候可预知晚辈中的函数, 就可调用它 像 Android 这样的应用框架里的抽象类别就是扮演父类的角色, 只是含有一些阳春型的类 别, 其提供很通用, 但不完整的函数, 是设计师刻意留给应用程序的子类来补充 的 一旦补充 ( 透过函数覆写之手段 ) 完成, 框架里的父类的函数就可以 反向调用 子类里的函数了 例如下述的范例程序 : 其程序码如下 : /* SalesPerson.java */ public abstract class SalesPerson { protected String name; protected String sex; protected float BasicFee; protected float Discount; public SalesPerson(String na, String sx){ name = na; sex = sx; public void SetFee(float basic_fee, float disc){ BasicFee = basic_fee; Discount = disc; public void display() { System.out.println(name + ", Fee: " + this.gettotal()); public abstract float GetTotal();

21 第 6 章抽象類別 145 /* SalesSecretary.java */ public class SalesSecretary extends SalesPerson { public SalesSecretary(String na, String sx){ super(na, sx); public float GetTotal() { return BasicFee * Discount - 100; /* JMain.java */ public class JMain { public static void main(string[] args) { SalesPerson linda = new SalesSecretary("Linda Fan", "Female"); linda.setfee(2500f, 0.7f); linda.display(); 请你仔细看看此程序的执行过程, 是很微妙而有趣的 此程序执行时, 先执行 JMain 类别的 main() 函数, 执行到指令 : linda.display(); 时, 就转而执行 SalesPerson 类别的 display() 函数 : public void display() { System.out.println(name + ", Fee: " + this.gettotal()); 执行到指令 :this.gettotal(); 由于 SalesSecretary 类别覆写了 GetTotal() 函数, 于是转而执行 SalesSecretary 类 别的 GetTotal() 函数 : public double GetTotal() { return BasicFee * Discount 100; 如下图所示 :

22 146 Android 的對象技術 (OOP) JMain main() { linda.display() SalesPerson display() { this.gettotal() ( 反向呼叫 ) SalesSecretary GetTotal() {. 图 6-2 典型的反向调用 (Inversion of Control) 机制 这程序显示了 抽象类别 + 预设函数 的美妙组合, 产生了下述的重要现象 : 1. 程序执行时, 主控权在抽象类别手上 虽然 main() 函数仍为程序的启动者, 但主要的处理过程是在 SalesPerson 的 display() 函数内 是它决定调用 GetTotal() 的 2. 具体类别的函数, 主要是供抽象类别调用之 例如,SalesSecretary 类别的 GetTotal() 供 SalesPerson 的 display() 函数调用之 3. 由于抽象类别掌握主控权, 复杂的指令皆摆在抽象类别中 其大幅简化了具体类别开发者的负担

23 第 6 章抽象類別 Android 反向调用之例 Android 是应用框架, 不但在抽象类别里摆上一些预设行为, 而且能进行反 向调用具体类别的覆写函数 抽象类别 预设行为和反向调用是应用框架的主要元素, 所以 Android 里不仅含有各式各样的抽象类别, 而且也有各式各样的预设 行为, 还能顺畅地反向调用 例如在 View 类别体系里各类别皆能覆写 ondraw() 函数, 让 View 类别继承的父类能顺利反向调用子类的 ondraw() 函数 例如下述的范例程序 : 操作情境 1. 此程序执行时, 呈现如下的画面 : 2. 如果按下 RadioButton, 画面就变换如下 : 3. 若按下 <Exit> 按钮, 程序就结束了

24 148 Android 的對象技術 (OOP) 撰写步骤 : Step-1: 建立 Android 应用程序项目 :Fx03 Step-2: 撰写 Activity 的子类 ac01, 其程序码如下 : /* ac01.java */ package com.misoo.ppxx; import android.app.activity; import android.os.bundle; import android.view.view; import android.view.viewgroup; import android.view.view.onclicklistener; import android.widget.button; import android.widget.linearlayout; import android.widget.radiobutton; public class ac01 extends Activity implements OnClickListener { private final int WC = ViewGroup.LayoutParams.WRAP_CONTENT; private MyView mv; private RadioButton ra; private Button public void oncreate(bundle icicle) { super.oncreate(icicle); LinearLayout layout = new LinearLayout(this); layout.setorientation(linearlayout.horizontal);

25 第 6 章抽象類別 149 LinearLayout.LayoutParams param = new LinearLayout.LayoutParams(115, 250); param.leftmargin = 1; mv = new MyView(this); layout.addview(mv, param); ra = new RadioButton(this); ra.setonclicklistener(this); param = new LinearLayout.LayoutParams(WC, WC); param.topmargin = 40; layout.addview(ra, param); btn = new Button(this); btn.settext("exit"); btn.setonclicklistener(this); btn.setbackgroundresource(r.drawable.gray); param.leftmargin = 30; layout.addview(btn, param); setcontentview(layout); public void onclick(view v) { if( v == ra) mv.redraw(); else if(v == btn) finish(); Step-3: 撰写 View 的子类 MyView, 其程序码如下 : /* MyView.java */ package com.misoo.ppxx; import android.content.context; import android.graphics.canvas; import android.graphics.color; import android.graphics.paint; import android.view.view; public class MyView extends View { private Paint pa = new Paint(); private boolean yn = false; public MyView(Context context) { super(context); public void ReDraw(){

26 150 Android 的對象技術 (OOP) protected void ondraw(canvas canvas) { yn =!yn; pa.setcolor(color.white); canvas.drawrect(10, 10, 100, 100, pa); pa.setcolor(color.yellow); if(yn){ pa.setcolor(color.blue); canvas.drawcircle(55, 55, 15, pa); else { pa.setcolor(color.red); canvas.drawrect(40, 40, 70, 70, pa); Step-4: 执行之 说明 : 1. 这 MyView 子类覆写了 ondraw() 函数, 创造了反向调用的机会 2. 当我们按下 RadioButton 时, 就调用到 MyView 类别的 ReDraw() 函数, 进而调用到 View 的 invalidate() 函数 3. 接着, 就反向调用 MyView 子类的 ondraw() 函数, 在 UI 画面上绘出图形来 这就是典型的 反向沟通 了 4. 如果你没有定义 ondraw() 函数的话, 会执行 View 父类预设的 ondraw() 函数, 而依据框架预设之惯例而行了

27 第 6 章抽象類別 应用于 C/C++: 抽象类别 关于 C++ C++ 使用 "virtual" 关键词表明某个函数是会采取晚期连结 (Late Binding) 的 至于 Java 语言里则不必特别说明, 就是会进行晚期连结的 本节将先介绍抽象类别与虚拟函数之关系, 再谈虚拟函数与晚期连结之关系 抽象类别与纯粹虚拟函数 在实际 OOP 软件设计中, 常先发现子类, 然后将子类的共同特性, 定义于其父类中 例如 :Rose 公司生产网球拍 桌球拍及羽毛球拍 它们皆是 一种 (A kind of) 球拍, 因之发现了父类 球拍 ;这些类别构成一类别体系(Class Hierarchy) 如下 : 球拍 網球拍 桌球拍 羽毛球拍 像 球拍 这种类别称为 抽象类别 (Abstract Class) 其特性为 : (1) 不产生对象;亦即不用它来宣告对象 (2) 包含子类之共同数据项及函数, 让子类继承之 (3) 将子类组织成一类别体系, 支持多型性 再如, 前面的 Java 部分所举的推销员例子里, 推销部门之人员, 其职称若不是 SalesManager, 就是 SalesEngineer ;因之, 这些人员若非 SalesManager 类别之对象, 就是 SalesEngineer 类别之对象 则此 SalesPerson 就是一抽象类别, 它永 远不含有对象 C++ 对抽象类别做了较严谨之定义 :

28 152 Android 的對象技術 (OOP) 含纯粹虚拟函数 (Pure Virtual Function) 之类别, 称为抽象类别 纯粹虚拟函数之特征为 : 函数之 指令 (Body) 部分从缺 例如 : class SalesPerson { double total_amount; public: SalesPerson( double a ) { total_amount = a ; virtual double bonus()=0; ; 这 bonus() 函数里并没有指令, 是个纯粹虚拟函数 C++ 规定您必须把 0 指定 (Assign to) 给纯粹虚拟函数 因之, 纯粹虚拟函数之宣告格式为 : virtual 型态函数名称 ( ) = 0; 由于 SalesPerson 类别包含纯粹虚拟函数 bonus(), 所以它是抽象类别 不能利用抽象类别来宣告对象, 所以下述指令错了! SalesPerson s( ); 但是, 能宣告 SalesPerson 之指标如下 : SalesPerson *ps; 此 ps 可指向子类之对象, 而达到多型性之效果 例如 : //cx06-01.cpp #include <iostream.h> class SalesPerson { protected: double total_amt; public: SalesPerson( double a ) : total_amt(a) { virtual double bonus() const =0; ; class SalesEngineer : public SalesPerson { public: SalesEngineer(double a):salesperson(a) { virtual double bonus() const

29 第 6 章抽象類別 153 { return( total_amt * ); ; class SalesManager : public SalesPerson { public: SalesManager(double a):salesperson(a) { virtual double bonus() const { return( total_amt * ); ; void compute_bonus( const SalesPerson *ps ) { cout << "bonus:" << ps->bonus() << endl; int main() { SalesManager peter( ); SalesEngineer alvin( ), lily( ); compute_bonus( &peter ); compute_bonus( &alvin ); compute_bonus( &lily ); return(0); 其中,ps 为抽象类别 SalesPerson 之指标, 且 bonus() 为 virtual 函数;因之, 计算机对 ps->bonus() 指令做 晚期连结 (Late Binding) 动作 虚拟函数与晚期连结 例如 : 前面各章里已经介绍 C++ 的对象指针, 其具有一项特性 : 父类之指标, 能指向其子孙类别之对象 //cx06-02.cpp #include <iostream.h> class SalesPerson { double total_amount; public: SalesPerson( double a ): total_amount(a) { double bonus() const { return( total_amount * ); ;

30 154 Android 的對象技術 (OOP) class SalesEngineer:public SalesPerson { public: SalesEngineer( double a ):SalesPerson(a) {; double bonus() const { return( SalesPerson::bonus() ); ; int main() { SalesPerson *p, x( ); SalesEngineer y( ), m( ); p = &x; cout << "x's bonus: " << p->bonus() << endl; p = &y; cout << "y's bonus: " << p->bonus() << endl; p = &m; cout << "m's bonus: " << p->bonus() << endl; return(0); 其中,p 是父类 SalesPerson 之对象指针, 能指向 SalesPerson 类别之对象, 也能指向子类 SalesEngineer 之对象 例如 : p = &x; 令 p 指向 SalesPerson 之对象 x 再如 : p = &y; 令 p 指向子类 SalesEngineer 之对象 y 兹介绍个重要观念, 指令 p = &x; cout << p->bonus() << "\n"; 这 bonus() 为 SalesPerson 类别之 bonus() 或是 SalesEngineer 类别之 bonus() 呢? 答案是 :SalesPerson 类别之 bonus() 计算机根据两个线索判断之 : (1) p 之型态为 SalesPerson * (2) p 所指之对象 x, 其型态为 SalesPerson 因之, 此 bonus() 是 SalesPerson 类别之 bonus() 函数, 亦即 p->bonus() 相当于 x.bonus() 接下来, 就别有奥妙了!请看指令 p = &y; cout << p->bonus() << "\n"; 这 bonus() 为 SalesPerson 类别之 bonus() 或 SalesEngineer 类别之 bonus() 呢

31 第 6 章抽象類別 155? y 为 SalesEngineer 之对象, 而 SalesEngineer 类别中含有两个 bonus() 定义, 其中 SalesPerson::bonus() 是由 SalesPerson 继承而来, 而 SalesEngineer 类别也定义新 bonus() 函数 因之, 上述 p->bonus() 是相当于下列之何者呢? 或者 : 请看两个可能线索 : y.bonus() y.salesperson::bonus() (1) p 之型态为 SalesPerson * (2) p 所指之对象 y, 其型态为 SalesEngineer 这两线索不一致, 该怎么办呢? C++ 提供两种可能让您抉择, 以便选取最合适者 如果您希望计算机依指针 p 之型态来决定, 那么 C++ 就采用 早期连结 (Early Binding) 方法, 使得指令 : 相当于 p = &y; cout << p->bonus() << "\n"; p = &y; cout << y.salesperson::bonus() << "\n"; 亦即, 计算机根据 p 之型态来判断此 bonus() 应为 SalesPerson 类别之 bonus() 函数 如果您希望计算机依 p 所指向对象之型态来决定, 那么 C++ 就采用 晚期 连结 方法, 使得指令 : 相当于 p = &y; cout << p->bonus() << "\n"; p = &y; cout << y.bonus() << "\n"; 亦即, 计算机根据 p 所指向对象之型态来判断此 bonus() 函数应为 SalesEngineer 类别之 bonus() 话说回来, 在程序中, 应如何告诉计算机采用 早期 或 晚 期 连结呢?很简单, 如果您宣告 bonus() 为 虚拟函数 (Virtual Function), 计算机就采用晚期连结 反之, 若未宣告 bonus() 为虚拟函数, 计算机就采用早期连结 如果需做晚期连结 (Late Binding), 必须了解虚拟函数 (Virtual Function) 本

32 156 Android 的對象技術 (OOP) 节将介绍晚期连结与虚拟函数观念 宣告虚拟函数的方法是 : 于父类中使用专用字 virtual 宣告之 被宣告为 虚拟 之多型函数, 计算机会做晚期连结 例如 : //cx06-03.cpp #include <iostream.h> class SalesPerson { double total_amount; public: SalesPerson( double a ):total_amount(a) { virtual double bonus() const { return( total_amount * ); ; class SalesEngineer:public SalesPerson { public: SalesEngineer( double a ): SalesPerson(a) { ; double bonus() const { return( SalesPerson::bonus() ); ; int main() { SalesPerson *p, x( ); SalesEngineer y( ), m( ); p = &x; cout << p->bonus() << "\n"; p = &y; cout << p->bonus() << "\n"; p = &m; cout << p->bonus() << "\n"; return(0); 父类 SalesPerson 宣告 bonus() 为虚拟函数, 则其子孙类别之 bonus() 函数皆 自动成为虚拟函数;因之, 只须在 SalesPerson 中使用 virtual 专用字即可 当然 您也能为 SalesEngineer 类别中的 bonus() 加上 virtual 字眼, 使得程序更清楚一些 由于 bonus() 为虚拟多型函数, 当计算机处理下述指令时, 就做晚期连结 p = &y; cout << p->bonus() << "\n"; 晚期连结会依照 p 所指向对象之型态选取适当之 bonus() 函数 于此例子 中,p 指向 y 对象,y 为 SalesEngineer 类别之对象, 于是此 bonus() 函数是指 SalesEngineer 之 bonus() 计算机就调用 SalesEngineer 之 bonus() 函数 如果去

33 第 6 章抽象類別 157 掉上述之 virtual 专用字, 则计算机会做早期连结 依照 p 之型态选取适当的 bonus() 函数, 而非依照 p 所指向对象之型态了 关于面向对象 C 制 目前的 LW_OOPC 并没有提供类别继承, 所以也无虚拟函数及晚期连结机 让高老师陪您登上 IT 生涯的巅峰 首席 IT 架构师的策略思考技术 Workshop 课程 上課 : 兩天 (12 小時 ) 學費 :RMB6,600 元 / 人指導 : 高煥堂先生內容 : 请参考