Delphi的学习笔记十一——类

最新推荐文章于 2023-08-25 13:47:45 发布
最新推荐文章于 2023-08-25 13:47:45 发布
阅读量410 收藏 1
点赞数
分类专栏： Delphi

一、

1.类成员的可见性

[delphi]  view plain copy
  1. private          //不可见  
  2. protected     //派生类可见  
  3. public           //可见  
  4. published     //可见。用于运行时信息  
  5. automated   //可见。用于兼容（只用于windows）  

在{$M+}状态下编译类时，它的默认可见性为published；否则，则它的可见性是public；


2.类方法调用

inherited（继承）：就是调用父类的函数。如果不带参数就是默认调用父类的同名函数；如果带参数则表明子类中的函数的参数个数可能比祖先类要多取其中的几个参数传过去
例如

[delphi]  view plain copy
  1. 祖先类有个函数 Create(AName:string);  
  2. 子类有个函数 Create(AName:string;AComponent:TObject);override;  
  3. 那么子类的Create函数内就可以这样调用祖先类：  
  4. procedure TAClass.Create(AName:string;AComponent:TObject);  
  5. begin  
  6. Inherited Create(AName);  
  7. end;  

类方法可以看做是公共方法，对于类方法的调用。例如：

[delphi]  view plain copy
  1. constructor TMyClass.Create;  
  2. begin  
  3.   inherited;  
  4.   MyProc;  //调用类方法  
  5. end;  
  6.   
  7. class procedure  TMyClass.MyProc;  
  8. begin  
  9.   ShowMessage('OK'); //类方法实现  
  10. end;  
  11. procedure TForm1.FormCreate(Sender: TObject);  
  12. var  
  13.   myclass : TMyClass;  
  14. begin  
  15.   TMyClass.MyProc;  //用类名调用类方法  
  16.   myclass := TMyClass.Create;   //初始化对象  
  17.   myclass.MyProc;  //对象调用类方法  
  18.   myclass.Free; //释放对象  
  19. end;  


3.覆盖虚方法

[delphi]  view plain copy
  1. //定义父类、子类方法  
  2. {父类}  
  3. TParent = class  
  4. protected  
  5.   function MyFun(i:Integer):Integer;dynamic; //动态方法  
  6.   procedure MyProc; virtual;  //虚方法  
  7. end;  
  8. {子类}  
  9. TChild = class(TParent) //继承父类  
  10. protected  
  11.   function MyFun(i:Integer):Integer;override;  //覆盖方法  
  12.   procedure MyProc; override;  
  13. end;  

实现类的方法、过程

[delphi]  view plain copy
  1. {TParent}  
  2. function TParent.MyFun(i:Integer): Integer;  
  3. begin  
  4.   Inc(i);  //i++  
  5.   Result:=i;  //返回变量i  
  6. end;  
  7. procedure TParent.MyProc;  
  8. begin  
  9.   ShowMessage('Parent');  
  10. end;  
  11.   
  12. {TChild}  
  13. function TChild.MyFun(i:Integer):Integer;  
  14. begin  
  15.   i:= inherited MyFun(i);  //继承父类的MyFun方法  
  16.   Inc(i);  
  17.   Result:=i;  
  18. end;  
  19. procedure TChild.MyProc;  
  20. begin  
  21.   inherited; //调用父类的MyProc方法  
  22.   ShowMessage('child');  
  23. end;  

我们可以注意到在实现子类方法的时候利用inherited来继承父类的方法。

 

4.抽象类考虑到抽象类在某种程度上可以用接口来代替，所以这里我并不在仔细对抽象类进行介绍。直接给例子：

[delphi]  view plain copy
  1. {父类}  
  2. TParent = class  
  3. protected  
  4.   function MyFun(i:Integer):Integer;abstract; //动态方法  
  5. end;  
  6. {子类}  
  7. TChild = class(TParent) //继承父类  
  8. protected  
  9.   function MyFun(i:Integer):Integer;override;  //覆盖方法  
  10. end;  

对类方法的实现也和第3点类方法的覆盖相类似。

 

5.方法重载

