Delphi
XE中类成员的访问权限 转老帅博客
共提供了6个关键词来用于限定访问权限：
public、private、protected、published、automated strict private
、 strict protected
其各自的含义为：
1. strict private：
此区定义的字段或方法只能用于当前的类中。即T1中此区定义的成员只能在T1中使用。
2. strict protected：
此区定义的成员除能用于当前类中，还可用于当前类的任何子类中。
以上两种成员，同一个类的不同对象间也不能互访问。
3. private：
所限定的成员只能用于定义这个类的.pas文件或.dpr文件。
4. protected：
相当于将private扩展到任意子类均可见。
5. public：
对任何位置、任何类均可见。当某些成员未显式指定其访问权限时，Delphi默认为此public。
6. published：
访问权限与public相同。
7. automated：
用于Win32下的COM编程。
注意：strict private与strict
protected从Delphi2007开始引入，之前的版本不存在这两种等级
在 published published published 区声明属性时应注意以下两点：
- published published 属性的值只能是：有序类型、字符串接口变体方法指针以及上下界在 0到 31
之间的集合类型。实数不能是 Real48 类型。
- 不能以同一个名字公布两个或更多的重载方法。
Delphi7之后Delphi的一些新特性
Abstract: See many of the major new language features in Delphi
released after the Delphi 7 version
Language and Compiler
Features Since Delphi 7
|
| Inlining |
Routines can now be marked with
the inline directive.
This tells the compiler that, instead of actually calling the
routine, it should emit code that includes the routine at the call
site. |
| Operator Overloading |
Delphi allows certain functions, or operators, to be overloaded
within record declarations
TMyClass =
class
class operator Add(a, b: TMyClass): TMyClass; // Addition of two operands of type TMyClass
class operator Subtract(a, b: TMyClass): TMyclass; // Subtraction of type TMyClass
class operator Implicit(a: Integer): TMyClass; // Implicit conversion of an Integer to type TMyClass
class operator Implicit(a: TMyClass): Integer; // Implicit conversion of TMyClass to Integer
class operator Explicit(a: Double): TMyClass; // Explicit conversion of a Double to TMyClass
end;
// Example implementation of Add class operator
TMyClass.Add(a, b: TMyClass): TMyClass;
begin
...
end;
var
x, y: TMyClassbegin
x := 12; // Implicit conversion from an Integer
y := x + x; // Calls TMyClass.Add(a, b: TMyClass): TMyClass
b := b + 100; // Calls TMyClass.Add(b, TMyClass.Implicit(100))
end;
|
| Class Helpers |
A class helper is a type that - when associated with another
class - introduces additional method names and properties which may
be used in the context of the associated class (or its
descendants). Class helpers are a way to extend a class without
using inheritance. A class helper simply introduces a wider scope
for the compiler to use when resolving identifiers. When you
declare a class helper, you state the helper name, and the name of
the class you are going to extend with the helper. You can use the
class helper any place where you can legally use the extended
class. The compiler's resolution scope then becomes the original
class, plus the class helper. Class helpers provide a way to extend
a class, but they should not be viewed as a design tool to be used
when developing new code. They should be used solely for their
intended purpose, which is language and platform RTL binding.
type
TMyClass = class
procedure MyProc;
function MyFunc: Integer;
end;
...
procedure TMyClass.MyProc;
var
X: Integer;
begin
X := MyFunc;
end;
function TMyClass.MyFunc: Integer;
begin
...
end;
...
type
TMyClassHelper = class helper for TMyClass
procedure HelloWorld;
function MyFunc: Integer;
end;
...
procedure TMyClassHelper.HelloWorld;
begin
WriteLn(Self.ClassName); // Self refers to TMyClass type, not TMyClassHelper
end;
function TMyClassHelper.MyFunc: Integer;
begin
...
end;
...
var
X: TMyClass;
begin
X := TMyClass.Create;
X.MyProc; // Calls TMyClass.MyProc
X.HelloWorld; // Calls TMyClassHelper.HelloWorld
X.MyFunc; // Calls TMyClassHelper.MyFunc
end;
|
| strict private |
The private keyword
actually creates a " friendship" relationship between classes in
the same unit. The strict
private declaration creates a true private
field, not viewable by any other class, not even classes in the
same unit. |
| strict protected |
Similar to the strict
private declaration, strict
protectedcreates a true protected member, visible only to
the declaring class and its descendents. |
| Records with Methods |
In addition to fields, records now may have properties and
methods (including constructors), class properties, class methods,
class fields, and nested types.
type
TMyRecord = record
type
TInnerColorType = Integer;
var
Red: Integer;
class var
Blue: Integer;
procedure printRed();
constructor Create(val: Integer);
property RedProperty: TInnerColorType read Red write Red;
class property BlueProp: TInnerColorType read Blue write Blue;
end;
constructor TMyRecord.Create(val: Integer);
begin
Red := val;
end;
procedure TMyRecord.printRed;
begin
writeln('Red: ', Red);
end;
|
| class abstract |
Classes, and not just methods, can be declared as abstract.
type
TAbstractClass = class abstract
procedure SomeProcedure;
end;
|
| class sealed |
Classes marked as sealed cannot be inherited from.
type
TAbstractClass = class sealed
procedure SomeProcedure;
end;
|
| class const |
Classes can now have class constants -- a constant value
associated with the class itself and not an instance of the class.
type
TClassWithConstant = class
public
const SomeConst = 'This is a class constant';
end;
procedure TForm1.FormCreate(Sender: TObject);
begin
ShowMessage(TClassWithConstant.SomeConst);
end;
|
| class type |
A class can now contain a type declaration that is usable only
within that class.
type
TClassWithClassType = class
private
type
TRecordWithinAClass = record
SomeField: string;
end;
public
class var
RecordWithinAClass: TRecordWithinAClass;
end;
...
procedure TForm1.FormCreate(Sender: TObject);
begin
TClassWithClassType.RecordWithinAClass.SomeField := 'This is a field of a class type declaration';
ShowMessage(TClassWithClassType.RecordWithinAClass.SomeField);
end;
|
| class var |
A class can also have a class variable, applicable only to the
class and not an instance of the class. See "class type" for an
example. |
| class property |
A class can have a
class property, which is a property that applies only to the class
reference and not to an instance of a
class. The accessors for the
class property must be either class methods or class
variables. See the example in "static class
methods" below. |
| nested classes |
Type declarations can be nested within class declarations. They
present a way to keep conceptually related types together, and to
avoid name collisions.
type
TOuterClass = class
strict private
MyField: Integer;
public
type
TInnerClass = class
public
MyInnerField: Integer;
procedure InnerProc;
end;
procedure OuterProc;
end;
procedure TOuterClass.TInnerClass.InnerProc;
begin
...
end;
|
| final methods |
A virtual method that you override can now be marked final,
preventing derived classes from overriding that method.
TAbstractClass = classabstract
public
procedure Bar; virtual;
end;
TSealedClass = classsealed(TAbstractClass)
public
procedure Bar; override;
end;
TFinalMethodClass = class(TAbstractClass)
public
procedure Bar; override; final;
end;
|
| sealed methods |
Classes marked
as sealed cannot be
descended from. See the example in 'final methods'. |
| static class methods |
Classes can have static class methods -- i.e. methods that can
be called from a class type. Class static methods can be accessed
without an object reference. Unlike ordinary class methods, class
static methods have
no Self parameter at
all. They also cannot access any instance members. (They still have
access to class fields, class properties, and class methods.) Also
unlike class methods, class static methods cannot be declared
virtual.
type
TMyClass = class
strict private
class var
FX: Integer;
strict protected
// Note: accessors for class properties must be declared class static.
class function GetX: Integer; static;
class procedure SetX(val: Integer); static;
public
class property X: Integer read GetX write SetX;
class procedure StatProc(s: String); static;
end;
TMyClass.X := 17;
TMyClass.StatProc('Hello');
|
| for-in loop |
Delphi 2007 for Win32 supports
for-element-in-collection style
iteration over containers. The following container iteration
patterns are recognized by the compiler:
for Element in ArrayExpr do Stmt;
for Element in StringExpr do Stmt;
for Element in SetExpr do Stmt;
for Element in CollectionExpr do Stmt;
|
