unit Classes;

type
TCollection = class
TCollectionItem = class(TPersistent)
  private
    FCollection: TCollection;
    FID: Integer;
    function GetIndex: Integer;
    procedure SetCollection(Value: TCollection);
  protected
    procedure Changed(AllItems: Boolean);
    function GetOwner: TPersistent; override;
    function GetDisplayName: string; virtual;
    procedure SetIndex(Value: Integer); virtual;
    procedure SetDisplayName(const Value: string); virtual;
  public
    constructor Create(Collection: TCollection); virtual;
    destructor Destroy; override;
    function GetNamePath: string; override;
    property Collection: TCollection read FCollection write SetCollection;
    property ID: Integer read FID;
    property Index: Integer read GetIndex write SetIndex;
    property DisplayName: string read GetDisplayName write SetDisplayName;
  end;
 
TCollectionItemClass = class of TCollectionItem;

TCollection = class(TPersistent)
  private
    FItemClass: TCollectionItemClass;
    FItems: TList;
    FUpdateCount: Integer;
    FNextID: Integer;
    FPropName: string;
    function GetCount: Integer;
    function GetPropName: string;   
    procedure InsertItem(Item: TCollectionItem);
    procedure RemoveItem(Item: TCollectionItem);
  protected
    property NextID: Integer read FNextID;
    { Design-time editor support }
    function GetAttrCount: Integer; dynamic;
    function GetAttr(Index: Integer): string; dynamic;
    function GetItemAttr(Index, ItemIndex: Integer): string; dynamic;
    procedure Changed;
    function GetItem(Index: Integer): TCollectionItem;
    procedure SetItem(Index: Integer; Value: TCollectionItem);
    procedure SetItemName(Item: TCollectionItem); virtual;
    procedure Update(Item: TCollectionItem); virtual;
    property PropName: string read GetPropName write FPropName;
    property UpdateCount: Integer read FUpdateCount;
  public
    constructor Create(ItemClass: TCollectionItemClass);
    destructor Destroy; override;
    function Add: TCollectionItem;
    procedure Assign(Source: TPersistent); override;
    procedure BeginUpdate; virtual;
    procedure Clear;
    procedure Delete(Index: Integer);
    procedure EndUpdate; virtual;
    function FindItemID(ID: Integer): TCollectionItem;
    function GetNamePath: string; override;
    function Insert(Index: Integer): TCollectionItem;
    property Count: Integer read GetCount;
    property ItemClass: TCollectionItemClass read FItemClass;
    property Items[Index: Integer]: TCollectionItem read GetItem write SetItem;
  end;

unit ComCtrls;

type
TStatusPanel = class(TCollectionItem)
  private
    FText: string;
    FWidth: Integer;
    FAlignment: TAlignment;
    FBevel: TStatusPanelBevel;
    FBiDiMode: TBiDiMode;
    FParentBiDiMode: Boolean;
    FStyle: TStatusPanelStyle;
    FUpdateNeeded: Boolean;
    procedure SetAlignment(Value: TAlignment);
    procedure SetBevel(Value: TStatusPanelBevel);
    procedure SetBiDiMode(Value: TBiDiMode);
    procedure SetParentBiDiMode(Value: Boolean);
    procedure SetStyle(Value: TStatusPanelStyle);
    procedure SetText(const Value: string);
    procedure SetWidth(Value: Integer);
    function IsBiDiModeStored: Boolean;
  protected
    function GetDisplayName: string; override;
  public
    constructor Create(Collection: TCollection); override;
    procedure Assign(Source: TPersistent); override;
    procedure ParentBiDiModeChanged;
    function UseRightToLeftAlignment: Boolean;
    function UseRightToLeftReading: Boolean;
  published
    property Alignment: TAlignment read FAlignment write SetAlignment default taLeftJustify;
    property Bevel: TStatusPanelBevel read FBevel write SetBevel default pbLowered;
    property BiDiMode: TBiDiMode read FBiDiMode write SetBiDiMode stored IsBiDiModeStored;
    property ParentBiDiMode: Boolean read FParentBiDiMode write SetParentBiDiMode default True;
    property Style: TStatusPanelStyle read FStyle write SetStyle default psText;
    property Text: string read FText write SetText;
    property Width: Integer read FWidth write SetWidth;
  end;

type
  TExample1 = class
    Field1 : integer;  // Public
  public
    .....
  end;

{$M+}
  TExample2 = class
    Field2 : integer;  // Published
  public
    ....
  end;
{$M-}

  TExample3 = class
    Field3 : integer;   // Public
  public
    ....
  end;

program Salary;

{$APPTYPE CONSOLE}

uses
  SysUtils;

type
  TSalary = class
  public
    Amount : integer;
    constructor Create;
    constructor CreateWithAmount(AAmount : integer);
  end;

constructor TSalary.Create;
begin
  inherited Create;
  // ±âº»ÀûÀ¸·Î ¸ðµç º¯¼ö´Â 0À¸·Î ÃʱâÈ­ µÇ±â ¶§¹®¿¡ ÀÌ ·çƾÀº ±»ÀÌ ½á ÁÖÁö ¾Ê¾Æµµ µÈ´Ù.
  Amount := 0;
