type
  TVehicle = class(TComponent)
  private
    FWidth : integer;
    FHeight : integer;
    FLength : integer;

    procedure SetWidth(const Value : integer);
    function  GetHeight : integer;
    procedure SetHeight(const Value : integer);

    function  GetVolume : integer;
  public
    constructor Create(AOwner : TComponent); override;

    property Width : integer read FWidth write SetWidth default 1700;
    property Height : integer read GetHeight write SetHeight default 4500;
    property Length : integer read FLength write FLength default 1800;
    property Volume : integer read GetVolume;
  end;

TCar = class(TVehicle)
private
    FVolume : integer;
function  GetVolume : integer;
procedure SetVolume(const Value : integer);
  published
    property Width : integer ;
    property Height : integer nodefault;
    property Length : integer;
    property Volume : integer read GetVolume write SetVolume;
  end;

...

implementation

...

constructor TVehicle.Create(AOwner : TComponent);
begin
  inherited Create(AOwner);
  FWidth := 1700;
  FHeight := 4500;
  FLength := 1800;
end;

function TVehicle.GetHeight: integer;
begin
  Result := FHeight;
end;

function TVehicle.GetVolume: integer;
begin
  Result := FWidth * FHeight * FLength;
end;

procedure TVehicle.SetHeight(const Value: integer);
begin
  if FHeight <> Value then
  begin
    FHeight := Value;
    Update;
  end;
end;

procedure TVehicle.SetWidth(const Value: integer);
begin
  if FWidth <> Value then
  begin
    if FWidth < 3000 then
    begin
      FWidth := Value;
      Update;
    end;
  end;
end;

function TCar.GetVolume: integer;
begin
  Result := inherited Volume;
Result := Result + 1;
end;

procedure TCar.SetVolume(const Value: integer);
begin
inherited Volumen := Value;
end;

unit Classes.pas

  { »ý·« }
  
  { TStrings class }

  TStrings = class(TPersistent)
  private
    { »ý·« }
    function GetValue(const Name: string): string;
    procedure SetValue(const Name, Value: string);
  protected
    { »ý·« }
    function Get(Index: Integer): string; virtual; abstract;
    function GetObject(Index: Integer): TObject; virtual;
    procedure Put(Index: Integer; const S: string); virtual;
    procedure PutObject(Index: Integer; AObject: TObject); virtual;
  public
    { »ý·« }
    property Objects[Index: Integer]: TObject read GetObject write PutObject;
    property Values[const Name: string]: string read GetValue write SetValue;
    property Strings[Index: Integer]: string read Get write Put; default;
  end;

{ »ý·« }

{ TStringList class }

  TStringList = class(TStrings)
  private
    { »ý·« }
  protected
    { »ý·« }
    function Get(Index: Integer): string; override;
    function GetObject(Index: Integer): TObject; override;
    procedure Put(Index: Integer; const S: string); override;
    procedure PutObject(Index: Integer; AObject: TObject); override;
  public
    { »ý·« }
  end;
  
{ »ý·« }

implementation

{ »ý·« }

{ TStrings }

function TStrings.GetObject(Index: Integer): TObject;
begin
  Result := nil;
end;

function TStrings.GetValue(const Name: string): string;
var
  I: Integer;
begin
  I := IndexOfName(Name);
  if I >= 0 then
    Result := Copy(Get(I), Length(Name) + 2, MaxInt) else
    Result := '';
end;
procedure TStrings.Put(Index: Integer; const S: string);
var
  TempObject: TObject;
begin
  TempObject := GetObject(Index);
  Delete(Index);
  InsertObject(Index, S, TempObject);
end;

procedure TStrings.PutObject(Index: Integer; AObject: TObject);
begin
end;

procedure TStrings.SetValue(const Name, Value: string);
var
  I: Integer;
begin
  I := IndexOfName(Name);
  if Value <> '' then
  begin
    if I < 0 then I := Add('');
    Put(I, Name + '=' + Value);
  end else
  begin
    if I >= 0 then Delete(I);
  end;
end;

{ TStringList }

function TStringList.Get(Index: Integer): string;
begin
  if (Index < 0) or (Index >= FCount) then Error(@SListIndexError, Index);
  Result := FList^[Index].FString;
end;

function TStringList.GetObject(Index: Integer): TObject;
begin
  if (Index < 0) or (Index >= FCount) then Error(@SListIndexError, Index);
  Result := FList^[Index].FObject;
end;

procedure TStringList.Put(Index: Integer; const S: string);
begin
  if Sorted then Error(@SSortedListError, 0);
  if (Index < 0) or (Index >= FCount) then Error(@SListIndexError, Index);
  Changing;
  FList^[Index].FString := S;
  Changed;
end;

procedure TStringList.PutObject(Index: Integer; AObject: TObject);
begin
  if (Index < 0) or (Index >= FCount) then Error(@SListIndexError, Index);
  Changing;
  FList^[Index].FObject := AObject;
  Changed;
end;

type
  TMatrix = class
  private
    { »ý·« }
    function GetEntry(ACol, ARow : Integer) :Real;
    procedure SetEntry(ACol, ARow : Integer, Value : Real);
  public
    property Entry[ACol, ARow : Integer] : Real 
      read GetEntry 
      write SetEntry
  end;

type
  TVehicle = class(TComponent)
  private
    FDimensions : Array[1..3] of integer;

    function  GetDimension(Index : integer) : Integer;
    procedure SetDimension(Index : Integer; const Value : integer);

  public
    constructor Create(AOwner : TComponent); override;

    property Width : integer index 1 read GetDimension write SetDimension;
    property Height : integer index 2 read GetDimension write SetDimension;
    property Length : integer index 3 read GetDimension write SetDimension;
  end;

implementation

function TVehicle.GetDimension(Index : Integer) : Integer;
begin
  Result := FDimensions[Index];
end;

procedure TVehicle.SetDimension(Index : Integer; const Value : Integer);
begin
  if FDimensions[Index] <> Value then
FDimensions[Index] := Value;
end;

unit Controls.pas
...
property ClientHeight: Integer read GetClientHeight write SetClientHeight stored False;
property Color: TColor read FColor write SetColor stored IsColorStored default clWindow;
...
function TControl.IsColorStored: Boolean;
begin
  Result := not ParentColor;
end;