delphi类大体描述.(整体讲解)不错

来自:http://www.cnblogs.com/mdnx/archive/2012/06/22/2558894.html

==================================================

刚刚接触的Delphi的朋友,可能最感兴趣的就是它丰富、强大的VCL(可视化构件 库)。仅仅向窗体上扔几个构件,甚至不用动手写代码,就能很容 易地做出一个有实用价值的程序,真是令人激动。但是,VCL只是Delphi的一小部分,Delphi的优秀远远不只是表现在VCL上。如果你仅仅停留在 使用VCL这一阶段,那么你永远也不可能成为一个真正的Delphi高手。记住,必须超越VCL,才能够接触到Delphi的核心。
   那么,在Delphi的VCL后面,到底隐藏着什么呢?本文将讨论两个比较高级的Delphi主题:OOP和数据库编程。
  本文假定读者已经具有Delphi编程的基础知识,例如,熟悉Pascal语言的一般语法,掌握简单的VCL使用,会使用Data-Ware构件编写基本的数据库程序,等等。本文不会重复VCL的使用这样的问题。
  
  1、OOP
  
  OOP的英文全称是Object Oriented
Programming,翻译过来就是面向对象编程。OOP是一种非常重要的编程思想。也许你会对这种抽象的东西不感兴趣,可是几乎任何一个高手都会告诉你:“语言并不重要,重要的是编程思想。”
  大家知道,Delphi的语言基础是Object
Pascal。这是Borland在传统的Pascal语言中增加了面向对象的特性后发展而成,并且特地冠以Object的字样,以示与传统的Pascal语言的差别,可见面向对象技术对其影响之大。可以说,Delphi构建在Object
Pascal的基础之上,而Object Pascal构建在面向对象技术之上。
  事实上,不但Delphi,OOP也是C++、Java等其他许多现代编程语言的基础(Visual
Basic不完全地支持OOP)。熟练地掌握OOP技术,是深入掌握Delphi的必要条件,是迈入高手境界的必经之路,也是一个成熟的程序员的标志之一。理解了OOP技术之后,很多以前令你困惑的东西会迎刃而解。
  有趣的是,虽然Delphi是完全基于OOP的,但是一个完全不了解OOP的程序员也能够使用Delphi编写程序,因为Delphi会自动完成绝大 多数的工作。当你开始学习Delphi的时候,你可能无法想象,当简单地往窗体上添加一个按钮时,Delphi会完成多么复杂的工作吧!但是既然有志于深 入Delphi的世界,成为一个真正的程序员,我们就应该对Delphi的细节具有好奇心。
  这些理论可能会让人觉得枯燥和望而生畏,其实当你掌握了它之后就会觉得没什么了。当然,你需要有足够的毅力。
  OOP有三个主要的特征:
  
  1.1 数据封装
  
  让我们先看一段代码:
  
  type
  TDate = class
  Mouth,day,Year:Integer;
  procedure SetValue(m,d,y:Integer);
  function LeapYear:Boolean;
  end;
  
  我们首先会看到class关键字,它的中文译名为“类”。类是一个非常重要的概念。根据权威的定义,类是:一种用户定义的数据类型,它具有自己的说明 和一些操作。一个类中含有一些内部数据和一些过程或函数形式的对象方法,通常来描述一些非常相似的对象所具有的共同特征和行为。
  这个定义可能比较晦涩。你可以把类想象为一种特殊的Record类型,其中不但可能包含数据,而且可能包含函数和过程(在OOP中称之为方法)。这些数据和方法被统称为类的成员。
  上面这个类很显然是一个日期类型,它包括Mouth,Day,Year这三个数据成员,和SetValue、LeapYear这两个方法。顺便说一句,在Delphi中,习惯以字母T作为每个类的前缀,就象Viusal
