Delphi的类和对象（四）- 类的方法

方法是在类中定义的且包装在类中的函数或过程，用于执行类的操作，完成类的任务。一个类的方法决定了通过这个类创建的实例行为，

一个类的所有方法决定了这个实例所执行的功能。类中的所有函数或过程都可以成为类的方法。

在Delphi 中子程序包含过程和函数两种表现形式，而方法通过这两种形式演变出 6种不同的形态。

（1）过程方法和函数方法：

　　  依附于某个特定的类，在某个类的声明中定义并根据可见性进行调用，如果过程方法或函数方法被声明成私有的，则他只能在这个类的实例中调用。

　　  与一般过程和函数一样，过程方法没有返回值，函数方法具有返回值。

（2）构造方法与析构方法：

　　  主要作用就是用于创建和释放类的对象，参考类和对象（一）有记录。

（3）类过程方法和类函数方法：

　　  类过程方法和类函数方法与过程方法和函数方法基本相同，不同的地方在于过程方法和函数方法必须在类的某个对象实例化之后才可使用。

　　  而类过程方法和类函数方法的操作对象不是类的对象而是类本身，所以不用通过对象来引用，类本身就可以引用类过程方法和类函数方法。

　　  当一个类的对象经常要调用类中的一个方法时，而这个方法又不需要使用类中所定义的变量，就可以将这个方法定义为类方法。

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs;

type
  TForm1 = class(TForm)
  private
    { Private declarations }
  public
    { Public declarations }
    class function GetformName: String;
    class procedure SetFormName(FormName: string);
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

{ TForm1 }

class function TForm1.GetformName: String;
begin
  Result:= Form1.Name;
end;

class procedure TForm1.SetFormName(FormName: string);
begin
  Form1.Name:= FormName;
end;

end.

在类中的方法按其功能分为静态方法，虚方法，动态方法。

（1）静态方法：静态方法是最常用的一种方法，如果不在方法声明时特意指定关键字，所声明的方法都是静态方法。

　　  当静态方法被声明时，编译器就会为这个方法指定一个地址。当调用这个方法时就是就会通过这个地址进行调用。静态方法是调用最快的一种。

　　  如果在父类定义一个静态方法，子类继承这个方法时只是将父类的这个方法地址赋予给了子类，所以子类继承的方法调用的还是父类方法。

　　  当子类中定义了一个和父类同名的静态方法时，子类的静态方法将覆盖父类的静态方法。当子类调用这个静态方法，调用的是自身的方法。

（2）虚方法：虚方法的声明只需要在方法声明的后面加上 virtual 关键字，父类中定义好虚方法之后，如果子类中定义了一个同名的方法，那么调用时子类的方法就不会像

　　  静态方法那样去覆盖父类的同名方法，而是在继承父类原有方法的基础上展现自身方法的特性。对虚方法的覆盖也叫重载（override）。

　　  静态方法的地址是固定的，虚方法的地址在编译器编译时是不会指定的，而是在程序运行时通过动态查找而制定的，所以虚方法调用时会比虚方法要快。

　　  虚方法的调用是通过一个虚拟表来实现的，编译器会为每一个类类型生成一个虚拟表，虚拟表用来存储虚方法入口地址。一个类只有一个虚拟表，该类的所有对象都会通过这个表调用虚方法。

　　  当类中的某个对象被创建时，编译器会为这个对象指定所属类的虚拟表，而指向这个虚拟表的指针存储在对象地址的前4 个字节中，如果类中没有定义虚方法，此时指向虚拟表的指针将设为空。

（3）动态方法：动态方法与虚方法在语意以及使用上都是一样的，只是存储方式不同，动态方法也有相应的地址表，叫做动态方法表。动态方法的定义是在方法声明时最后加 dynamic 。