[delphi]  view plain copy
  1. {1.关于方法重载： 
  2.  2.过程和函数之间可以重载 
  3.  3.类内重载必须有 overload 关键字 
  4.  4.子类重载必须有 overload 关键字，夫类可以没有 
  5.  5.如果夫类是虚函数(virtual dynamic),子类重载时需要加 reintroduce 修饰词 
  6.  6.published 区内不能重载}  
  7.  //方法重载  
  8.  TMyClass2 = class  
  9.  protected  
  10.    procedure MyProc1(i:Integer); overload; //重载方法  
  11.    function MyFun1(s1,s2:string): string; overload;  
  12.  end;  

对类方法的实现也和第3点类方法的覆盖相类似。

 

6.参数默认值

例如

[delphi]  view plain copy
  1. //带默认值的参数只能在后面  
  2. function MyFun(a:Integer; b:Integer=1; c:Integer=2): Integer;  
  3. begin  
  4.   Result := a + b + c;  
  5. end;  


如在调用该函数时，对参数已赋值。则默认值不起作用；如未赋值，则用默认值进行操作。

 

7.属性的自动完成

在Type区写入

[delphi]  view plain copy
  1. TMyClass = class  
  2.     property s: string;  
  3.   end;  

然后把光标放在其中，执行Ctrl+Shift+C。Delphi会自动生成属性的相关代码

[delphi]  view plain copy
  1. TMyClass = class  
  2.   private  
  3.     Fs: string;  
  4.     procedure Sets(const Value: string);  
  5.   published  
  6.     property s: string read Fs write Sets;  
  7.   end;  
  8. { TMyClass }  
  9. procedure TMyClass.Sets(const Value: string);  
  10. begin  
  11.   Fs := Value;  
  12. end;  


8. 对TClass的调用（可读性好）：

[delphi]  view plain copy
  1. type TMyClass = class(TObject)  
  2. ...  
  3. end;  


9.Forward声明

[delphi]  view plain copy
  1. type  
  2.    TFigure = class;  
  3.    TDrawing = class  
  4.       Figure : TFigure;  
  5.       ...  
  6.    end;  
  7.    TFigure = class  
  8.       Drawing: TDrawing;  
  9.       ...  
  10.     end;  

二、

1.结构与类都是自定义类型，结构可以直接使用，内存是自动管理；类对象需要创建才可以使用，并在使用完成后需要对其手动释放。例如

[delphi]  view plain copy
  1. type  
  2.   TMyRecord = Record  
  3.     d:TDate;  
  4.   end;  
  5.   
  6.   TMyClass = class  
  7.     d:TDate;  
  8.   end;  
  9. procedure TForm2.Button1Click(Sender: TObject);  
  10. var  
  11.   myRecord : TMyRecord;  
  12.   myClass : TMyClass;  
  13. begin  
  14.   //使用结构（不需要初始化，内存自动管理）  
  15.   myRecord.d := Now;  
  16.   ShowMessage(DateToStr(myRecord.d));  
  17.   ShowMessage(IntToStr(SizeOf(myRecord)));//8  
  18.   
  19.   //使用类  
  20.   myClass := TMyClass.Create;  //初始化对象  
  21.   myClass.d := Now;  
  22.   ShowMessage(DateToStr(myClass.d));  
  23.   ShowMessage(IntToStr(SizeOf(myClass)));//4  
  24.   myClass.Free;   //释放对象  
  25. end;  


2.关于类的方法，在上一篇类的的文章中已经有所涉及。这里就不再详述。一般情况下，类都会定义在interface区；在implementation区定义的类只能本单元使用。

3.关于类的属性

类属性的定义：

[delphi]  view plain copy
  1. {定义两个属性}  
  2.   TMyClass2 = class  
  3.     private  
  4.       FName : string;  
  5.       FAge : Integer;  
  6.       procedure SetAge(const Value:Integer);    //Value设置为常量  
  7.       procedure SetName(const Value:string);  
  8.     published  
  9.       property Name: string read FName write SetName;  
  10.       property Age : Integer read FAge write SetAge;  
  11.     end;  


自定义set方法：

[delphi]  view plain copy
  1. procedure TMyClass2.SetAge(const Value: Integer);  
  2. begin  
  3.   if (Value>=0) and (Value<200) then  
  4.     FAge := Value;  
  5. end;  
  6.   
  7. procedure TMyClass2.SetName(const Value: string);  
  8. begin  
  9.   if Value<>'' THEN  
  10.     FName:= Value;  
  11. end;  


设置属性的直

[delphi]  view plain copy
  1. myClass2.Age := 99;    //访问属性  


4.类与事件

