Difference between revisions of "extended class syntax"

From Lazarus wiki
Jump to navigationJump to search
m (Text replace - "delphi>" to "syntaxhighlight>")
Line 1: Line 1:
 
=== static fields, static properties, regular fields and regular properties: ===
 
=== static fields, static properties, regular fields and regular properties: ===
<delphi>
+
<syntaxhighlight>
 
type
 
type
 
   TSomeClass = class
 
   TSomeClass = class
Line 29: Line 29:
 
   WriteLn(SomeClass.SomeProperty);
 
   WriteLn(SomeClass.SomeProperty);
 
end.
 
end.
</delphi>
+
</syntaxhighlight>
  
 
=== class constants: ===
 
=== class constants: ===
  
<delphi>
+
<syntaxhighlight>
 
type
 
type
 
   TSomeClass = class
 
   TSomeClass = class
Line 60: Line 60:
 
begin
 
begin
 
end.
 
end.
</delphi>
+
</syntaxhighlight>
  
 
=== nested classes: ===
 
=== nested classes: ===
  
<delphi>
+
<syntaxhighlight>
 
type
 
type
 
   TSomeClass = class
 
   TSomeClass = class
Line 123: Line 123:
 
   TDescendant.Test;
 
   TDescendant.Test;
 
end.
 
end.
</delphi>
+
</syntaxhighlight>

Revision as of 15:16, 24 March 2012

static fields, static properties, regular fields and regular properties:

type
  TSomeClass = class
  private
    type
      TSomeType = type integer;    // an internal type
    class var
      FSomeClassVar: TSomeType;    // class variable belongs to a class, not an instance
    var
      FSomeIntanceVar: TSomeType;  // instance variable belongs to instance. it is a usual field
    class procedure SetSomeClassVar(const AValue: TSomeType); static;
  public
    class property SomeProperty: TSomeType read FSomeClassVar write SetSomeClassVar; // class property - belongs to a class
    property SomeInstanceProp: TSomeType read FSomeIntanceVar;
  end;

{ TSomeClass }

class procedure TSomeClass.SetSomeClassVar(const AValue: TSomeType);
begin
   FSomeClassVar := AValue;
end;

var
  SomeClass: TSomeClass;
begin
  SomeClass.SomeProperty := 1;
  WriteLn(SomeClass.SomeProperty);
end.

class constants:

type
  TSomeClass = class
  strict private
    const
      PrivateConst = 1;
    type
      PrivateType = type Integer;
    var
      FPrivateField: PrivateType;
  public
    procedure DoSomething(Value: PrivateType = PrivateConst);
    function ReturnSomething: PrivateType;
    property SomeProp: PrivateType read FPrivateField write FPrivateField default PrivateConst;
  end;

  procedure TSomeClass.DoSomething(Value: PrivateType = PrivateConst);
  begin
  end;

  function TSomeClass.ReturnSomething: PrivateType;
  begin
    Result := PrivateConst;
  end;

begin
end.

nested classes:

type
  TSomeClass = class
  strict private
    type
      TPrivateNestedClass = class
      public
        procedure DoSomething;
      end;
  public
    type
      TNestedClass = class
      public
        procedure DoSomething;
      end;
    class procedure Test; virtual;
  end;

  TDescendant = class(TSomeClass)
  public
    class procedure Test; override;
  end;

procedure TSomeClass.TPrivateNestedClass.DoSomething;
begin
  WriteLn('TSomeClass.TPrivateNestedClass.DoSomething: ok');
end;

procedure TSomeClass.TNestedClass.DoSomething;
begin
  WriteLn('TSomeClass.TNestedClass.DoSomething: ok');
end;

class procedure TSomeClass.Test;
var
  P: TPrivateNestedClass;
  N: TNestedClass;
begin
  P := TPrivateNestedClass.Create;
  P.DoSomething;
  P.Free;
  N := TNestedClass.Create;
  N.DoSomething;
  N.Free;
end;

class procedure TDescendant.Test;
var
  N: TNestedClass;
begin
  N := TNestedClass.Create;
  N.DoSomething;
  N.Free;
end;

begin
  TSomeClass.Test;
  TDescendant.Test;
end.