Delphi重载,覆盖,多态

一、override  重载
type
  TFigure = class
    procedure Draw; virtual;//(我的理解是)父类中可以使用父类的,子类中使用子类的。与“四”是有区别的。
  end;
  TRectangle = class(TFigure)
    procedure Draw; override;//a1
  end;
  TEllipse = class(TFigure)
    procedure Draw; override;//a2
  end;
使用
var
  Figure: TFigure;
begin
  Figure := TRectangle.Create;
  Figure.Draw;  // 执行a1
  Figure.Destroy;
  Figure := TEllipse.Create;
  Figure.Draw;  // 执行a2
end;

二、overload 多态
  procedure foo(i: integer); overload;
  procedure foo(d: double);  overload;
  procedure foo(v: variant); overload;
典型用法。如果是对于继承的。必须使用reintroduce
type
  T1 = class(TObject)
    procedure Test(I: Integer); overload; virtual;
  end;
  T2 = class(T1)
    procedure Test(S: string); reintroduce; overload;
  end;
   ...
  SomeObject := T2.Create;
  SomeObject.Test(‘Hello!‘);  // T2.Test
  SomeObject.Test(7);         // T1.Test

三、override & inherited
override是用来重载父类的procedure,
如果父类是virtual 或者 dynamic 方法的,就可以使用inherited,来调用父类中的代码。

四、abstract
procedure DoSomething; virtual; abstract;//如果是这个样式的,表示要在子类中实现(代码)。而父类中,其他procedure function可以使用这个procedure。
(这里的virtual似乎不能被dynamic替换)。
使用procedure DoSomething; virtual; abstract;和procedure DoSomething; virtual;的区别就是,前者的实现代码在子类,而后者实现代码在自身。后者可以在子类中override一下,使其子类也有自己的实现代码。
2009-4-11
在最近的代码中发现(不知道是不是D7的缘故)
procedure DoSomething; virtual; abstract;
procedure DoSomething; dynamic; abstract;
都是可以的。
而且在继承类中也可以不写实现代码。
在基类中如果要判断有没有被继承类写实现代码的方式不是
if Assigned(DoSomething) then ...
而是
if MethodAddress(‘DoSomething‘)<>nil then...

五、reintroduce
覆盖父类中的virtual 方式的内容。(编译器不会提示“xxx 被hide了”)

六、static
默认就是这个。
我们常打 procedure test(xx:Integer);其实就是static的。
这个比较好理解。
如果子类中,声明了一个test,跟父类无关。各自用各自的。
除非使用强制转换。比如:
type
  TFigure = class
    procedure Draw;
  end;
  TRectangle = class(TFigure)
    procedure Draw;
  end;
//实现
var
  Figure: TFigure;
  Rectangle: TRectangle;
begin
  Figure := TFigure.Create;
  Figure.Draw;  // 父类用父类的 TFigure.Draw
  Figure.Destroy;
  Figure := TRectangle.Create;
  Figure.Draw;  // 虽然初始化为子类,但是由于申明的是父类,所以Figure还是调用了父类的Draw  TFigure.Draw
  TRectangle(Figure).Draw;  // 强制转换成子类,就可以用TRectangle.Draw
  Figure.Destroy;
  Rectangle := TRectangle.Create;
  Rectangle.Draw;  // 子类用子类的 TRectangle.Draw
  Rectangle.Destroy;
end;

七、forward declaration提前定义。
用于类被提前使用。注意fd的class后面要立即加“;”不能使用括号和基类。
type
  TFigure = class;  // forward declaration
  TDrawing = class
    Figure: TFigure;
     ...
  end;
  TFigure = class  // defining declaration
    Drawing: TDrawing;
     ...
  end;

八、virtual 和 dynamic
虚拟方法占用的内存大,调用速度快;动态方法相反。
如今,哪有PC内存不够的。
所以,笔者建议,就使用virtual吧。
2009-04-07
我知道了,内存是有不够用的时候。
所以这里修改说法,需要来回调用的用virtual,一般只用到1,2次的用dynamic。
像笔者一般写一个基类函数,只用一次,所以大部分都改成dynamic了。
但是有个地方必须要用virtual
private
  FItem:Integer
  procedure SetItem(Value:Integer);virtual;//dynamic不允许
public
  property Item:Integer;read FItem write SetItem;
end;

参考:http://www.cnblogs.com/key-ok/p/3380401.html

时间: 2024-11-02 21:01:01

Delphi重载,覆盖,多态的相关文章

java中的覆盖,重载和多态

今天来介绍java中的三大强功能覆盖,重载和多态. 方法覆盖:当一个子类继承了一个父类时,它也同时继承了父类的属性和方法,可以直接使用父类的属性和方法,或者,如果父类的方法不能满足子类的需求,则可以在子类中对父类的方法进行"改造"即覆盖.在覆盖的过程中,需要提供和父类中的被覆盖方法相同的方法名称,输入参数以及返回类型.另外,在子类对父类的方法进行覆盖的过程中,不能使用比父类中的被覆盖方法更严格的访问权限,例如父类中方法的修饰符为public,则子类的覆盖方法不能用protected,d