C++中习惯以字母C作为每个类的前缀一样。
  Mouth,Day,Year这三个数据成员指定了该日期的年、月、日。SetValue方法为这三个数据成员赋值,而LeapYear检查当前日期所在的那一年是否是闰年。下面我们给出这两个方法的实现部分:
  
  procedure TDate.SetValue(m,d,y):Integer;
  begin
  Mouth := m;
  Day := d;
  Year := y;
  end;
  
  function TDate.LeapYear:Boolean;
  begin
  if (Year mod 4 <> 0) then
  LeapYear := False
  else if (Year mod 100 <> 0)
  LeapYear := True
  else if (Year mod 400 <> 0)
  LeapYear := False
  else
  LeapYear := True;
  end;
  
  实现了这些定义之后,就可以这样调用它们:
  
  var
  ADay: TDate;
  begin
  //建立一个对象
  ADay := TDate.create;
  //使用之
  ADay.SetValue(1,1,2000);
  if ADay.LeapYear then
  ShowMessage('闰年:' + Inttostr(ADay.year));
  //释放对象
  ADay.free;
  end;
  
  我们来逐行解释这些代码的含义。var后面那一行声明了一个TDate类的变量。
  声明了变量之后,我们怎么使用它呢?使用TDate类的Create方法可以建立一个该类的对象,并将其赋予ADay变量。
  现在我们又接触到了OOP中另一个重要的概念:对象。什么是对象?简言之,对象就是类的实例,或者说,是类定义的数据类型的变量。当建立一个类的对象 时,系统为它分配一块内存。例如我们定义一个变量A为Integer类型,那么,Integer是一个数据类型,A就是一个实例。类与对象的关系就类似于 这两者之间的关系。区别类和对象是非常重要的,甚至一些专业的程序员都往往将他们搞混。
  细心的读者可能注意到,在TDate类的定义中,并没有Create这个方法。那么这个Create方法是从哪里来的呢?Create方法是每一个 Class都具有隐含的方法,它的作用是建立这个类的实例。请注意,在这里,类和其他的数据类型是不同的。其他的数据类型都是声明了变量之后就可以直接使 用,而类类型必须在使用Create方法创建它的实例(对象)之后才能使用。
  事实上,在C++和其他大多数的OOP语言中,声明一个类的变量就能够同时建立起这个类的对象。而Delphi(包括它的孪生兄弟C++
Builder)在这方面与众不同,必须要Create一下才能真正建立对象。同时,在这个对象不再需要时,必须要手工调用free方法释放这个对象(当 然,free方法也是每个类隐含的)。这和Delphi独特的“对象引用模型”有关,有兴趣的朋友可以查阅有关资料,我就不多说了。
  这种情况造成了一个非常有趣的现象,那就是,编程的初学者往往忘记在使用对象之前create它,从而出错,但从C++转向Delphi的高手也常常犯同样的错误……
  顺便告诉大家一个诀窍,当编译器出现“Read of Address:
ffffffff”这样的错误时,多半是因为在使用对象之前忘了Create,可以从这方面入手检查代码。另外,也千万不要忘记在不需要它时使用free释放掉,否则可能造成内存泄漏。
  在建立和释放对象的代码的中间,是使用对象的代码。访问对象的数据成员非常简单,和Record类型没有什么区别。可以点号表达式来访问它们:
  
  ADay.Year := 2000;
  ADay.Mouth := 1;
  ADay.Day := 1;
  
  同样,也可以使用点号表达式来调用对象的方法。如果你阅读了方法实现部分的代码,你可以很容易地发 现,ADay.SetValue(1,1,2000)这一句分别为三个数据成员赋了值,而ADay.LeapYear调用则返回当前日期所在年是否为闰 年。至此,整段代码的意义也就清楚了。
  然而,类不仅仅这么简单。上面这个例子是一个非常简单的类,可以直接访问它的任何成员(数据和方法)。但某些类的成员是不能被随便访问的。Delphi中用三个关键字区分这些成员的访问权限:
  
  表1
      Private该类型的成员只能在声明类中被访问
      Public该类型的成员可以被程序中的任何地方的代码访问
      Protected该类型的成员只能在声明类以及声明类的派生类中被访问


  
  Protected类型的成员以及什么是“派生类”等问题我们留到以后再进行讨论,现在我们将注意力集中在前两者。
  Public类型就是在上面例子中的那种类型,这个很好理解。而Private类型,根据表格中的简单解释,只能在该成员被声明的那个类(也就是该成 员所属的那个类啦)中被访问,越出这个界限,它就是不可见的。那么,Private类型的成员将如何被使用呢?简单地说,就是通过一个Public类的方 法来访问它。
  让我们看一个新的例子:
  
  type
  TDate = class
  private
  Mouth,day,Year:Integer;
  Public
  procedure SetValue(m,d,y:Integer);
  function LeapYear:Boolean;
  function GetText:String;
  end;
  
  
  在这个类中,Mouth,Day,Year这三个成员被声明为Private成员,因此它们在类以外的其它地方是不可访问的。也就是说,如果你使用
  
  ADay.Year := 2000;
  
  这样的代码,那么编译器将会报错。但是,我们可以照样通过SetValue方法为它们赋值:
  
  ADay.SetValue(1,1,2000);
  
  这行代码是合法的,因为SetValue本身是TDate类的成员,而且它又是一个Public成员。而使用GetText方法则可以得到当前日期值(这也是得到当期日期值的唯一办法)。
  这样的设置使得类的一些成员被隐含起来,用户只能用一些专门的方法来使用它们。那些可以被外部代码访问的成员称之为类的接口。这样做有什么好处呢?首 先,这让类的作者可以检测被赋值的内容。比如,用户可能给一个对象赋予13月40日这样的无效日期。而在隐含了一些成员之后,类的作者可以在方法的代码中 检测这些值是否有效,从而大大地减少了产生错误的机会。其次,使用规范的类,作者可以随时修改类内部的代码,而使用该类的代码却无需任何修改!这样使得代 码的维护成了一件轻松的事件,特别是对于多人协作的大型软件而言。
  这就叫做数据的封装(encapsulation)。这是OOP的第一个特征。一个优秀的OOP程序员,应该在设计类的时候,就确定将哪些重要的数据封装起来,并给出一个高效率的接口。
  需要指出的一点是,表1中Private部分的论述对于“标准的”OOP语言(例如C++)是完全正确的,但对于Delphi有一个例外。在 Delphi中,Private成员除了在声明类中可以访问外,在声明类所在的单元(.pas文件)中的任何地方都能被访问,不论这些代码与声明类的关系 如何。严格来说,这是违反OOP的原则的,我不明白Borland为何要这么做(据说是为了方便)。在关于Delphi的优劣性的讨论中,这是常被涉及的 一个问题。
  
  1.2 继承与派生
  
  我们再来看一段代码:
  
  type
  TNewDate = class(TDate)
  Public
  function GetTextNew:String;
  end;
  
  function GetText:String;
  begin
  return := inttostr(Mouth) + ':' + inttostr(Day) + ':' + inttostr(Year);
  end;
  
  可以看到,在class后面出现一个包含在括号中的类名。这种语法表示新的类继承了一个旧的类。继承了原有类的类称之为派生类,也叫子类,被继承的类称之为基类,也叫父类。
  派生类与基类之间是什么关系呢?当派生类继承自一个基类时,它自动具有基类的所有数据、方法以及其他类型,无须在派生类中再做说明。例如,可以象下面这段代码这样使用TNewDate类:
  
  var
  ADay: TNewDate;
  begin
  ADay := TNewDate.create;
  ADay.SetValue(1,1,2000);
  if ADay.LeapYear then
  ShowMessage('闰年:' + Inttostr(ADay.year));
  ADay.free;
  end;
  
  而且,派生类还可以在基类的基础上加入自己的数据和方法。可以看到在TnewDate类中增加了一个新的方法GetTextNew。下面给出这个方法的实现部分:
  
  function GetTextNew:String;
  begin
  return := GetText;
  end;
  
  然后调用它:
  
  ADay.GetTextNew;
  
  这个新的方法工作得很好。
  为什么GetTextNew方法必须调用基类中的GetText方法,而不能直接使用GetText方法中的那些代码呢?原因 是,Mouth,Day,Year这三个成员被声明为Private成员,因此它们即使在派生类中也是不能被访问的,所以必须调用基类中的GetText 方法,间接地使用它们。如果要直接使用它们的话,可以将这三个成员的属性从Private改为Protected。在表1中可以看到,Protected 属性的成员可以在声明类以及声明类的派生类中被访问,然而仍然不能被这两种情况以外的其他代码所访问。现在我们终于可以理解了,这个特殊的属性实际上提供 了极大的方便:它使得类的成员被封装,避免了混乱,同时又能够让派生类方便地使用它们。
  (如果你是一个细心的人,你可能发现上面的话中间有一个小小的仳漏。当你真的在GetTextNew方法中访问了基类的Private成员的话,你可 能会惊奇地发现程序也能够编译通过而且正常运行!其实,这个问题和OOP本身没有关系。上面我已经说过,在Delphi中,Private成员在声明类所 在的单元文件中的任何地方都能被访问,因此如果TNewDate类和TDate类在同一个.pas文件中时,这种情况就不足为怪了。)
  怎么样,是不是觉得非常奇妙?通过这种继承的机制,类不再仅仅是数据和方法的封装,它提供了开放性。你可以方便地继承一个功能强大的类,然后添加进自 己需要的特性,同时,你又不需要对基类进行任何的修改。相反,原作者对基类的任何改动,都可以在你的新类中立即反映出来。这非常符合代码的重用要求。
  这种继承机制也非常符合现实世界中的情形。可以设想,一般意义上的“动物”是一个类,具有自己的一些特征(成员);而“狗”是“动物”的派生类,它具 有动物的所有特征,同时还具有自己独有的特征(四条腿,汪汪叫,等等)。而“狗”这个类可以继续派生下去,例如“黑狗”“白狗”,它们除了保留狗的全部特 征之外,还具有自己的特征(黑颜色,白颜色,等等)。而具体到一只活生生的狗,可以认为它就是“黑狗”或“白狗”(或其他什么狗)的一个实例(对象)。
  OOP这种对现实世界的模拟不仅极大地简化了代码的维护,而且使得整个编程思想产生了革命性的变化,较之模块化编程有了飞跃的进步。
  如果你曾经仔细阅读过VCL的资料甚至它的源代码,你就可以发现,整个VCL都是建立在这种强大的封装-继承的机制之上的。你可以看到一张详细的 VCL层次结构图,就象是一个庞大的家谱,各种VCL构件通过层层继承而产生。例如,一个简简单单的TForm类,就是许多次继承之后的产物:
  TObject - TPersistent - TConponent - TControl - TWinControl -