关于类与事件的定义，我将通过一个例子来给予说明。

 事件的定义：

[delphi]  view plain copy
  1. //定义事件  
  2.   TMyEvent = procedure of object;  
  3.   
  4.   TMyClass = class  
  5.     private  
  6.       FAge:Integer;  
  7.       FOnHundred:TMyEvent;  
  8.       procedure SetAge(const Value:Integer);  
  9.     published  
  10.       procedure SetOnHundred1;  //定义事件1  
  11.       procedure SetOnHundred2;  //定义事件2  
  12.       constructor create;       //Form初始化时执行  
  13.       property Age:Integer read FAge write SetAge;  
  14.       property OnHundred: TMyEvent read FOnHundred write FOnHundred; //定义事件属性（通过属性的形式来设置事件）  
  15.     end;  


在Form一开始创建的时候就必须先定义一个事件。

[delphi]  view plain copy
  1. constructor TMyClass.create;  
  2. begin  
  3.    FOnHundred:= SetOnHundred1;   
  4. end;  


事件的调用

[delphi]  view plain copy
  1. myclass.OnHundred := myclass.SetOnHundred2; //事件的指定（类似于属性）  


事件类型是一个指针，指向一个过程（不带返回值的方法），事件在定义时指定了参数的类型和个数，调用过程的参数必须与其保持一致。

 

5. 字段

[delphi]  view plain copy
  1. type  
  2.    TAncestor = class  
  3.        Value : Integer;  
  4.    end;  
  5.    TDescendant = class(TAncestor)  
  6.        Value : string;  
  7.    end;  
  8.    var  
  9.       MyObject : TAncestor;  
  10.    begin  
  11.       MyObject := TDescendant.Create;  
  12.       TDescendant(MyObject).Value := 'hello world';  
  13.    end;  
三、

1.类的继承

继承类的定义

[delphi]  view plain copy
  1. {父类}  
  2.   TBase = class  
  3.     procedure msg1;  
  4.   end;  
  5.   {继承父类}  
  6.   TChild = class(TBase)  
  7.     procedure msg2;  
  8.   end;  


对于子类与父类的使用与一般类的调用并没有特殊的区别，这里不再详述。在子类中，如果需要调用父类的方法，可以利用inherited指示字：

[delphi]  view plain copy
  1. procedure TChild1.Proc;  
  2. begin  
  3.   inherited Proc;            {调用父类的 Proc 方法}  
  4. end;  

 

2.类的封装

待补充。。。

3.类的多态性

多态是同一个方法在不同的对象里会有不同的实现。在定义类的多态的时候需要在父类创建虚方法，并在子类重写该方法。

[delphi]  view plain copy
  1. {父类}  
  2.   TBase = class  
  3.     procedure alert;virtual; //定义一个虚方法  
  4.   end;  
  5.   
  6.   {子类1}  
  7.    TChild1 = class(TBase)  
  8.     procedure alert;override;  //重载父类方法  
  9.    end;  
  10.   
  11.    {子类2}  
  12.    TChild2 = class(TBase)  
  13.     procedure alert;override;  
  14.    end;  

以下是对于类的调用

[delphi]  view plain copy
  1. {调用父类的方法}  
  2. procedure TForm2.Button1Click(Sender: TObject);  
  3. var  
  4.   base : TBase;  
  5. begin  
  6.   base := TBase.Create;  
  7.   base.alert;  
  8.   base.Free;  
  9. end;  
  10.   
  11. {调用子类1的方法}  
  12. procedure TForm2.Button2Click(Sender: TObject);  
  13. var  
  14.   base : TBase;  
  15. begin  
  16.   base := TChild1.Create;  
  17.   base.alert;  
  18.   base.Free;  
  19. end;  


这里我们可以看到，对父类对象引用子类对象进行初始化，这也充分体现了类的多态性。

4.抽象类

用class abstract说明抽象类，但内部必须有抽象方法。例如

[delphi]  view plain copy
  1. TMyClass5 = class abstract(TObject)  
  2.     procedure Proc; virtual; abstract;  
  3.   end;  


类中数据成员的排列顺序一般是：字段、方法、属性。

5.类的向前声明

例如：

