Cross Ref > Language Basics

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;)