Java and Delphi Cross Reference Guide

Java applets and applications both require the Java Runtime Environment (JRE) and any additional dependencies you've added.

Delphi creates native code Windows applications so you can create an EXE with no dependencies that will run on any Windows computer. If you add dependencies (reports, database libraries, DLLs, etc.) use a Windows installer to build an installation program.

D2007 and D2009 are bundled with InstallAware Express CodeGear Edition installer.

Many compilers and development tools are available. Common development tools include Sun's J2EE, CodeGear JBuilder, and Eclipse.

CodeGear Delphi is the primary tool of choice for most developers but other Object Pascal language development tools do exist and some are quite good.

The customary primary source file extension for Java code is ".java" which could contain anywhere from a single class to the entire source code.

Other important files:

• .JAR - Java archive file (compressed code file). Archive that contains multiple Java files and is compressed using .ZIP compression; stores Java classes and metadata and may be digitally signed; runs as a program if the Java Runtime Environment (JRE) is installed on the computer.
• .CLASS - compiled source code which are platform-independent. If a source file has more than one class, each class is compiled into a separate .class file. These .class files can be loaded by any Java Virtual Machine (JVM).

 Java File Extensions (.java)

Common source code file extensions include:

• .BDSPROJ - Project, Borland Developer Studio project file holds compiler options, etc. This is the file you open.
• .DCU - Delphi Compiled Unit file.
• .DFM - Delphi Win32 form file (a text resource file).
• .DPR - Delphi project file. Primary project "source" file.
• .PAS - Delphi unit source file.

Note: Delphi 2009 changed the project file to acommadatte new features. When you open a project file from a previous version, it will be upgraded. In addition to .bdsproj, D2009 also uses a .dproj project file.

 Delphi File Extensions

 Ref: http://delphi.wikia.com/wiki/Delphi_File_Extensions

Promoted as a single source cross-platform runtime system (Write Once, Run Anywhere). Java builds on and in some ways simplifies the object oriented features of C++. Java applications are typically compiled to byte-code and can run on any platform running the Java Virtual Machine (JVM).

Target Platforms: Java is suitable for creating many types of cross-platform applications that target the JVM including desktop business applications as well as Java applets which target all the major web browsers.

Language Overview: Delphi programming language is a type-safe language consisting of hybrid traditional Pascal and OOP features. You code either in a traditional approach using functions, procedures, and global data, or you code using an OOP approach, or a mixture of both.

Target Platforms: Delphi for Win32 is most suitable for creating native code Win32 applications that run on Microsoft Windows.

Both Eclipse 3.3 and JBuilder 2008 come bundled with Business Intelligence and Reporting Tools (BIRT). BIRT is an Eclipse-based open source reporting system with both a report designer based on Eclipse, and a runtime component that you can add to your app server plus a charting engine that lets you add charts.

Rave Reports comes closest to a Delphi standard now but historically there has been no real standard in Delphi development. Do-it-yourself developers sometimes like to use TPrinter for very simple reports. ReportSmith was bundled with the first few versions of Delphi.

Delphi has offered many embedded VCL component report options. Quick Reports has been a part of Delphi since Delphi 2.0 and has been the default report writer for many Delphi developers. Ace Reporter, ReportBuilder and Rave Reports are also very popular. During the time of Kylix, FastReports was popular because of it's cross-platform nature.

Crystal Reports is very common because of it's overall popularity as a stand-alone report writer that integrates well with many different tools.

 Delphi Report Tools Overview

Java is case sensitive.

Customary casing:

• Classes - Initial Caps (Pascal Casing)
• Variables - Initial lowecase (Camel case)
• Methods - Initial lowecase (Camel case)

 Camel versus Pascal Casing

Object Pascal is generally not case sensitive.

Syntax Example:   Variables and commands are not case sensitive. var FullName: String; begin fullname := 'Mike Prestwood'; ShowMessage(fullNAME); SHOWMESSAGE(FULLNAME); showmessage(fullname); end;

 Camel versus Pascal Casing

Curly braces are used to bracket code blocks including classes and the methods within a class.

