Cross Ref > OOP Basics

The Object class is Java's single base class all classes ultimately inherit from.

public class Cyborg {

}

public class Cyborg extends Object {

}

In Delphi programming language (Object Pascal), all classes ultimately inherit from the base class TObject.

//Specify both namespace and class:

TCyborg = class(System.TObject)
end;

//Use shortcut alias:

TCyborg = class(TObject)
end;

//None, default is System.TObject

TCyborg = class
end;

 Delphi Base Class (TObject)  

Unlike languages such as C++ and Object Pascal, every line of code written in Java must occur within a class.

//Declare class.

public class Cyborg {

  //Fields.

  private String cyborgName;

  private int age;

  //Constructor.

  public Person() {

  cyborgName = "unknown";

  age = 0;

  }

}

//Create object from class.

Cyborg p = new Cyborg();

p.getClass(); //From the Object base class.

Declare your class in the Interface section. Then implement the class in the Implementation section. To create an object instance, call the class constructor (usually named Create). Since Delphi does not have a garbage collector, you have to also free the object usually with either Free or FreeAndNil.

//Interface section:

TCyborg = class(TObject)
public
 procedure IntroduceYourself;
end;

//Implementation section;

procedure TCyborg.IntroduceYourself;
begin
 ShowMessage('Hi, I do not have a name yet.');
end;

//Some event like a button click:

var
  T1: TCyborg;
begin
  T1 := T1.Create;
  T1.IntroduceYourself;

  FreeAndNil(T1);      //Be sure to clean up!
end;

 Delphi Class..Object (class..end..Create)

Simple syntax example of class inheritance.

public class Android {

}

public class T-600 extends Android {

}

 Java Inheritance (extends ParentClass)

In Delphi, you use the class keyword followed by the parent class in parens. If you leave out the parent class, your class inherits from TObject.

TAndroid = class

end;

T-600 = class(TAndroid)

end;

 Delphi Inheritance (=class(ParentClass))  

In Delphi, member events are essentially properties of the type method pointer.

In Java, you can set the scope of a field member to public, protected, or private. Additional modifiers are static, abstract, final (assign only once), strictfp (strict floating point values) transient (do not save to persistent storage), and volatile (all threads see same value).

You can initialize member fields as in:

int age = 0;

In Delphi, it is common to start all member fields with "F" as in FName and FAge. You can initialize the value of member fields too.

Delphi member fields do not support static data. The workaround is to use the hybrid nature of Delphi and use a unit variable (a variable declared in the implementation section of a unit) and then access the unit variable with a member property.

Delphi doesn't support setting a member field to read-only. However, you can accomplish the task with a strict private member field and a read-only property.

TCyborg = class(TObject)
private
  FSerialNumber: String='A100';
public
  FCyborgName: String;
  FCyborgAge: Integer=0;
  FSeriesID: Integer=100;
end;

 Delphi Member Field

Delphi uses the keywords procedure and function. A procedure does not return a value and a function does.

//Interface section:

TCyborg = class(TObject)
public
  procedure IntroduceYourself;
end;

//Implementation section;

procedure TCyborg.IntroduceYourself;
begin
  ShowMessage('Hi, I do not have a name yet.');
end;

//Some event like a button click:

var
  T1: TCyborg;
begin
  T1 := T1.Create;
  T1.IntroduceYourself;
end;

Specify Delphi member modifiers as follows:

reintroduce; overload; [binding modifier]; [calling convention]; abstract; [warning]

The binding modifiers are virtual, dynamic, or override.

The calling conventions are register, pascal, cdecl, stdcall, or safecall.

The warnings are platform, deprecated, or library.

Additional directives include reintroduce, abstract, class, static, overload, and message.

TCyborg = class(TObject)

public

  procedure Speak(pMessage: String); virtual;

end;

 
TSeries888 = class(TCyborg)

public

  procedure Speak(pMessage: String); override;

end;

 Delphi Member Modifiers  

Delphi uses a special property keyword to both get and set the values of properties. The read and write keywords are used to get and set the value of the property directly or through an accessor method. For a read-only property, leave out the write portion of the declaration.

You can give properties any visibility you wish (private, protected, etc). It is common in Delphi to start member fields with "F" ("FName" in our example) and drop the "F" with properties that manage member fields ("Name" in our example).

TCyborg = class(TObject)
private
  FCName: String;
public
  property CyborgName: String read FCName write FCName;
end;

In Delphi, you group member declarations as part of defining the interface for a class in the Interface section of a unit.

Up until D2005, private and protected were not implemented strictly. Starting with D2005, a traditional strict versions of OOP are supported using the strict keyword. OO purist will want you to use strict private over private and strict protected over protected. I suggest you follow that advice until you both fully understand the differences and have a specific need.

Delphi offers a special published specifier which is the same as public members but runtime type information (RTTI) is generated.

TCyborg = class(System.Object)
private
  //Don't use accept when you really want private friendly members.
strict private
  //Use as your default private members.

  FName: String;
protected
  //Don't use accept when you really want protected friendly members.

strict protected
  //Use as your default protected members.

public

  

published

  //RTTI Info

end;

 Delphi Member Visibility  

 Ref: /ASPSuite/KB/Document_View.asp?QID=100889