Cross Ref > OOP Details

General Info: Abstract Class / Abstract Member

An abstract class member is a member that is specified in a class but not implemented. Classes that inherit from the class will have to implement the abstract member. Abstract members are a technique for ensuring a common interface with descendant classes. An abstract class is a class you cannot instantiate. A pure abstract class is a class with only abstract members.

Languages Focus

Abstraction is supported at various levels with each language. A language could enforce abstraction at the class level (either enforcing a no-instantiation rule or a only abstract members rule), and with class members (member methods and/or properties).

Java:   abstract 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). Syntax Example: public abstract class Dog {   abstract void Bark(); }  Java Abstraction (abstract)

Delphi:   abstract, override 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. Syntax Example: 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)

A. In Dephi, class helpers allow you to extend a class without using inheritance. With a class helper, you do not have to create and use a new class descending from a class but instead you enhance the class directly and continue using it as you always have (even just with the DCU).

B. In general terms, developers sometimes use the term to refer to any class that helps out another class.

Java:  "Class Helpers" Not Supported 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:  "Class Helpers" class helper for 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. Syntax Example: TCyborg = class(TObject) public   FCyborgName: String; end; TCyborgHelper = class helper for TCyborg   procedure ShowClassName; end;  Delphi Class Helpers (class helper for)

A.k.a. Class Contract and Design by Contracts.

A contract with a method that must be true upon calling (pre) or exiting (post). A pre-condition contract must be true when the method is called. A post-condition contract must be true when exiting. If either are not true, an error is raised. For example, you can use code contracts to check for the validity of input parameters, and results

An invariant is also a code contract which validates the state of the object required by the method.

[Not specified yet. Coming...]

Delphi:  "Code Contracts" Not Supported 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;

General Info: Class Constructor

Constructors are called when you instantiate an object from a class. This is where you can initialize variables and put code you wish executed each time the class is created. When you initially set the member fields and properties of an object, you are initializing the state of the object. The state of an object is the values of all it's member fields and properties at a given time.

Languages Focus

What is the syntax? Can you overload constructors? Is a special method name reserved for constructors?

Java:  "Constructors" Use class name A method with the same name as the class. Syntax Example:   public class Cyborg{ //Constructors have the same name as the class. public Cyborg() { } }

Delphi:  "Constructors" constructor 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. Syntax Example: //Interface section. TCyborg = class(TObject) public   constructor Create; end;  Then implement the class constructor in the Implementation section. constructor TCyborg.Create; begin   inherited;  //Call the parent Create method end;  Delphi Constructors (constructor)

General Info: Class Destructor

A special class method called when an object instance of a class is destroyed. With some languages they are called when the object instance goes out of scope, with some languages you specifically have to call the destructor in code to destroy the object, and others use a garbage collector to dispose of object instances at specific times.

Desctructors are commonly used to free the object instance but with languages that have a garbage collector object instances are disposed of when appropriate. Either way, destructors or their equivalent are commonly used to free up resources allocated in the class constructor.

Languages Focus

Are object instances freed with a garbage collector? Or, do you have to destroy object instances.

Java:  "finalize" finalize() 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. Syntax Example: protected void finalize() throws Throwable { try { close(); // close open files } finally { super.finalize(); } }

Delphi:   Free or FreeAndNil 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;

An element of coding where you define a common set of properties and methods for use with the design of two or more classes.

Both interfaces and abstract classes are types of abstraction. With interfaces, like abstract classes, you cannot provide any implementation. However, unlike abstract classes, interfaces are not based on inheritance. You can apply an Interface to any class in your class tree. In a real sense, interfaces are a technique for designing horizontally in a class hierarchy (as opposed to inheritance where you design vertically). Using interfaces in your class design allows your system to evolve without breaking existing code.

Java:  "Interfaces" Yes  Java Interfaces (Yes)

Delphi:  "Interfaces" IInterface, TInterfacedObject 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. Syntax Example: //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)

General Info: Method Overriding

Where you define or implement a virtual method in a parent class and then replace it in a descendant class.

When you decide to declare a method as virtual, you are giving permission to derived classes to extend and override the method with their own implementation. You can have the extended method call the parent method's code too.

In most OO languages you can also choose to hide a parent method. When you introduce a new implementation of the same named method with the same signature without overriding, you are hiding the parent method.

[Not specified yet. Coming...]

Delphi:   virtual, override 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. Syntax Example: TRobot = class(TObject) public procedure Speak; virtual; end; TCyborg = class(TRobot) procedure Speak; Override; end;  Delphi Overriding (virtual, override)

A partial class, or partial type, is a class that can be split into two or more source code files and/or two or more locations within the same source file. Each partial class is known as a class part or just a part. Logically, partial classes do not make any difference to the compiler. The compiler puts the class together at compile time and treats the final class or type as a single entity exactly the same as if all the source code was in a single location.

Languages Focus

For languages that have implemented partial classes, you need to know usage details and restrictions. Can you split a class into two or more files? Can you split a class within a source code file into two or more locations? What are the details of inheritance? Does it apply to interfaces as well?

Java:  "Partial Classes" Not Supported	Delphi:  "Partial Classes" Not Supported 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)

A coding technique where the same named function, operator, or object behaves differently depending on outside input or influences. Usually implemented as parameter overloading where the same named function is overloaded with other versions that are called either with a different type or number of parameters. Polymorphism is a general coding technique and other specific implementations are common such as inheritance, operator overloading, and interfaces.

Languages Focus

Many languages support built-in polymorphism such as a "+" operator that can add both integers and decimals. The following documents the ability to implement developer defined polymorphism.

[Not specified yet. Coming...]

Delphi:  Delphi supports the following types of polymorphism: Parametric Polymorphism (Method Overloading) Inheritance-Based Polymorphism Interface-Based Polymorphism (Interfaces) Ad-Hoc Polymorphism (Operator Overloading) More Info / Comment

Languages Focus

How do you prevent another class from inheriting and/or prevent a class from overriding a member.

Java:  "final class" Final In Java, there is the concept of a final class. More Info / Comment	Delphi:  "Sealed class" sealed, final 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. Syntax Example: type Robot = class sealed(TObject) public   procedure Speak(pSentence: String); virtual; final; end;  Delphi Sealed class (sealed, final)

General Info: Static Class / Static Member

A static member is a member you can have access to without instantiating the class into an object. For example, you can read and write static properties and call static methods without ever creating the class. Static members are also called class members (class methods, class properties, etc.) since they belong to the class and not to a specific object. A static class is a class that contains only static members. In the UML, these classes are described as utility classes.

Languages Focus

Languages that support static members usually at least support static member fields (the data). Some languages also support static methods, properties, etc. in which case the class member is held in memory at one location and shared with all objects. Finally, some languages support static classes which usually means the compiler will make sure a static class contains only static members.

Java:  "Static Members" static When calling a static method from within the same class, you don't need to specify the class name. Syntax Example: class MyUtils { //Static method. public static void MyStaticMethod() { } }  Java Static Members (static)

Delphi:  "Class Members" Class 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). Syntax Example: type TMyUtils = class(TObject) public class function MyStaticMethod: Integer; end; In implimentation: class function TMyUtils.MyStaticMethod: Integer;  Delphi Class Members (Class)