TScrollingWinControl - TCustomForm - TForm
  不但Delphi的VCL,Visual C++中的著名的MFC(Microsoft Foundation Class,微软基本类库),以及以前Borland
C++中风光一时的OWL(Object Window
Library,对象窗口类库),都是建立在这种机制之上。所不同的是,对于前两种语言,你要花上好几个月的功夫去基本掌握那些繁复无比的类,才能写出比 较有实用价值的程序,而在Delphi中,大部分的工作Delphi都已经自动帮你完成了。例如,每次你向程序中加入一个窗体时,Delphi就自动为你 从TForm派生一个新类(默认为TForm1),并且为这个新类创造一个实例。你对这个窗体的改动(添加构件和代码之类),无非是为这个派生类加入一些 新的特性而已;你再也用不着自己去处理最大化、最小化、改变大小这一类的情况,因为这些代码都在基类中被实现,而被派生类所继承了。这就是Delphi的 伟大之处。当然,Delphi的VCL也绝不比MFC或OWL逊色(事实上它是由后者演变而来)。
  (可能有人会问起VB的情况。VB不支持继承,因此并没有什么复杂的类库,它自己的控件也少得可怜,主要是使用ActiveX控件。)。
  也许你已经若有所悟,为你的发现而心痒难骚了吧。但是,我们要讨论的东西当然不会仅仅这么简单。
  在1.1部分(“数据封装”),我们讲到了“Create方法是每一个Class都具有隐含的方法”。其实,这种说法是不准确的。事实是,在 Delphi中,所有的类都默认继承自一个最基础的类TOject,甚至在你并未指定继承的类名也是如此。Create方法是TObject类具有的方 法,因此理所当然,所有的类都自动获得了Create方法,不管你是否实现过它。想想看就知道了:如果没有Create方法的话,怎样建立一个对象呢?
  你可能注意到了Create方法是一个特殊的方法。不错,Create方法的确非常特殊,甚至于它的“头衔”不再是function或procedure,而是Constructor(构造器)。你可以在VCL的源码中见到这样一些例子:
  
  Constructor Create;
  
  构造器不仅是一个Delphi关键字,而且是一个OOP方法学的名词。与之相对应的,还有Destructor(毁坏器)。前者负责完成创建一个对象 的工作,为它分配内存,后者负责释放这个对象,回收它的内存。要注意的一点是,Constructor的名字一般是Create,但Destructor 的名字却不是Free,而是Destroy。例如:
  
  Destructor Destroy;
  
  那么,在以前的代码,为什么又使用Free来释放对象呢?二者的区别是,Destroy会直接释放对象,而Free会事实检查该对象是否存在,如果对 象存在,或者对象不为nil,它才会调用Destroy。因此,程序中应该尽量使用free来释放对象,这样更加安全一些。(但要注意,free也不会自 动将对象置为nil,所以在调用free之后,最好是再手动将对象置为nil。)
  象对待一般的函数或过程那样,也可以向构造器传递参数:
  
  type
  TDate = class
  private
  Mouth,day,Year:Integer;
  Public
  function LeapYear:Boolean;
  function GetText:String;
  Constructor Create(m,d,y:Integer);
  end;
  
  procedure TDate.Create(m,d,y):Integer;
  begin
  Mouth := m;
  Day := d;
  Year := y;
  end;
  
  调用它:
  
  ADay: TDate;
  begin
  ADay := TDate.create(1,1,2000);
  if ADay.LeapYear then
  ShowMessage('闰年:' + Inttostr(ADay.year));
  ADay.free;
  end;
  
  这样,在Create方法里就完成了对数据的初始化,而无须再调用SetValue方法了。
  
  接下来,我们将要涉及到另一个重要的、也是很有趣的问题:方法的虚拟与重载。
  可能你已经有点晕了吧……还是先看一个新的例子:
  
  type
  TMyClass = class
  procedure One;virtual;
  end;
  
  type
  TNewClass = class(TMyClass)
  procedure One;override;
  end;
  
  procedure TMyclass.One;virtual;
  begin
  ShowMessage('调用了TMyclass的方法!');
  end;
  
  procedure TNewClass.One; override;
  begin
  Inherited;
  ShowMessage('调用了TNewClass的方法!');
  end;
  
  可以看到,从TMyClass派生了一个新类TNewClass。这两个类都声明了一个名字相同的方法One。所不同的是,在TMyClass中,One方法后面多了一个Virtual关键字,表示这个方法是一个虚拟方法(Virtual
Method)。而在TNewClass中,One方法后面多了一个Override关键字,表示该方法进行了重载(Override)。重载技术能够实现许多特殊的功能。
  让我们来仔细分析它们的实现部分。在TMyclass.One方法的实现部分,调用ShowMessage过程弹出一个对话框,说明该方法已被调用;这里没有任何特别的地方。在TNewClass.One方法中,出现了一条以前从未出现过的语句:
  
  Inherited;
  
  这个词的中文意思是“继承”。我们暂时不要去涉及到太过复杂的OOP概念,只要知道这条语句的功能就是了。它的功能是调用基类中相当的虚拟方法中的代码。例如,你如果使用以下代码:
  
  var
  AObject: TNewClass;
  begin
  AObject := TNewClass.create;
  AObject.One;
  AObject.free;
  end;
  
  那么程序将弹出两次对话框,第一次是调用TMyclass类中的One方法,第二次才是TNewClass.One方法中的代码。
  重载技术使得我们不但可以在派生类中添加基类没有的数据和方法,而且可以非常方便地继承基类中原有方法的代码,只需要简单地加入Inherited就 可以了。如果你不加入Inherited语句,那么基类的相应方法将被新的方法覆盖掉。但是必须注意,重载只有在基类的方法被标志为Virtual时才能 进行,而且重载的方法必须具有和虚拟方法完全相同的参数类型。
  虚拟方法还有一种特例,即抽象方法:
  
  procedure One;override;abstract;
  
  在One方法后面,不但有override关键字,还多了一个abstract关键字(意为抽象)。这种方法称为抽象方法(在C++中称为纯虚拟函 数)。含有抽象方法的类称为抽象类。抽象方法的独特之处在于,它只有声明,而根本没有实现部分,如果你企图调用一个对象的抽象方法,你将得到一个异常。只 有当这个类的派生类重载并实现了该方法之后,它才能够被调用。(在C++中,甚至根本就不能建立一个抽象类的实例。)
  既然如此,那么这种抽象方法又有什么用呢?这个问题我们将在接下来的“多态”部分进行讨论。
  
  1.3 多态
  
  多态相对来说比较复杂一点。不过不要担心,它的内容比较少,而且如果以前的知识掌握得比较稳固的话,多态的概念是水到渠成的。
  先来讨论一下类型的兼容性问题。下面是一个例子:
  
  type
  TAnimal = Class
  Procedure Voice;virtual;
  ...
  end;
  
  TDog = Class(TAnimal)
  Procedure Voice;Override;
  ...
  end;
  
  implementation
  
  Procedure TAnimal.Voice;virtual;
  Begin
  PlaySound('Anim.wav',0,snd_Async);
  End;
  
  Procedure TDog.Voice;virtual;
  Begin
  PlaySound('Dog.wav',0,snd_Async);
  End;
  
  TDog类继承了TAnimal类,并重载了其中的Voice方法。PlaySound是一个WIN