重写,重载,多态,继承的区别。

重写,重载,多态,继承的区别: 继承是子类继承父类的方法: 重写(override)是子类重写父类允许访问的方法.返回值和参数类型必须相同. 重载(overload)就是允许多个同名但是形参个数或者类型不同的函数方法存在于同一个类里.当类统一调用方式时由形参来决定调用具体的方法. 下面是转载的一篇文章: 继承是子类获得父类的成员,重写是继承后重新实现父类的方法.重载是在一个类里一系列参数不同名字相同的方法.多态则是为了避免在父类里大量重载引起代码臃肿且难于维护. 网上看到一个有趣的说法是:继承是

Java之方法重写、方法重载、多态

Java之方法重写.方法重载.多态博客分类: java语言Java重写重载多态 一.方法重写(Override) 子类可以重写父类的方法. 方法的返回值类型.参数类型.参数个数都不能改变,只能重写方法体. 方法的重写规则 参数列表必须完全与被重写方法的相同: 返回类型必须完全与被重写方法的返回类型相同: 访问权限不能比父类中被重写的方法的访问权限更低. 例如:如果父类的一个方法被声明为public,那么在子类中重写该方法就不能声明为protected. 解释:用于多态(父类引用子类对象). 声明

重写、覆盖、重载、多态几个概念的区别分析

[仔细阅读,很不错] override->重写(=覆盖).overload->重载.polymorphism -> 多态 override是重写(覆盖)了一个方法,以实现不同的功能.一般是用于子类在继承父类时,重写(重新实现)父类中的方法.重写(覆盖)的规则:   1.重写方法的参数列表必须完全与被重写的方法的相同,否则不能称其为重写而是重载.   2.重写方法的访问修饰符一定要大于被重写方法的访问修饰符(public>protected>default>private

重写、覆盖、重载、多态区别

override->重写(=覆盖).overload->重载.polymorphism -> 多态 override是重写(覆盖)了一个方法,以实现不同的功能.一般是用于子类在继承父类时,重写(重新实现)父类中的方法.重写(覆盖)的规则:   1.重写方法的参数列表必须完全与被重写的方法的相同,否则不能称其为重写而是重载.   2.重写方法的访问修饰符一定要大于被重写方法的访问修饰符(public>protected>default>private).   3.重写的方

8.继承、覆盖、重载与多态

1. 继承 1.1 继承的概念 1.1.1 概念 继承是java面向对象编程技术的一块基石,因为它允许创建分等级层次的类. 继承就是子类继承父类的特征和行为,使得子类对象(实例)具有父类的实例域和方法,或子类从父类继承方法,使得子类具有父类相同的行为. 例如: 兔子和羊属于食草动物类,狮子和豹属于食肉动物类. 食草动物和食肉动物又是属于动物类. 所以继承需要符合的关系是:is-a,父类更通用,子类更具体. 虽然食草动物和食肉动物都是属于动物,但是两者的属性和行为上有差别,所以子类会具有父类的一般

C++:区别覆盖,重载与多态

覆盖:在基类中定义了一个非虚拟函数,然后在派生类中又定义了一个同名同参数同返回类型的函数,这就是覆盖了.在派生类对象上直接调用这个函数名,只会调用派生类中的那个.重载:在基类中定义了一个非虚拟函数,然后在派生类中定义一个同名,但是具有不同的参数表的函数,这就是重载.在派生类对象上调用这几个函数时,用不同的参数会调用到不同的函数,有可能会直接调用到基类中的那个.多态:在基类中定义了一个虚拟函数,然后在派生类中又定义一个同名,同参数表的函数,这就是多态.多态是这3种情况中唯一采用动态绑定技术的一种情

Java学习资料-方法覆盖、方法重载、多态与动态绑定

1.方法覆盖 方法覆盖就是子类定义一个和父类同名的方法来覆盖父类的方法.当父类方法在某些子类中被覆盖后,通常是子类调用父类,并做一些额外的其它工作. 使用方法覆盖应注意下面一些事项: 不使用super而希望引用父类方法会导致无限的递归,因为子类方法实际上是在调用它自己. 当通过父类引用调用一个方法时,Java会正确地选择与那个对象对应的类的覆盖方法.对于父类提供的方法,子类可以覆盖它,但这不是必须的,即子类也可以使用一个方法的父类版本. 方法覆盖中,子类在重新定义父类已有的方法时,应保持与父类完

重载 覆盖 隐藏

本文转自:http://www.jb51.net/article/54225.htm 本文实例讲述了C++中重载.重写(覆盖)和隐藏的区别,对于C++面向对象程序设计来说是非常重要的概念.具体分析如下: 1.重载:重载从overload翻译过来,是指同一可访问区内被声明的几个具有不同参数列(参数的类型,个数,顺序不同)的同名函数,根据参数列表确定调用哪个函数,重载不关心函数返回类型. 示例代码如下: ? 1 2 3 4 5 6 7 8 class A{ public:   void test(i