delphi 基础

Class:

type
//class 声明或者定义继承一个类class(TObject). 
TDate = class
private
fDate: TdateTime;
Month, Day, Year: Integer;
public 

//构造函数，如果定义了constructor，默认构造函数无效
constructor Create (y, m, d: Integer);
constructor Create; overload;

//Destructor用于标识析构函数, 析构函数在类被释放时自动调用.析构函数只允许覆盖, 再不允许重载
//Free时，会调用Destory,调用前会判断是否为nil，但是调用后不会将self置为nil，因为不知道本身是否被引用。
destructor Destroy;override;

//procedure 无返回值
procedure SetValue (y, m, d: Integer); overload；

//overload 重载
procedure SetValue (NewDate: TDateTime); overload;
function LeapYear: Boolean;
function GetText: String;
procedure Increase;
proceure Y;

//虚拟函数，通C++相同，通过virtual table（VMT）来找到virtual函数入口，包含父类的VMT
function Voice:String; virtual;
//动态方法，结果和virtual相同，差别在于编译时候使用动态方发表(DMT)，
//子类使用唯一的数字+动态方法地址构成DMT，但是不包含祖先的DMT。所以运行时内存小，但是速度慢
//function Voice:String; dynamic;

//抽象函数，同C++，抽象函数，不能定义实例
function Jump:String; virtual; abstract;

//message方法可用于处理windows消息,可调用postMessage(TDateObj.hANDLE，wm_User, 0, 0); var是引用
procedure WMUser(var Msg: TMessage); message wm_User;

//属性名 : 属性值类型 read 属性读函数/属性值变量 write 属性写函数/属性值变量,write属性可以省略，变成只读
property Year: Integer read GetYear write SetYear;
end;

constructor TDate.Create;
begin
Day:= 0;
end;


type
TClassB = clas(TDate)
public
//父类可以访问子类方法
class procedure X;

//和C++一样叫虚拟函数，和java一样有override关键字...... 必须父类函数是virtual,如果不是，是覆盖而不是刻意动态绑定
function Voice:String; override;
end

procedure TDate.GetYear;
begin
Result := YearOf(fDate);
end;

procedure TDate.Y;
begin 
//Self访问当前对象，无参数方法可以省略()
Self.X;
end;

类型转换和异常处理：

//is 判断类型
if obj is ClassB then
xxxxx

//as 类型转换
(obj as ClassB).do

//异常处理
try…except…end;　
try…finally…end;
//和try…except…end不同，该结构的finally部分总被执行
//不存在try…except…finally…end结构来既处理异常，又保护资源分配的结构
//允许如下结构，从而实现既处理异常，又保护资源的分配
try
 try…except…end  
finally
end;

//触发异常，类似C++ throw
raise xxxException;

流程处理:

//If语句的通常结构是If...Then...else, else语句也可以不要.
//在If语句内如果有多个子语句, 则必须用begin...End结构进行区分.
if a > b then
begin
　WriteLn('a>b');
End
else
　WriteLn('b>a');

//For关键字引出For循环结构, 用于做指定次数的循环.
for i := 1 to 100 do sum := sum + i;
//如果循环变量是递减的, 则可以用DownTo关键字
for i := 100 downto 1 do Inc(sum);


//Case语句用于完成条件选择, Case语句的的被选择对象必须是有序类型, 包括整型, 枚举类型, 字符型等.
//Case语句必须由end结束,如果没有相符合的选择项, 可以加入else来作出通用选择.
function GetDays(AYear,AMonth: Integer): Integer;
begin
 case AMonth of
  1,3,5,7,8,10,12: Result := 31;
  4,6,9,11: Result := 30;
  2: begin
  if IsLeapYear(AYear) then
   Result:=29
  else
   Result:=28;
  end;
 else
  Result:=0;
end;

//While关键字用于引出While循环语句, 循环前先进行循环条件的判断, 如果条件为真则执行循环.
i := 0;
while i < 100 do
begin
　sum := sum + i;
　Inc(i);
end;

//Until关键字用于判断repeat循环结构的循环条件, 
//如果循环条件为真, 则退出循环.Until必须与repeat关键字联合使用.
i := 0;
repeat
　sum := sum + i;
　Inc(i);
until(i >= 100);

//Goto语句用在跳转行号, 可以跳转到当前结构层内任意位置.
//必须在声明处用label关键字声明行号.
//由于Goto语句会破坏程序的结构, 不推荐使用.
var
　a,b: Integer;
label
　X,Y;
begin
　if a > b then
　　goto X
　else
　　goto Y;
X:
　WriteLn('a > b');
Y:
　WriteLn('b > a');
end;

与或非

//Xor用于取异或, 当两个操作数相等时, 返回False, 不等时返回True.
var
　a,b: Integer;
begin
　a := 2; b := 3;
　if a xor b then
　　WriteLn('a xor b')
　else
　　WriteLn('a not xor b');
end;

//一、表示逻辑与 必须用括号括起
if (a>0) and (b>0) then
//二、表示位运算  必须用括号括起
var
a,b,c: Integer;
begin
c := (a and b);
end;

//一、表示逻辑或  必须用括号括起
if (a>0) or (b>0) then
//二、表示位运算  必须用括号括起
var
a,b,c: Integer;
begin
c := (a or b);
end;

数据类型