API函数,可以播放指定的wav文件。(这个函数的定义在MMSystem.pas文件中可以找到。)
  先看这段代码:
  
  var
  MyAnimal1, MyAnimal2: TAnimal;
  Begin
  MyAnimal1 := TAnimal.Create;
  MyAnimal2 := TDog.Create;
  ...
  
  在实现部分的第一行中,建立了一个TAnimal类型的对象,并将其赋予TAnimal类型的变量MyAnimal1。这是很正常的事。但在第二行 中,建立了一个TDog类型的对象,并将其赋予了TAnimal类型的变量MyAnimal2。这看上去令人吃惊,但这些代码是完全合法的。
  众所周知,Pascal以及Object
Pascal是一种类型定义严格的语言,你不能将某个类型的值赋予不同类型的变量,例如将一个整型值赋予布尔型变量,将会导致出错。但是,这个规则在涉及 到OOP领域时,出现了一个重要的例外,那就是:可以将一个子类的值赋予一个父类类型的变量。但倒过来却是不行的,一个父类的值决不能赋予一个子类类型的 变量。
  如果将这个原则放到现实世界中,那就很容易理解了:“狗”继承自“动物”,因为狗也是一种动物。所以可以将一个“狗”类型的值赋予“动物”类型的变量,因为“狗”具有“动物”的一切特征。但反过来,“动物”不具有“狗”的所有特征,因此反向赋值是不行的。
  那么,这种兼容规则在编程中究竟有什么用处呢?
  请注意下面这段代码:
  
  var
  MyAnimal1, MyAnimal2: TAnimal;
  Begin
  MyAnimal1 := TAnimal.Create;
  MyAnimal2 := TDog.Create;
  MyAnimal1.Sound;
  MyAnimal2.Sound;
  ...
  
  MyAnimal1和MyAnimal2都是TAnimal的变量,而且都调用了Sound方法。但是,执行的结果是完全不同的:前者执行的是 TAnimal.Voice的代码,而后者执行的是TDog.Voice的代码!其原因很简单,因为MyAnimal1被赋予了TAnimal类型的对 象,而MyAnimal2被赋予了TDog类型的对象。也就是说,一个TAnimal类型的变量,当它调用Sound方法时,所执行的代码是不确定的:可 能执行TAnimal.Voice的代码,也可能执行的是TDog.Voice的代码,取决于它当时引用的是一个什么样的对象。
  再看:
  
  MyAnimal1 := TAnimal.Create;
  MyAnimal1.Sound;
  MyAnimal1.free;
  MyAnimal1 := TDog.Create;
  MyAnimal1.Sound;
  ...
  
  同一个变量MyAnimal1,在第一次调用Sound方法时,执行的是TAnimal.Voice的代码,在第二次时执行的是TDog.Voice 的代码。MyAnimal1.Sound这行代码不需要变化,程序可以根据不同的情况赋予该变量不同的对象,从而使它执行不同的代码。这就是多态的定义。
  这个非常重要的特点大大地增加了代码的可复用性。如前所述,只需要简单地写下一行代码,就可以让程序执行不同的功能,因为这个虚拟方法同 TAnimal的任何派生类都是兼容的,甚至连那些还没有编写出来的类也是一样。而程序员并不需要了解这些派生类的细节。利用多态性写出来代码,还具有简 洁和维护性好的特点。
  现在我们可以回到本文的1.2节结尾处的问题了。抽象方法本身不能够做任何事情,必须在子类中被重载并实现,才能够完成有意义的工作。但抽象方法的存 在,相当于为父类留下了一个接口,当程序将一个子类的对象赋予父类的变量时,父类的变量就可以调用这个方法,当然此时它运行的是相应的子类中重载该方法的 代码。如果没有这个抽象方法,父类的变量就不能调用它,因为它不能调用一个只在子类中存在、而在父类中不存在的方法!
  
  关于OOP的介绍就到此这止。在以上这些篇幅里,介绍的只是OOP最基本的一些概念,让读者对OOP有一定的系统认识,也为下文的讨论打好基础 。更多、更深入的东西等待着你自己去发掘。
  本文已经多次强调OOP的重要性,这里还要强调一次:对OOP的掌握程度,在某种意义上决定着你对Delphi世界的理解能力。

转载于:https://www.cnblogs.com/del88/archive/2012/12/07/2808151.html

  • 0
    点赞
  • 0
    评论
  • 0
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

表情包
插入表情
评论将由博主筛选后显示,对所有人可见 | 还能输入1000个字符
©️2021 CSDN 皮肤主题: 编程工作室 设计师:CSDN官方博客 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值