For Java, JavaScript, PHP, and C++, I prefer to put the first { at the end of the first line of the code block as in the example above because I see moreJava codeformatted that way.

public class Dog {

  public bark() {

    System.out.println("Ruff");

  }

}

Object Pascal requires the semi-colon after the "declaration" part.

function DoSomething : integer;

var

  a, b : integer

begin

  a := 1;

  b := 2;

  result := a + b;

end;

Commenting Code
Java uses "//" for a single line comment and /* */ for a multiple line comment.

//Single line comment in MS (not ANSI compliant so do NOT use).
/* ANSI compliant single line comment. */
/*
Multiple line
comment.

*/

/*

* This is another popular way 

* to write multi-line comments.

*/

Commenting Code
Delphi uses // for a single line comment and both {} and (**) for multiple line comments. Although you can nest different types of multiple line comments, it is recommended that you don't.

Compiler Directives - $
A special comment. Delphi compiler directives are in the form of {$DIRECTIVE}. Of interest for comments is using the $IFDEF compiler directive to remark out code.

//This is a single line comment.

 
{

Multiple line

comment.

}

 
(*
This too is a
multiple line comment.
*)

 
{$IFDEF TEMPOUT}
  //...code here
{$ENDIF}

 Delphi Comments (// or { ... } or (* ... *))  

In Delphi, you define constants similar to how you define variables but use the Const keyword instead of the Var keyword. Declare global constants in a unit's interface section and unit constants (scope limited to unit) in the implementation section. Declare local constants above the begin..end block.

Const 

  kFeetToMeter: Double = 3.2808;

  kMeterToFeet: Double = .3048;

  kName: String = "Mike";

//Local constants:

procedure SomeProcedure;

const

  kPI: Double=3.1459;

begin

end;

 Delphi Constants (Const kPI: Double=3.1459;)  

Object Pascal uses a semicolon ";" as an end of statement specifier and you can put multiple statements on a single line of code and put a single statement on two or more code lines if you wish.

Syntax Example:   WriteLn('Hello1'); WriteLn('Hello2'); WriteLn('Hello3'); //Same line works too: WriteLn('Hello4'); WriteLn('Hello5'); //Two or more lines works too: WriteLn ('Hello6');

String literals are quoted as in "Prestwood". If you need to embed a quote use a slash in front of the quote as in \".

To specify a floating point literal between 1 and -1, you can preceed the decimal with a 0 or not (both work). In other words, preceding and following decimals are allowed (both 1. and 1.0 work as well as .1 and 0.1). In general, Java follows the IEEE 754 Binary Floating-Point Arithmetic standard.

System.out.println("Hello");

System.out.println("Hello \"Mike\".");

//Does Java evaluate this simple

//floating point math correctly? No!

if ((.1 + .1 + .1) == 0.3) {
  System.out.println("Correct");
} else {
  System.out.println("Not correct");
}

 Ref: http://www.ibm.com/developerworks/java/library/j-jtp0114/

String literals are single quoted (the apostrophe) as in 'Prestwood'. If you need to embed an apostrophe use two apostrophes in a row.

Floating point literals must start with an integer. For example, to specify a fractional floating point literal between 1 and -1, you preceed the decimal with a 0; otherwise, you will get a compiler error.

//x := .1 + .1;   //Does not work.

x := 0.1 + 0.1;   //Does work.

Syntax Example:   ShowMessage('Hello'); ShowMessage('Hello Mike''s website.');

 Ref: https://forums.codegear.com/thread.jspa?threadID=8909&tstart=60

Variable names are case sensitive.

The Java basic types are boolean, byte, short, int, long, float, double, and char. You can also declare a variable to hold a particular instance of a class such as String.

int a;

int a, b;

int age = 43;

String FullName;

The Delphi language is a strongly typed language so you have to specifically declare variables and frequently use commands such as IntToStr and StrToInt.

Declare global variables in the interface section of a unit, variables declared within the implementation section (but not within a method) have a scope limited to the unit. You declare local variables in a var block outside (above) your begin..end code block. You cannot declare variables in-line (inside begin..end).

You can initialize global and unit variables but you cannot initialize local variables.

Delphi offers many variable types. Some common variable types include String, WideString, PChar, Integer, Boolean, Single, Double, Pointer, and Variant.

Note: D2009 introduced a new UnicodeString type.

procedure SomeProcedure;

var
  Fullname: String;
  Age: Integer;

  X, Y, Z: Double;

  MyArray: array [1..100] of Char;

begin

end;

//You can initialize global variables.

var

  ClickCounter: Integer = 0;

 Delphi Variables (var x: Integer = 0;)  

Because java is an OOP language, all custom routines belong to a specific class and are therefore referred to as methods.

All methods in Java must return something so even with procedures, you return a "void".

public void sayHello(String pName) {
  System.out.println("Hello" + pName);
}

 

public int add(int p1, int p2) {

  return p1 + p2;

}

Delphi is a hybrid language so you can create either class methods (functions and procedures) or you can create global functions and procedures. When a function or procedure is part of a class, it is a class method.

[function/procedure] RoutineName : ReturnType;

As with C++, your custom routine must come before it's first usage or you have to prototype it in the Interface section.

Note: Contrast Delphi with Delphi Prism which is an OOP language (everything is within a class). Both Delphi and Delphi Prism are based on Object Pascal but implement OOP features differently and have some syntax differences too.

procedure SayHello(pName: String);
begin
  ShowMessage('Hello ' + pName);
end;

function Add(p1, p2 : Double): Double;
begin
  Result := p1 + p2;
end;

 Delphi Custom Routines (procedure, function)

Many objects in Delphi have events you can use to trigger code. For example, when you add a form to your project you have access to the form events such as onCreate, onShow, onHide, onDockDrop, etc. In addition, Delphi offers module level events initialization and finalization sections.

You cannot embed assembly in a java program but you can get system information via jni.

In Delphi, you can inline assembler code using the asm keyword.

The Java compiler automatically inlines when it determines  a benefit. The use of final methods is considered a compiler hint to tell the compiler to inline the method if beneficial.

Delphi introduced developer defined function and procedure inlining with Delphi 2005. Use the inline keyword to tell the compiler to try to inline a routine (a compiler hint). Since Delphi will only try to inline the routine, make sure you test for speed because inlining a routine can lead to slower code under some circumstances.

Syntax Example:   function Add(a, b: Integer): Integer; inline; begin end;

Java Overloading

• Operator - No. Sun deliberately chose not include operator overloading in the Java language.
• Method - Yes.

 Java Overloading

Delphi supports both method and operator overloading.

For method overloading, you use the overload keyword (all versions of the routine must include the overload keyword). The compiler chooses the correct method first based on the number of parameters, then on the type so you can have two overloaded methods with the same number of parameters so long as at least one parameter is different.

Another form of method overloading is with the use of default parameters, a shortcut syntax, where you specify a default parameter value.

Delphi also supports operator overloading with some operators.

function Add(a, b: integer): Integer;  overload;
begin
  Result := a+b;
end;

function Add(const msg: String; a, b: integer): String; overload;
begin
  Result := msg + IntToStr(a+b);
end;

 Delphi Overloading (overload)

Object Pascal allows parameters of the same type to be listed together, separated by commas, and followed with a single data type (more params of different data types can follow, after a semi-colon).

Delphi also supports default parameters (a form of overloading).

By Reference or Value (and by constant): The default for parameters is by value. For by reference, add var in front of the parameter. Object Pascal also offers constant parameters where you add const in front of the parameter. A constant parameter is like a local constant or read-only parameter the compiler can optimize. You cannot assign a value to a constant parameter, nor can you pass one as a var parameter to another routine. (But when you pass an object reference as a constant parameter, you can still modify the object's properties.)

function Add(a, b: integer) : integer; 
begin
  Result := a + b;
end;
  
procedure ReplaceTime(var pDT: TDateTime; const pNewDT: TDateTime);
begin
end;

 Delphi Parameters (var, const)  

Within the implementation of a method, the identifier Self references the object in which the method is called. The Self variable is an implicit parameter for each object method. A method can use this variable to refer to its owning class.

ShowMessage('Self=' + Self.ClassName);

Delphi supports both static and dynamic arrays as well as single and multi dimensional arrays.

var
  MyArray: array[0..3] of string;
  i: Integer;
begin
  MyArray[0] := 'Mike';
  MyArray[1] := 'Lisa';
  MyArray[2] := 'Felicia';
  MyArray[3] := 'Nathan';

  for i := 0 to High(MyArray) do
    ShowMessage(MyArray[i]);
end;

 Delphi Array (x=Array[0..3] of string;)  

An associative array links a set of keys to a set of values. In Java, associative arrays are implemented as Maps.

This will print "Arizona."

import java.util.*;

public class Maps 
{
    public static void main(String[] args) 
    {
        Map states = new HashMap();
        
        states.put("CA", "California");
        states.put("FL", "Florida");
        states.put("AZ", "Arizona");

        System.out.println(states.get("AZ"));
    }
}

 Associative Arrays in Java (a Map)

Object Pascal doesn't have a native associative array, but you can use a TStringList the same way. (Alternatively, search the Internet for TStringHash and THashedStringList classes for implementations of a true associative array).

var
  StateList : TStringList;
begin
  StateList := TStringList.Create; 

  StateList.CommaText := 'CA=California, FL=Florida';

  ShowMessage('FL is ' + StateList.Values['FL']);
end;

 Associative Arrays in Delphi/Object Pascal (Use TStringList)

Java does not offer developer defined pointers.

Although pointer data types in Delphi coding are less important and not required for most general coding, Delphi fully supports developer defined pointers. Use a carrot (^) to declare a pointer data type. Use the @ operator or Addr function to return the current address of a variable.

Delphi provides typed pointer types such as PChar and PExtended as well as a generic point to anything Pointer type.

Nil is a special pointer value that you can assign to any type of pointer. Nil never points to any valid memory and indicates an unassigned or empty pointer.

//Declare a pointer of type integer.

PCounter : ^Integer;

//Assign a value to the location of a pointer.

//Also known as dereferencing.

PCounter^ := 8;

//Assign address of A to B.

PointerB := @PointerA;  //or...PointerB := Addr(PointerA);

Use a try..except..end block to trap and process errors.

Delphi also offers a try...finally where code will execute in the finally section no matter what. It's common to put a try..except inside a try..finally.

var
  y : Double;
begin
  try
    y := 0;
    y := (1/y);
    ShowMessage(FloatToStr(y));
  except
    ShowMessage('You cannot divide by zero.');
  end;
end;

Syntax template:

if (expression) {

  expression1_true_code;

} else if (expression2) {

  expression2_true_code;

} else {

  otherwise_code;

}

if ((.1 + .1 + .1) == 0.3) {
  System.out.println("Correct");
} else {
  System.out.println("Not correct");
}

Notice in the more complete example that the semicolon for the begin..end block after end is not included. That tells the compiler something else is coming (the statement is not finished). Also note the semicolon is missing right before the final "else" statement.

Note: The following example uses floating point literals. In Delphi, to specify a fractional floating point literal between 1 and -1, you preceed the decimal with a 0; otherwise, you will get a compiler error (i.e. .1 + .1 does not work).

if (0.1 + 0.1 + 0.1) = 0.3 then
  ShowMessage('Correct')
else
  ShowMessage('Not correct');

//Complete example:
if x = true then
begin 

  ShowMessage('x is true');

end

Else If y = 'Mike' Then 

  ShowMessage('hello mike')

Else 

  ShowMessage('last option');

 Delphi If Statement (If..Else If..Else)

Java uses = for it's assignment operator.

Delphi uses := for it's assignment operator.

var

  FullName: String;

  Age: Integer;

begin

  FullName := "Randy Spitz";
  Age := 38;

end

The Java comparison operators are:

Common comparison operators:

//Does Delphi evaluate the math correctly? Yes!

//Refer to math.pas MaxSingle for more info.

if (0.1 + 0.1 + 0.1 = 0.3) then
  ShowMessage('correct')
else
  ShowMessage('not correct')

 Delphi Comparison Operators (=, <>)

Length() or SizeOf() will correctly identify an unassigned string variable or an empty string.

if length(s) = 0 then
  ShowMessage('empty string');

Java logical operators:

//Given expressions a, b, c, and d:

if !((a && b) && (c || d)) {

  //Do something.

}

Delphi logical operators:

The Delphi compiler default is to short circuit multi argument boolean expressions when the result is known before the evaluation completes. To disable short circuiting, use the {$B+} compiler directive. To reset it back to the compiler default of short circuting, use the {$B-} compiler directive.

//Given expressions a, b, c, and d:

if Not (a and b) and (c or d) then

  //Do something.

 Delphi Logical Operators  

In Java, you use either the String concatenation + operator or StringBulder class methods such as append. Since Java compilers frequently create intermediate objects when the + operator is used and don't when StringBuilder.append is used, the append method is faster than the + operator.

In general, use the convenience of a + operator when speed is not an issue. For example, when concatenating a small number of items and when code isn't executed very frequently. A decent rule of thumb is to use the + operator for general purpose programming and then optimize the + operator with StringBuilder.append as needed.

System.out.println("Hello" + " " + "Mike.");

StringBuilder myMsg = new StringBuilder();
 

myMsg.append("Hello ");

myMsg.append("Mike.");

 
System.out.println(myMsg);

Use the + operator to concatenate two strings. Use IntToStr to convert an integer to a string and FloatToStr to convert a floating point number to a string.

var 

  FirstName : String; 

  LastName : String;

begin 

  FirstName := 'Mike'; 

  LastName := 'Prestwood';

  ShowMessage('Full name: ' + FirstName + ' ' + LastName);

  ShowMessage(FloatToStr(3.2));

end;

An operation with only one operand (a single input). The Java unary operators are ++, --, +, -, ~, and !.

• + Indicates positive value (numbers are positive without this)
• - Negates an expression
• ++ Increment operator by 1
• -- Decrement operator by 1
• ! Logical complement operator (inverts the value of a boolean)
• ~ Bitwise inversion operator (works on integral data types)

An operation with only one operand (a single input). In Object Pascal, a unary operator has the highest precedence and always precedes its operand (for example, -B), except for the  ^ pointer operator, which follows its operand (for example, P^). In addition to the obvious +, -, and Not operators, Delphi also offers:

The TYPE operator is also a unary operator and is valuated at compile time. The TYPE operator returns the size in bytes of the operand,

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

Java supports marking a full class as abstract as well as class members. A subclass must either implement the abstract members or you must declare the subclass abstract (which delays the implementation to it's subclass).

public abstract class Dog {
  abstract void Bark();
}

 Java Abstraction (abstract)

Delphi for Win32 supports abstract class members using the abstract keyword. You can even instantiate instances of a class that contains abstract members. Then you override each abstract member in a descendant class with Override.

Delphi does not support setting an entire class as abstract. You can create an abstract class (a class with one or more abstract methods), but there is no way to tell the compiler to not allow the instantiation of the abstract class.

Delphi does not support abstract member properties directly. To implement an abstract properity, make use of abstract methods. That is, you can read a GetPropertyX abstract function and write to a SetPropertyX abstract procedure. In effect, creating  an abstract property.

TCyborg = class(TObject)
public
  procedure Speak(pMessage: String); virtual; abstract;
  procedure Walk; virtual; abstract;
end;

TSeries600 = class(TCyborg)
public
  procedure Speak(pMessage: String); override;
  procedure Walk; override;
end;

 Delphi Abstraction (abstract, override)

However, developers sometimes use the term "class helper" to refer to code that helps out a class. Not truly the meaning we are using here, but you should be aware of the term's general usage.

Delphi allows you to extend an existing class without using inheritance. Buggy in 2005 and not officially supported but stable, usable, and officially supported in 2006 and above.

You declare a class helper similiar to how you declare a class but use the keywords class helper for.

TCyborg = class(TObject)
public
  FCyborgName: String;
end;

TCyborgHelper = class helper for TCyborg
  procedure ShowClassName;
end;

 Delphi Class Helpers (class helper for)  

Delphi does not offer built-in Design by Contract features. It does offer an Assert method which tests if an expression is true. If false, an EAssertionFailed exception is raised. Although you can use Assert in a similar manor as you would use a pre-condition contract, the Delphi help clearly says Assert is a debugging tool only and to not use it in production code.

//Although not intended as a code contract feature,

//Assert is useful for debugging.

method Cyborg.Walk(pPace);

begin
  Assert(pPace > 0);
  Assert(pPace < 100);

  //Overloaded version with message.
  Assert(FEnergyLevel >= 10, 'Energy level too low.');
end;

A method with the same name as the class.

Syntax Example:   public class Cyborg{ //Constructors have the same name as the class. public Cyborg() { } }

In Delphi, use the constructor keyword to signify which method or methods are constructors for a class. It is traditional but not required to use a procedure called Create.

In addition to having multiple named constructors, you can overload constructors.

//Interface section.

TCyborg = class(TObject)
public
  constructor Create;
end; 

constructor TCyborg.Create;
begin
  inherited;  //Call the parent Create method

end;

 Delphi Constructors (constructor)  

Java has a garbage collection algorythm that runs as a background task so it has no destructors. You can use the finalize() method to close additonal resources such as file handles.

protected void finalize() throws Throwable {
try {
	close(); // close open files
} finally {
	super.finalize();
}
}

Object Pascal uses a standard virtual destructor named Destroy which is called by the standard Free method. All objects are dynamic, so you need to call MyObject.Free method or the FreeAndNil(MyObject) routine for each object you create.

Syntax Example:   var MyObject: TObject; begin MyObject := TObject.Create; //Use it... MyObject.Free //Or use...FreeAndNil(MyObject); end;

Java does not support multiple implementation inheritance. Each class can have only one parent class (a single inheritance path). In Java, you can use multiple interface usage to design in a multiple class way horizontally in a class hierarchy.

Delphi does not support multiple implementation inheritance. Each class can have only one parent class (a single inheritance path).

In Delphi, you can use multiple interface usage to design in a multiple class way horizontally in a class hierarchy.

In Delphi, you use interfaces for both com objects and language interfaces and make use of IUnknown, IInterface, and/or TInterfacedObject.

For a pure language interface, add your specified proprieties, procedures, and functions to an interface that descends from IInterface (the base interface) as an interface, no implementation. Then have your implementing class inherit from TInterfacedObject and implement the interface.

For extending the VCL, you descend from the class you wish to extend, then implement an interface from IInterface and add the required functions QueryInterface, _AddRef, and _Release methods (refer to TInterfacedObject for an example).

For a com object, you descend from IUnknown. Descending from IUnknown instead of IInterface informs the Delphi compiler that the interface must be compatible with COM objects -- a Windows feature).

When defining an interface, define it in the type block just like you do for a class but you use the interface keyword instead of the class keyword and in the interfaces section only. Since interfaces, by definition, do not have any implementation details, all you do is specify it in the type block. Then implement in all classes that support the interface.

//Language interface:

//Interface section of unit.

IHuman = Interface(IInterface)
  //Specify interface methods and properties here.

end;

TCyborg = class(TInterfacedObject)

end;

TCyborgHuman = class(TCyborg, IHuman)
  //Specify each here and implement in
  //implementation section.
end;

 Delphi Interfaces (IInterface, TInterfacedObject)

In Delphi, you specify a virtual method with the virtual keyword in a parent class and extend (or replace) it in a descendant class using the override keyword. Call Inherited in the descendant method to execute the code in the parent method.

TRobot = class(TObject)
public
  procedure Speak; virtual;
end;

TCyborg = class(TRobot)
  procedure Speak; Override;
end;

 Delphi Overriding (virtual, override)

As of Delphi 2009, partial classes are not supported. The main reason given in the thread below was that the Delphi compiler is a single pass compiler. Here is a link to a discussion thread on the subject:

• Delphi language (partial classes)

Delphi supports the following types of polymorphism:

• Parametric Polymorphism (Method Overloading)
• Inheritance-Based Polymorphism
• Interface-Based Polymorphism (Interfaces)
• Ad-Hoc Polymorphism (Operator Overloading)

In Java, there is the concept of a final class.

With Delphi, use the sealed keyword to prevent a class from being inherited from and use the final keyword to prevent a method from being overridden.

type

  Robot = class sealed(TObject)
  public
    procedure Speak(pSentence: String); virtual; final;
  end;

 Delphi Sealed class (sealed, final)  

When calling a static method from within the same class, you don't need to specify the class name.

class MyUtils {
  //Static method.

  public static void MyStaticMethod() {
  }

}

 Java Static Members (static)

Object Pascal supports static methods, but not static member fields. For static member fields, use traditional Pascal-like global variables.

Since Object Pascal is a hybrid language, you can use global functions and data so the need for class methods is diminished but still useful. For example, since Object Pascal does not have automatic reference counting, you could use a class method to keep track of the number of object instances.

Delphi 1-7: All classes in a unit are friendly (see eachother's private members), some developers like to put each class in it's own unit and reserve putting multiple classes in the same unit until they wish to implement friendly classes.

Delphi 2005+: New strict keyword allows you to indicate friendly.

Delphi Prism: The Strict keyword was introduced from the beginning (Delphi.Net preview that shipped with D7).

type
TMyUtils = class(TObject)
public
  class function MyStaticMethod: Integer;
end;

class function TMyUtils.MyStaticMethod: Integer;

 Delphi Class Members (Class)