[delphi]  view plain copy
  1. //解决方案 - 向前声明  
  2.   TClassB = class; {向前声明}  
  3.   
  4.   TClassA = class  
  5.     Field1: string;  
  6.     Field2: Integer;  
  7.     Field3: TClassB;  
  8.   end;  
  9.   
  10.   TClassB = class  
  11.     Field1: string;  
  12.     Field2: Integer;  
  13.   end;  
四、

1.类的方法参数可以分为四种（默认参数（传值）、var（传址）、out（输出）、const（常数））。这里需要注意的是var定义的参数，例如：

[delphi]  view plain copy
  1. {var参数是传址, 会被改变}  
  2. function MyF2(var x: Integer): Integer;  
  3. begin  
  4.   Inc(x);  
  5.   Result := x;  
  6. end;  

Inc(x)：表示对x的内存地址加1，这将导致方法返回的值的变化。

对于out(输出)，其用法和var一致，所以在一般情况下我们采用var来定义而不是out；对于const，则表示该定义的变量为常量，常量的值无法改变。

 

2.implementation区/interface区的方法

对于implementation区中的方法，只能在本单元中调用。这里就不举例子了，在之前的举例中都有涉及。

对于interface区中的方法，可以被其它单元调用。

 

3.在类中的方法

如果一个方法被声明在一个类中，那么调用该方法前就必须先对该类进行初始化。这与其他语言对于类中方法的调用是一致的；并且在实现该方法时，必须在方法名前加上类的前缀，例如：

[delphi]  view plain copy
  1. {函数在实现区必须有 TForm1. 作为前缀}  
  2. function TForm1.MyFun(x,y: Integer): Integer;  
  3. begin  
  4.   Result := x + y;  
  5. end;  


4.调用其他单元的函数

在调用其他单元的函数时，被调用单元的函数必须在interface区中声明，并在implementation区中也实现。在调用时，我们需要对其单元进行引用，例如：

[delphi]  view plain copy
  1. implementation  
  2.   
  3. {$R *.dfm}  
  4.   
  5. uses Unit2; {必须 uses 定义函数的单元}  
  6.   
  7. procedure TForm1.Button1Click(Sender: TObject);  
  8. var  
  9.   i: Integer;  
  10. begin  
  11.   i := MyFun(1,2);         {调用函数}  
  12.   //i := Unit2.MyFun(1,2); {有时为了避免重名, 需要这样调用}  
  13.   ShowMessage(IntToStr(i)); {3}  
  14. end;  


5.方法的提前声明

如果前面的方法需要调用后面的方法，则需要在被调用的方法中声明forward指示字。例如：

[delphi]  view plain copy
  1. function MyFunB(x: Integer): Integer; forward; {使用 forward 指示字提前声明}  
  2.   
  3. function MyFunA(x: Integer): Integer;  
  4. begin  
  5.   Result := MyFunB(x) * 3; {要调用后面的方法, 后面的方法需要提前声明}  
  6. end;  
  7.   
  8. function MyFunB(x: Integer): Integer;  
  9. begin  
  10.   Result := Abs(x);  
  11. end;  

但如果该方法已在interface区中提前声明了，那么就无需在对方法添加forward指示字了。

 

6.静态数组做参数

对于静态数组做参数，我们需要在Type区把数组定义成一个类型，在对该类型定义一个变量，最后在使用该变量。例如：

[delphi]  view plain copy
  1. //应该先把数组定义成一个类型  
  2. Type  
  3.   IntArray = array[0..9] of Integer; {先把需要的数组定义成一个类型}    
  4. //给一个静态数组求和的函数  
  5. function MyFun(arr: IntArray): Integer;  
  6. var  
  7.   i: Integer;  
  8. begin  
  9.   Result := 0;  
  10.   for I:= 0 to Length(arr)-1 do  
  11.   begin  
  12.     Result := Result + arr[I];  
  13.   end;  
  14. end;  


而对于开放数组参数，则可以将其直接作为参数来使用，不需要在Type区将其定义为一个类型。例如：

[delphi]  view plain copy
  1. function MyFun(const arr: array of Integer): Integer;  


对于遍历开放数组也需要注意，因不知其长度，所以在遍历时需要用到Low()和High()方法，例如：

[delphi]  view plain copy
  1. for i := Low(iArr) to High(iArr) do  
  2.   begin  
  3.     iArr[i] := i + 1;  
  4.   end;  


7.指针参数

在方法中传递指针，我们需要用指针类型来定义。具体实现如下：

