Delphi的学习笔记十一——类

最新推荐文章于 2023-12-27 21:27:15 发布
最新推荐文章于 2023-12-27 21:27:15 发布
阅读量433 收藏 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 动态创建类
xhfbx的博客
07-24 592
昨天在看 Java Web 开发时有看到servlet 通过反射动态创建类，想到Delphi中能否实现。 环境 Win10 x64 , Delphi 10.4 需引用System.Rtti ； 发现 private 下的function GetXY:Integer 没有获取到，why? Rtti设计就这样？ unit untTest; interface uses Classes,SysUtils,Dialogs; type TTestClass = class(TPer...
Delphi中的容器类
weixin_33924770的博客
03-09 196
Delphi中的容器类作者 陈省从Delphi 5开始VCL中增加了一个新的Contnrs单元，单元中定义了８个新的类，全部都是基于标准的TList 类。 TList 类TList 类实际上就是一个可以存储指针的容器类，提供了一系列的方法和属性来添加，删除，重排，定位，存取和排序容器中的类，它是基于数组的机制来实现的容器，比较类似于C++中的Vector和Java中的A...
Delphi中的容器类（转载）
lch_love_hl的专栏
03-12 1418
Delphi中的容器类作者 陈省 从Delphi 5开始VCL中增加了一个新的Contnrs单元，单元中定义了８个新的类，全部都是基于标准的TList 类。   TList 类TList 类实际上就是一个可以存储指针的容器类，提供了一系列的方法和属性来添加，删除，重排，定位，存取和排序容器中的类，它是基于数组的机制来实现的容器，比 较类似于C++中的Vector和Java中的ArrayList，T
谈谈Delphi中的类和对象
菠菜汤的收藏
09-25 868
1.登不了大雅之堂地理解几个概念   说到类和对象，我们不能不提及这样几个概念：类，对象，实例。就我个人觉得可以这样来理解：对象指的是泛称，自然界的任何实体都可以看成一个对象；而类则是以这些对象某些特征而分成的一系列的种类；实例则是特指属于某一个类的一个对象。好啦，这些大道理我就不用多说了。不如来一个“背道而驰”的作法，我们用Delphi code 来阐述这些外国人提出的一些令我们中国人不好理解的
Delphi面向对象学习随笔九：后记
intelsong的专栏
03-03 447
Delphi面向对象学习随笔九：后记作者：巴哈姆特http://www.cnpack.org（转载时请注明出处并保持完整） 最后一篇了，呵呵！其实通过写这几篇笔记，也发现了我自己知识欠缺的部分。当然也通过各位高手的提点，让我把以前学习过的东西来了一次“体检”。    当然，错误也有，但是改了就还是好同志嘛，呵呵^_^     随便介绍一下Delphi中的几个比较常用的类吧:   TOb
Delphi学习笔记二——数据类型
kimifdw的专栏
12-06 1886
Delphi的数据类型主要有以下这几类：简单数据类型(Simple)，字符串数据类型（String），结构数据类型（Struct），指针数据类型（pointer），函数和过程数据类型（procedural），变体数据类型（variant）等。下面我们来一一做一个介绍。 一、简单数据类型 简单数据类型分为有序数据类型（ordinal）和实数数据类型（real）两种。 1.1 有序数据类型 有
Delphi学习笔记四——语句
kimifdw的专栏
12-10 1147
今天我们来看一下Delphi的语句。 一、常量声明语句 和其他语言一样，常量在声明时就被赋值，且在程序执行过程中是不可改变的。常量用“=”表示两边的值是相等的。 const Pi = 3.14159; Answer = 342; ProductName = 'Delphi';   二、赋值语句 这个语句最常用，在之前也介绍过。这里就
Delphi学习笔记一——单元文件（补充）
kimifdw的专栏
01-14 1047
单元文件是我们在Delphi开发中最常用的文件，主要的代码编写都在该文件中进行。所以，我们有必要对其文件结构进行分析。一个单元文件主要有以下几部分组成：单元文件头部、接口部门、实现部分，前三者是最主要也是最常见的，还有就是initialization部分和finalization部分。 1. unit heading 例如：unit MainForm;结构，其中MainForm与该单元文件的文
delphi基础学习笔记二——delphi 单引号和双引号的区别
yanni23的专栏
05-10 1687
<br />1.$aa = "中国";<br />   echo "我爱$aa";//输出"我爱中国"<br />   echo '我爱$aa';//输出"我爱$aa"<br />2.双引号表示其中字符可能包含变量，而单引号表示整个引号内的东西都当成字符串来处理。<br />也就是说：没有内设变量就用单引号''，有就用双引号""。<br />举例说明：<br />$var = 'this';<br />print "haha $var"; //OUT: haha this<br />print 'haha
数据结构与算法之美 | 学习笔记06 ——队列
跟一大桃一起学习
05-07 217
一、队列 队列：先进者先出，在队尾插入元素，在队头删除元素。基本操作为入队enqueue()和出队dequeue()。 1. 顺序队列和链式队列 队列与栈一样，可以用数组或链表来实现。 顺序队列：用数组实现的队列。 链式队列：用链表实现的队列。 基于数组的队列实现方法 队空判定条件为head == tail，队满判定条件为tail == n。 // 用数组实现的队列 public class Ar...
Delphi的学习笔记——类
SauceJ的专栏
05-19 726
1.类成员的可见性private //不可见 protected //派生类可见 public //可见 published //可见。用于运行时信息 automated //可见。用于兼容（只用于windows）
Delphi 类类型
weixin_30642561的博客
08-24 205
转载于:https://www.cnblogs.com/fanweisheng/p/11406297.html
Delphi中的类和对象
blazingfire的专栏
11-21 1050
                   谈谈Delphi中的类和对象1.登不了大雅之堂地理解几个概念   说到类和对象，我们不能不提及这样几个概念：类，对象，实例。就我个人觉得可以这样来理解：对象指的是泛称，自然界的任何实体都可以看成一个对象；而类则是以这些对象某些特征而分成的一系列的种类；实例则是特指属于某一个类的一个对象。好啦，这些大道理我就不用多说了。不如来一个“背道而驰”的作法，我们用Del
Delphi 类的学习
LoveCProgramming的专栏
02-28 770
一、类与对象1、  类(Class)是用户定义的数据类型2、  对象（Object）是类(Class)的一个实例，或由类定义数据类型的一个变量;3、  类有一种状态（内部数据），操作（行为或方法），属性;4、  对象是一个实体，程序运行时会为其内部表现分配一些内存;5、  类与对象之间的关系和变量与类型之间一样的；6、创建一个类 类型名(class name) =class
Delphi中类的使用
Steven_xg的专栏
09-27 1045
 unit Unit2;interfaceuses Dialogs;type  TPerson=Class(Tobject)  private    aname:string;    asex:string;    aage:integer;    function  getName():string;    function  getsex():string;    function
Delphi 基础知识：类和对象
sensor_WU 博客
03-19 1904
具有严格保护可见性的类成员在它们被声明的类中是可见的，在任何子类中也是可见的，不管它在哪里被声明。一个类的实例不能访问同一个类的其他实例中的严格私有或严格保护的实例成员。一个被保护的成员在其类被声明的模块中的任何地方都是可见的，也可以从任何子类中看到，不管子类出现在哪个模块。受保护的方法可以被调用，受保护的字段或属性可以被读写，可以从属于声明受保护成员的类的任何方法的定义中调用。在类声明的开头没有指定可见性的成员默认为公开的，只要该类是在{$M+}状态下编译的，或者是从{$M+}状态下编译的类派生的；
6. 明明类存在但是引用报红
m0_55895362的博客
10-02 165
然后import class就行了。
对象与类类型
.NET&Delphi小站－－－－编程技术的乐园
09-29 2160
                                  对象与类类型　　从用户角度考虑，用户并不需要了解面向对象编程，就可编写Delphi应用程序。当用户在建立新窗体，添加新构件以及处理事件时，大部分相关代码会由Delphi自动产生。但是，知道语言及其细节，对理解Delphi正在做什么并完全掌握它是很有帮助的。特别是有关类类型的概念及用法是学习后面构件编程及Delphi深入编程的基础。
【Delphi 基础知识 2】定义类的几种形式
最新发布
记录日常技术经验
12-27 613
type// 基本类定义private// 私有成员protected// 受保护成员public// 公有成员// 构造函数// 析构函数override;// 成员方法end;上述是一个简单的类定义，包含私有、受保护和公有成员，以及构造函数、析构函数和一个成员方法。
Delphi学习笔记：列表框与组合框控件详解
"Delphi部分学习笔记，涵盖了列表框(ListBox)和组合框(ComboBox)的使用，包括它们的常用属性、方法和事件，并提供了一个简单的Delphi工程创建及界面设计的步骤，以及如何通过代码操作这两个控件的示例。" 在Delphi...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值