基本数据类型
类型             类型说明            使用说明
整形             Integer             标准数据类型，使用前不必定义
实型             Reall               标准数据类型，使用前不必定义
字符型           Character           标准数据类型，使用前不必定义
字符串型         String              标准数据类型，使用前不必定义
布尔型           Boolean             标准数据类型，使用前不必定义
枚举型           Enumerated          高级数据类型，先定义后使用
子界型           Subrange            高级数据类型，先定义后使用
集合型           Set                 高级数据类型，先定义后使用
数据类型         Aray                高级数据类型，先定义后使用
文件类型         File                高级数据类型，先定义后使用
记录类型         Record              高级数据类型，先定义后使用
类类型           Class               高级数据类型，先定义后使用
类引用类型       Class Reference     高级数据类型，先定义后使用
接口类型         Interface           高级数据类型，先定义后使用
指针类型         Pointer             高级数据类型，先定义后使用
过程类型         Procedural          高级数据类型，先定义后使用
可变类型         Variant             高级数据类型，先定义后使用 

整形数据      
类型          类型说名符    字节数     取值范围 
整型          Integer       4          -2 147 483 648——2 147 483 647 
序数型        Cardinal      4          0——4 294 967 295       
短整型        ShortInt      1          -128——127
长整型        LongInt       4          -2 147 483 648——2 147 483 647
小整型        SmallInt      2          -32 768——32 767
64位整数      Int64         8          -2 63次方——2 63次方-1
字型          Word          2          0——65 535
长字型        LongWord      4          0——4 294 967 295
字节型        Byte          1          0——255     

实型数据
类型          类型说明符    字节数     取值范围
单精度实型    Single        4          -3.4X10 38方——  -1.5X10-39方 ，1.5X10-39方——3.4X10 38方
双精度实型    Double        8          -1.7X10 308方——  -5.0X10-324方，5.0X10-324方——1.7X10 308方 
扩展型        Extended      10         -1.1X10 4932方——  -3.6X10 -4951方，3.6X10 -4951方——1.1X10 4932方
货币型        Currency      8          -922 337 203 685 477.580 8——922 337 203 685 477.5870
实型          Real          8          -1.7X10 308方—— -5.0X10 -324方，5.0X10-324方——1.7X10 308方

字符型数据
类型          名称          字节数     取值范围
字符型        Char          1(2)       扩展ANSI字符集
宽字符型      WideChar      2          UniCode字符集
Ansi字符型    AnsiChar      1          扩展ANSI字符集


字符串型数据
类型           类型说明符        最大长度
字符串型       String            2 31方个字符
短字符型       ShortString       255个字符
长字符串型     Ansisting         2 31方个字符
宽字符串型     WideSring         2 30方个字符

布尔形数据
类型           类型说明符    字节数    取值
布尔型         Boolean       1         只能为0（False）或1（True） 
长布尔型       LongBOOl      4         0（False）或非0（True）
宽布尔型       WideBool      2         0（False）或非0（True）
字节布尔型     ByteBool      1         0（False）或非0（True）

集合类型

//Array用于表示数组, 任何的对象都能被声明成数组.数组分为静态和动态的２种.
//静态数组
var
Arr1: array [1..10] of Integer;
 
//动态数组, 由于声明时不知其元素个数, 所以必须在后期用SetLength方法设置数组的大小
var
Arr2: array of Integer;
 
//数组作为参数时, 不能传入数组的大小, 只能传入数组名, 然后用Length方法获取数组的元素个数
function X(A: array of Integer): Integer;
var
i: Integer;
begin
Result := 0;
for i := 0 to Length(A)-1 do
Result := Result + A[i];
end;

//Set关键字用于声明集合类, 集合类允许用集合运算符, 如in等进行操作.
//集合的元素个数不超过256个
type
　TCol = (cA,cB,cC);
　TCols = set of TCol;
//操作时允许使用加减符号来添加或删除某个集合元素
var
　Cols: Tcols;
begin
　Cols := Cols + [cA,cB];
end;

其他关键字

//On关键字用于异常处理, 指出发生的异常, 并获取异常信息.
try
　i := StrToInt(s);
except
　on E: exception do
　　ShowMessage(E.Message);
end;

//With关键字用于将相同的对象集合起来处理, 它可以省去输入大量重复的代码, 使代码看上去比较精简.
with Form1.Memo1.Lines do
begin
　Clear;
　Append('abc');
　Append('def');
　SaveToFile('C:demo.txt');
end;
//上面这段代码如果不使用With语句, 则显得非常冗余复制内容到剪贴板代码:
Form1.Memo1.Lines.Clear;
Form1.Memo1.Lines.Append('abc');
Form1.Memo1.Lines.Append('def');
Form1.Memo1.Lines.SaveToFile('C:demo.txt');

//In用于判断一个集合中是否包含某个元素.被判断的内容必须是单个集合元素和一个集合的实例.
type
　TCol = (cA,cB,cC);
　TCols = set of TCol;
var
　Cols: TCols;
begin
　Cols := [cA,cB];
　if cA in Cols then
　　ShowMessage('cA in Cols')
　else
　　ShowMessage('cA not in Cols');
end;
//In也用于工程文件中, 用于标识某个文件是否被工程所引用.
Uses
　Unit1 in 'Unit1.pas';
 
//In可以被用在For语句中, 用于循环取出一个集合中的元素.
var
　s: string;
　sl: TStringList;
begin
　...
　for s In sl do
　begin
　　ShowMessage(s);
　end;
end;

//Of关键用于和其他关键字构成指定的结构.Of可以与Case, Class, Array, File, Set, Object连用.
//Case语句:
case Tag Of
　0: Result := 'a';
　1: Result := 'b';
end;
 
//Class语句:
type
　TDemo = class of TComponent;
 
//Array结构:
var
　MyInt: array of Integer;
 
//File结构:
var
　MyFile: file of Byte;
 
//Set语句:
type
　TCol = (cA,cB,cC);
　TCols = set of TCol;
 
//Object结构:
type
　MyFun = function(I: Integer): Integer of Object;