[delphi]  view plain copy
  1. function MyFun(p: PInteger): Integer; {PInteger 是 Integer 的指针类型}  
  2. begin  
  3.   p^ := p^ * 2;  
  4.   Result := p^;  
  5. end;  


在调用该函数时，需要用@来获取变量的地址，例如：

[delphi]  view plain copy
  1. var  
  2.   i,x: Integer;  
  3. begin  
  4.   i := 8;  
  5.   x := MyFun(@i);             


9.方法重载

方法的重载只要用在方法重名但参数不一样的情况，在方法后面必须声明overload指示字。在调用时根据参数来决定调用哪个方法。这与其他语言的重载相似。在published区中的方法命名要有唯一性，该区域方法不能被重载。

my98800
关注
专栏目录
【Delphi 基础知识 2】定义类的几种形式
记录日常技术经验
12-27 585
type// 基本类定义private// 私有成员protected// 受保护成员public// 公有成员// 构造函数// 析构函数override;// 成员方法end;上述是一个简单的类定义，包含私有、受保护和公有成员，以及构造函数、析构函数和一个成员方法。
Delphi XE2 之 FireMonkey 入门学习笔记
10-23
### Delphi XE2 之 FireMonkey 入门学习笔记 #### 一、Delphi XE2 FireMonkey 概述 Delphi XE2引入了一种全新的跨平台UI框架——FireMonkey（简称FMX），该框架支持Windows和Mac OS X操作系统，并且能够提供丰富的...
Delphi 基础知识：类和对象
sensor_WU 博客
03-19 1832
具有严格保护可见性的类成员在它们被声明的类中是可见的，在任何子类中也是可见的，不管它在哪里被声明。一个类的实例不能访问同一个类的其他实例中的严格私有或严格保护的实例成员。一个被保护的成员在其类被声明的模块中的任何地方都是可见的，也可以从任何子类中看到，不管子类出现在哪个模块。受保护的方法可以被调用，受保护的字段或属性可以被读写，可以从属于声明受保护成员的类的任何方法的定义中调用。在类声明的开头没有指定可见性的成员默认为公开的，只要该类是在{$M+}状态下编译的，或者是从{$M+}状态下编译的类派生的；
delphi自定义类大体描述
yygyyygy1233的博客
12-18 722
delphi类,自定义类的大体描述. 刚刚接触的Delphi的朋友，可能最感兴趣的就是它丰富、强大的VCL（可视化构件库）。仅仅向窗体上扔几个构件，甚至不用动手写代码，就能很容 易地做出一个有实用价值的程序，真是令人激动。但是，VCL只是Delphi的一小部分，Delphi的优秀远远不只是表现在VCL上。如果你仅仅停留在 使用VCL这一阶段，那么你永远也不可能成为一个真正的Delphi高手。记住，...
理解 Delphi 的类(二) - 初识类的方法
兴趣使然的编程菜鸟
10-20 441
此时我们的类定义就可以放到interface区，直接把定义放在type里面，就无需再多写个type了， 而过程与函数的实现还是放在implementation区。在类中的属性叫做成员变量，方法叫做成员方法；我们在类中定义过程和函数基本相同，唯一的区别就是在类的过程和函数名称前面加上类名和句点。在Object Pascal语言对类的定义和其他语言一样，都是使用class关键字来声明一个类的。在 implementation 区定义的类只能本单元使用。下面把过程与函数包含在一个类里面。
delphi 类的写法 和 控制台程序的制作---深入Delphi编程 数据库
chinajobs的专栏
12-21 2124
2、数据库 　　 　　在相对枯燥的理论之后，我们终于要开始接触到一些比较激动人心的实际应用了。 　　数据库编程是Delphi最强大的优势之一，恐怕也很少有Delphi程序员没有接触过数据库编程的。Delphi独特的Data-Aware构件，让很多初识Delphi的人为之目瞪口呆。不需要写任何代码，在几分钟之内就可以做出一个相当精巧的数据库程序，而且在开发期就可以看到运行期的结果，这真是不可思
delphi笔记
04-20
《Delphi笔记——深入探索与实践》 Delphi，这个由Borland公司开发的集成开发环境（IDE），因其高效、强大的对象 Pascal 编程语言和丰富的组件库，长期以来深受程序员喜爱。它不仅适合快速开发桌面应用程序，还能...
Delphi学习资料
04-20
《Delphi学习之旅：深入解析开发宝典与实用工具》 Delphi，这款强大的面向对象的编程语言，自诞生以来就深受程序员喜爱。它以其高效、简洁的语法和丰富的库支持，成为Windows平台上软件开发的重要工具。对于想要...
Android（OPhone）学习笔记-界面设计工具.doc
07-05
本篇学习笔记主要介绍了一个开源的Android界面设计工具——DroidDraw，它允许开发者以可视化的方式创建界面布局，从而简化XML布局文件的编写过程。 DroidDraw是一款类似于VB、Delphi或JBuilder的拖放式界面设计工具...
基于delphi试卷生成系统源码.zip
最新发布
08-26
这个标题揭示了我们要讨论的核心内容——一个使用Delphi编程语言开发的试卷生成系统。Delphi是一种面向对象的 Pascal 编程语言，它以其高效的编译器和强大的集成开发环境（IDE）而闻名，常用于快速开发桌面应用程序...
Delphi语法（九）泛型
ForAnnuus的博客
04-23 1150
Delphi语法第十章 泛型
Delphi语法（五）类与对象
ForAnnuus的博客
04-19 481
Delphi语法 第六章 类与对象
理解 Delphi 的类(七) - 认识类的多态
男神的专栏
05-17 375
{总结: 现在同是 bass.alert 方法, 通过不同对象的实现, 有了不同的功能, 这就是多态!{同一个方法, 在不同类里有不同的实现}{同一个方法, 在不同类里有不同的实现}{同一个方法, 在不同类里有不同的实现}我的理解就是: 同样一个方法, 在不同的对象里会有不同的实现, 仅此而已.bass: TBass;{注意还是定义 TBass 的变量}bass: TBass;//定义了三个类, 后两个类都继承与第一个类 TBass。
Delphi中的容器类
weixin_33924770的博客
03-09 182
Delphi中的容器类作者 陈省从Delphi 5开始VCL中增加了一个新的Contnrs单元，单元中定义了８个新的类，全部都是基于标准的TList 类。 TList 类TList 类实际上就是一个可以存储指针的容器类，提供了一系列的方法和属性来添加，删除，重排，定位，存取和排序容器中的类，它是基于数组的机制来实现的容器，比较类似于C++中的Vector和Java中的A...
Delphi的学习笔记——类
SauceJ的专栏
05-19 708
1.类成员的可见性private //不可见 protected //派生类可见 public //可见 published //可见。用于运行时信息 automated //可见。用于兼容（只用于windows）
理解 Delphi 的类(一) - 从结构/记录谈起
兴趣使然的编程菜鸟
10-20 437
类的概念类是一种用户自定义的数据类型，可以说它是对某一类事物的抽象描述。类使用属性和方法来描述某一事务的具体特性和行为。简单举个例子：将轮船作为类进行描述，轮船不单单指一个物体，而是一类的总称。所以可以不考虑大小，颜色……而是将它抽象为一个类，对应的大小，颜色就可以在类中以属性的形式体现，而轮船在水中运动就是它的方法，所以。
理解 Delphi 的类(五) - 认识类的继承
男神的专栏
08-25 311
一个是 TForm 类;一个是 TForm1 类;TForm1 继承于 TForm.先新建一个 VCL Forms Application 工程, 代码中就已经出现了两个。TForm 是 TForm1 的父类;TForm1 是 TForm 的子类.//测试2: 子类有两个方法, 自己一个 msg2, 还继承了一个 msg1。//下面自定义了两个类, TChild 继承于 TBass。//测试1: 父类只有一个方法 msg1。
Delphi 类的学习
LoveCProgramming的专栏
02-28 754
一、类与对象1、  类(Class)是用户定义的数据类型2、  对象（Object）是类(Class)的一个实例，或由类定义数据类型的一个变量;3、  类有一种状态（内部数据），操作（行为或方法），属性;4、  对象是一个实体，程序运行时会为其内部表现分配一些内存;5、  类与对象之间的关系和变量与类型之间一样的；6、创建一个类 类型名(class name) =class
"Delphi学习笔记：函数用法及技巧举例详解
Delphi学习笔记是关于Delphi编程语言的个人学习笔记，涵盖了各种函数的说明、用法和技巧的示例。下面是我对这些内容的总结： 我首先记录了一个简单的数学运算函数的示例。在Delphi中，使用“mod”操作符可以计算两...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值