Delphi OOP Basics
In OOP languages, members of a class have a specific scope that indicates visibility. Standard visibility includes private, protected, and public. Private members are usable by the defining class only (fully encapsulated). They are invisible outside of the class except by friendly classes.
Protected members are usable by the defining class and descendant classes only (plus friendly classes). Public members are usable wherever its class can be referenced.
Languages Focus Traditional member visibility specifiers for fully OOP languages are private, protected, and public. Many modern OOP languages implement additional member visibilities.
Additional member modifiers are documented under the Member Modifiers topic.
Delphi:
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.
Syntax Example: 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;
Cross Reference Examples:
ASP Classic:
Private, Public
The member visibility modifiers are Private and Public . If not specified, the default is Public . Private and Public have the usual meaning. Private members are visible only within the class block. Public members are visible within the class and outside of the class.
Syntax Example: Class Cyborg Private FSerialNumber Public FCyborgName Public Function IntroduceYourself() Response.Write("Hi, I do not have a name yet.") End Function End Class
C#:
"Access Modifiers"
In C#, you specify each class and each class member's visibility with an access modifier . The C# access modifiers are the traditional public , protected , and private plus the two additional .Net modifiers internal and protected internal .
Internal indicates members are accessible from types in the same assembly. Protected internal indicates members are accessible from types in the same assembly as well as descendant classes. OO purist might object to internal and protected internal and I suggest you choose private , protected , or public over them until you both fully understand them and have a need that is best suited by them.
Syntax Example: public class Cyborg{ private String FName;}
C++:
C++ implements class and member visibility specifiers traditionally. Note the colon at the end of each visibility specifier and the semi-colon at the end of the class (the end of the statement).
Syntax Example: class Cyborg: Public AParentClass {public : protected : private :};
Corel Paradox:
Not Supported
Delphi Prism:
"Class Member Visibility Levels"
In Prism, you specify each class and each class member's visibility with a Class Member Visibility Level preceding the return type. Like Delphi, you group member declarations as part of defining the interface for a class in the Interface section of a unit.
Unlike Delphi, Prism supports a traditional OO approach to member visibility with additional .Net type assembly visibility. For example, private members are truly private to the class they are declared in. In Delphi for Win32, you use strict private for true traditional private visibility.
Prism also supports assembly and protected and assembly or protected which modify the visibility of protected members to include only descendants in the same assembly (and ) or publicly accessible from assembly and descendant only outside (or ). OO purist might object to assembly and protected and assembly or protected and I suggest you choose the traditional private , protected , and public as your first chose at least until you both fully understand them and have a specific need for them.
Syntax Example: Cyborg = public class(System.Object)private //private properties, methods, etc. here. FName: String;protected //protected properties, methods, etc. here. assembly and protected //properties, methods, etc. here. assembly or protected //properties, methods, etc. here. public //properties, methods, etc. here. end;
VB Classic:
In VB Classic, the keywords Private , Friend , Public , and Static are used to set access levels for declared elements.
More Info / Comment
VB.Net:
"Access Modifiers"
In VB.Net, you specify each class and each class member's visibility with an access modifier preceding class or member. The VB.Net access modifiers are the traditional Public , Protected , and Private plus the two additional .Net modifiers Friend and Protected Friend .
Friend indicates members are accessible from types in the same assembly. Protected Friend indicates members are accessible from types in the same assembly as well as descendant classes. OO purist might object to Friend and Protected Friend and I suggest you avoid them until you both fully understand them and have a need that is best suited by them.
Syntax Example: Public Class Cyborg Inherits Object Private FName As String End Class