　　  一般情况下在子类中经常覆盖父类的方法时可使用虚方法，而不经常覆盖父类的方法时就使用动态方法。因为虚方法的执行效率要高于动态方法，而动态方法又比较节省空间。 

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type
  TForm1 = class(TForm)
    Button1: TButton;
    procedure FormCreate(Sender: TObject);
    procedure Button1Click(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;
  TMyClass = class   {定义类; 虽然这个类没有什么实际意义, 但就是一个类了}
    d: TDate;
  end;

//父类
  TParent = class
  protected
    function MyFun(i: Integer): Integer; dynamic;  //动态方法
    procedure MyProc; virtual;  //虚方法
  end;

//子类
  TChild = class(TParent)
  protected
    function MyFun(i: Integer): Integer; override;  //覆盖
    procedure MyProc; override;  //覆盖
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

{ TParent }

function TParent.MyFun(i: Integer): Integer;
begin
  Inc(i);
  Result := i;
end;

procedure TParent.MyProc;
begin
  ShowMessage('Parent');
end;

{ TChild }

function TChild.MyFun(i: Integer): Integer;
begin
  i := inherited MyFun(i);  //先调用夫类方法，被 +1；当然也可以不调用
  Inc(i);                   //子类再 +1
  Result := i;
end;

procedure TChild.MyProc;
begin
  inherited;  //先调用夫类方法；当然也可以不调用
  ShowMessage('Child');
end;

//测试
procedure TForm1.FormCreate(Sender: TObject);
var
  p: TParent;
  c: TChild;
begin
  p := TParent.Create;
  c := TChild.Create;

  p.MyProc;  //Parent
  c.MyProc;  //Parent; TChild

  ShowMessage(IntToStr(p.MyFun(2)));  //3
  ShowMessage(IntToStr(c.MyFun(2)));  //4

  p.Free;
  c.Free;
end;

procedure TForm1.Button1Click(Sender: TObject);
var
  MyCls: TMyClass;  {声明一个类变量, 也就是对象}
begin
  {使用类}
  MyCls := TMyClass.Create;              {需要先手动建立, 因为类需要实例化为对象才可以使用}

  MyCls.d := Now;                        {2008-1-11}
  ShowMessage(DateToStr(MyCls.d));
  ShowMessage(IntToStr(SizeOf(MyCls)));  {4; 怎么会是4? 因为 MyCls 对象只是一个指针!}

  MyCls.Free;                            {用完后释放}
end;

end.

在虚方法和动态方法的基础上还有一个方法叫做抽象方法（abstract）抽象方法的定义只是在虚方法与动态方法的标识符后秒加 abstract 标识符。

在类的声明中包含了抽象方法，那么此类也称为抽象类，它是一种特殊的专门为父类所定义的处于层次结构较为上层的类。在设计类的结构时，如果想将具有共性的

功能抽象成一个类的话，就可以将这个类声明为抽象类。而对于抽象类的可见性最好是设置成受保护的。

抽象方法不同于普通的方法，不具备方法体，在父类定义，子类实现。否则程序不能调用的。

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs;

type
  TForm1 = class(TForm)
    procedure FormCreate(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;

{父类，抽象类 Delphi中的抽象类只定义行为的类，它规定了由此派生的类必须具备某些行为。但是抽象类不实现这些行为，而必须由其派生类去实现这些行为。所以，它只是一种“抽象”的类，而且，我们无法为抽象类创建实例。}
  TParent = class
  protected
    function MyFun(i: Integer): Integer; virtual; abstract;
    //抽象方法(纯虚方法)，只有定义没有实现，一个类包含一个即成抽象类，抽象类不能直接创建对象。
  end;

//子类
  TChild = class(TParent)
  protected
    function MyFun(i: Integer): Integer; override;  //覆盖
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

{ TChild }

function TChild.MyFun(i: Integer): Integer;
begin
  Inc(i);
  Result := i;
end;

//测试
procedure TForm1.FormCreate(Sender: TObject);
var
  p: TParent;
  c: TChild;
begin
  p := TChild.Create;  //抽象类只能通过其子类创建对象
  c := TChild.Create;

  ShowMessage(IntToStr(p.MyFun(2)));  //3
  ShowMessage(IntToStr(c.MyFun(2)));  //3

  p.Free;
  c.Free;
end;

end.