end;

constructor TSalary.CreateWithAmount(AAmount : integer);
begin
  inherited Create;
  Amount := AAmount;
end;

var
  Temp1, Temp2 : TSalary;
  TempStr : string;
begin
  Temp1 := TSalary.Create;
  Temp2 := TSalary.CreateWithAmount(1000000);
  try
    writeln('Temp1ÀÇ ±Þ¿©´Â ', IntToStr(Temp1.Amount));
    writeln('Temp2ÀÇ ±Þ¿©´Â ', IntToStr(Temp2.Amount));
  finally
    Temp1.Free;
    Temp2.Free;
  end;
  WriteLn('Á¾·áÇÏ·Á¸é ENTER Å°¸¦ ´©¸£¼¼¿ä!!');
  ReadLn(TempStr);
end. 

program VMethods;

{$APPTYPE CONSOLE}

uses
  classes;

type

  TParent = class
    procedure VirtualProc; virtual;
    procedure DynamicProc; dynamic;
    procedure BrokenProc; virtual;
  end;

  TDescendant = class(TParent)
    procedure VirtualProc; override;
    procedure DynamicProc; override;
    procedure BrokenProc; virtual;
  end;

  procedure TParent.VirtualProc;
  begin
    writeln('TParent.VirtualProc');
  end;

  procedure TParent.DynamicProc;
  begin
    writeln('TParent.DynamicProc');
  end;

  procedure TParent.BrokenProc;
  begin
    writeln('TParent.BrokenProc');
  end;

  procedure TDescendant.VirtualProc;
  begin
    inherited VirtualProc;
    writeln('TDescendant.VirtualProc');
  end;

  procedure TDescendant.DynamicProc;
  begin
    inherited DynamicProc;
    writeln('TDescendant.DynamicProc');
  end;

  procedure TDescendant.BrokenProc;
  begin
    inherited BrokenProc;
    writeln('TDescendant.BrokenProc');
  end;

  procedure TestVirtProc(Obj : TParent);
  begin
    Obj.VirtualProc;
  end;

  procedure TestDynProc(Obj : TParent);
  begin
    Obj.DynamicProc;
  end;

  procedure TestBrokenProc(Obj : TParent);
  begin
    Obj.BrokenProc;
  end;
var
  TempObj : TDescendant;
  TempStr : string;
begin
  TempObj := TDescendant.Create;
  try
    writeln('Virtual ¸Þ¼Òµå');
    TestVirtProc(TempObj);
    writeln('Dynamic ¸Þ¼Òµå');
    TestDynProc(TempObj);
    writeln('¸Þ¼Òµå ¿¬°áÀÌ ²÷¾îÁø´Ù');
    TestBrokenProc(TempObj);
  finally
    TempObj.Free;
  end;
  WriteLn('Á¾·áÇÏ·Á¸é ENTER Å°¸¦ ´©¸£¼¼¿ä!!');
  ReadLn(TempStr);
end.

unit fRefExam;

interface

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  ExtCtrls, StdCtrls;

type
  TfrmRefExam = class(TForm)
    rdoButton: TRadioButton;
    rdoEdit: TRadioButton;
    rdoCheckBox: TRadioButton;
    btnCreate: TButton;
    Bevel1: TBevel;
    panMsg: TPanel;
    procedure btnCreateClick(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;

var
  frmRefExam: TfrmRefExam;

implementation

{$R *.DFM}

// TControlClass = class of TControl
// TControlClass´Â Controls.pas¿¡ À§¿Í °°ÀÌ Á¤ÀǵǾî ÀÖ´Ù.

procedure TfrmRefExam.btnCreateClick(Sender: TObject);
var
  Reference : TControlClass;
  Instance : TControl;
begin
  if rdoButton.Checked then
    Reference := TControlClass(TButton)
  else if rdoEdit.Checked then
    Reference := TControlClass(TEdit)
  else
    Reference := TControlClass(TCheckBox);

  Instance := Reference.Create(Self);
  Instance.Parent := Self;
  Instance.Left := 8;
  Instance.Top := 88;
  panMsg.Caption := Instance.ClassName + ' »ý¼º';
end;

end.

program ClsMethod;
{$APPTYPE CONSOLE}
uses
  SysUtils;

type
  TExample = class
    class function GetClassName : string;
  end;

  class function TExample.GetClassName : string;
  begin
    Result := 'Ŭ·¡½º ¸Þ¼Òµå ¿¹Á¦ Ŭ·¡½º';
  end;
var
  TmpObj : TExample;
  TmpStr : string;
begin
  // Insert user code here
  WriteLn('Á÷Á¢ È£Ãâ -> ', TExample.GetClassName);
  TmpObj := TExample.Create;
  try
    WriteLn('°´Ã¼ »ý¼º ÈÄ È£Ãâ -> ', TmpObj.GetClassName);
  finally
    TmpObj.Free;
  end;
  WriteLn('Á¾·áÇÏ·Á¸é ENTER Å°¸¦ ´©¸£¼¼¿ä!!');
  ReadLn(TmpStr);
end.