Comparison of programming languages (object-oriented programming)

Last updated

This comparison of programming languages compares how object-oriented programming languages such as C++, Java, Smalltalk, Object Pascal, Perl, Python, and others manipulate data structures.

Contents

Object construction and destruction

constructiondestruction
ABAP Objects data variable type ref to class .
create object variable «exporting parameter = argument».
[1]
[2] [3]
APL (Dyalog)variable←⎕NEW class «parameters»⎕EX 'variable'
C++ class variable«(parameters)»; [4] or
class * variable = new class«(parameters)»; [5]
delete pointer;
C# class variable = new class(parameters);variable.Dispose(); [3]
Java [3]
D destroy(variable);
eCclass «instance handle» { «properties/data members assignments, instance method overrides» }delete instance handle;
Objective-C (Cocoa)class * variable = [[class alloc ] init]; or
class * variable = [[class alloc ] initWithFoo:parameter «bar:parameter ...»];
[variable release];
Swift let variable = class(parameters)
Python variable = class(parameters)del variable [3] (Normally not needed)
Visual Basic .NET Dim variable As New class(parameters)variable.Dispose() [3]
Xojo Dim variable As New class(parameters)variable = Nil
Eiffel create variable or
create «{TYPE}» variable.make_foo «(parameters)» or
variable := create{TYPE} or
variable := create {TYPE}.make_foo «(parameters)»
[3]
PHP $ variable = new class«(parameters)»;unset($variable); [3]
Perl 5«my »$variable = class->new«(parameters)»;undef($variable);
Raku «my »$variable = class.new«(parameters)»;$variable.undefine;
Ruby variable = class.new«(parameters)» [3]
Windows PowerShell $variable = New-Object «-TypeName» class ««-ArgumentList» parameters»Remove-Variable «-Name» variable
OCaml let variable = new class «parameters» or
let variable = object members end [6]
[3]
F# let variable = «new »class(«parameters»)
Smalltalk The class is an Object.
Just send a message to a class, usually #new or #new:, and many others, for example:
Pointx:10y:20.Arraywith:-1with:3with:2.
JavaScript var variable = new class«(parameters)» or
var variable = { «key1: value1«, key2: value2 ...»»}
[3]
Object Pascal (Delphi)ClassVar := ClassType.ConstructorName(parameters);ClassVar.Free;
Scala
valobj=newObject// no parametersvalobj=newObject(arg0,arg1,arg2...)valobj=Object(arg0,arg1,arg2...)// case classvalobj=newObject(arg0,arg1,param1=value1,...)// named parameters
[3]
COBOL INVOKE class "NEW"RETURNING variable or
MOVE class::"NEW"TO variable
Cobra variable «as class» = class(parameters)variable.dispose
ISLISP (setq variable (create (class <some-class> [:field-1 value-1 [:field-2 value-2] ..]))) [3]

Class declaration

class protocol namespace
ABAP Objectsclass name definition «inheriting from parentclass». «interfaces: interfaces.» method_and_field_declarations endclass.
class name implementation. method_implementations endclass.
interface name. members endinterface.
APL (Dyalog):Class name «:parentclass» «,interfaces»
members
:EndClass
:Interface name
members
:EndInterface
:Namespace name
members
:EndNamespace
C++class name« : public parentclasses [7] » { members };namespace name { members }
C#class name« : «parentclass»«, interfaces»» { members }interface name« : parentinterfaces» { members }
Dmodule name;
members
eCclass name« : base class» { «default member values assignments» «members» }namespace name;
Javaclass name« extends parentclass»« implements interfaces» { members }interface name« extends parentinterfaces» { members }package name; members
PHPnamespace name; members
Objective-C@interface name« : parentclass» [8] «< protocols >» { instance_fields } method_and_property_declarations @end
@implementation
name method_implementations @end
[9]
@protocol name«< parentprotocols >» members @end [10]
Swiftclass name« : «parentclass»«, protocols»» { members }protocol name« : parentprotocols» { members }
Pythonclass name«(parentclasses [7] )»:
Tab ↹
members
[11] __all__ = [ member1,member2,... ]
Visual Basic .NETClass name« Inherits parentclass»« Implements interfaces»
members
End Class
Interface name« Inherits parentinterfaces»
members
End Interface
Namespace name
members
End Namespace
XojoClass name« Inherits parentclass»« Implements interfaces»
members
End Class
Interface name« Inherits parentinterfaces»
members
End Interface
Module name
members
End Module
Eiffelclass name« inherit parentclasses [7] »
members
end
Perlpackage name; «@ISA = qw(parentclasses [7] );» members 1;package name; members
Rakuclass name «is parentclass «is parentclass ... [7] »» «does role «does role ...»» { members }role name «does role «does role ...»» { members }module name { members }
Rubyclass name« < parentclass»
members
end
module name
members
end
Windows PowerShell
OCamlclass name «parameters» = object «(self)» «inherit parentclass «parameters» «inherit parentclass «parameters» ... [7] »» members endmodule name
members
F#type name«(parameters)»«as this» = class «inherit parentclass«(parameters)» «as base»» members «interface interface with implementation «interface interface with implementation ...»» endtype name = interface members endnamespace name
members
Smalltalk [12] [13]
JavaScript (ES6)class name «extends parentclass» { members }
Object Pascal (Delphi)

ClassName = Class «(ClassParent, Interfaces)»
private
// Private members(include Methods and Fields)
public
// Public members
protected
// Protected members
published
// Published members
end;

package name; members
Scala
classConcreteClass(constructorparams)extendsParentClasswithTrait1withTrait2withTrait2{// members}
traitTraitNameextendsOtherTrait1withOtherTrait2withOtherTrait3{// members}
packagename
COBOLCLASS-ID. name« INHERITS« FROM» parentclasses».
    FACTORY« IMPLEMENTS interfaces».
    class-members
    END FACTORY.
    OBJECT« IMPLEMENTS interfaces».
    instance-members
    END OBJECT.

END CLASS name.

INTERFACE-ID. name« INHERITS« FROM» interfaces».
    members

END INTERFACE name.

Cobraclass name «inherits parentclass» «implements interfaces»
Tab ↹ members
interface name «inherits parentinterfaces»
Tab ↹ members
namespace name
Tab ↹ members
ISLISP(defclass name (base-class) ((x :initform 0 :accessor get-x :initarg x)) (:abstractp nil))

Class members

Constructors and destructors

constructor destructor finalizer [14]
ABAP Objectsmethods constructor «importing parameter = argument»
method constructor. instructions endmethod.
[15]
APL (Dyalog) name
:Implements Constructor «:Base «expr»»
instructions
name
:Implements Destructor
instructions
C++class(«parameters») «: initializers [16] » { instructions }~class() { instructions }
C#class(«parameters») { instructions }void Dispose(){ instructions }~class() { instructions }
Dthis(«parameters») { instructions }~this() { instructions }
eCclass() { instructions }~class() { instructions }
Javaclass(«parameters») { instructions }void finalize() { instructions }
Eiffel [17] [18]
Objective-C (Cocoa)- (id)init { instructions... return self; } or
- (id)initWithFoo:parameter «bar:parameter ...» { instructions... return self; }
- (void)dealloc { instructions }- (void)finalize { instructions }
Swiftinit(«parameters») { instructions }deinit { instructions }
Pythondef __init__(self«, parameters»):
Tab ↹ instructions
def __del__(self):
Tab ↹ instructions
Visual Basic .NETSub New(«parameters»)
instructions
End Sub
Sub Dispose()
instructions
End Sub
Overrides Sub Finalize()
instructions
End Sub
XojoSub Constructor(«parameters»)
instructions
End Sub
Sub Destructor()
instructions
End Sub
PHPfunction __construct(«parameters») { instructions }function __destruct() { instructions }
Perlsub new { my ($class«, parameters») = @_; my $self = {}; instructions ... bless($self, $class); return $self; }sub DESTROY { my ($self) = @_; instructions }
Rakusubmethod BUILD { instructions } or
«multi » method new(««$self: »parameters») { self.bless(*, field1 => value1, ...); ... instructions }
submethod DESTROY { instructions }
Rubydef initialize«(parameters)»
instructions
end
Windows PowerShell
OCamlinitializer instructions [19]
F#do instructions or
new(parameters) = expression
[20]
member this.Dispose() = instructionsoverride this.Finalize() = instructions
JavaScriptfunction name(«parameters»){ instructions } [21]
JavaScript (ES6)constructor(«parameters») { instructions }
COBOL [22]
Cobracue init(parameters)
Tab ↹base.init
Tab ↹ instructions
def dispose
Tab ↹ instructions
ISLISP(defmethod initialize-object ((instance <class-name>) initvalues)

Fields

publicprivateprotectedfriend
ABAP Objectspublic section. [23] data field type type.private section. [23] data field type type.protected section. [23] data field type type. [24]
APL (Dyalog):Field Public field « value»:Field «Private» field « value»
C++public: type field;private: type field;protected: type field; [25]
C#public type field «= value»;private type field «= value»;protected type field «= value»;internal type field «= value»;
Dpackage type field «= value»;
Javaprotected type field «= value»;type field «= value»;
eCpublic type field;private type field;
Eiffelfeature
field: TYPE
feature {NONE}
field: TYPE
feature {current_class}
field: TYPE
feature {FRIEND}
field: TYPE
Objective-C@public type field;@private type field;@protected type field;@package type field;
Swift
Smalltalk [26]
Pythonself.field = value [27] [28]
Visual Basic .NETPublic field As type «= value»Private field As type «= value»Protected field As type «= value»Friend field As type «= value»
XojoPublic field As type «= value»Private field As type «= value»Protected field As type «= value»
PHPpublic $field «= value»;private $field «= value»;protected $field «= value»;
Perl$self->{field} = value; [27]
Rakuhas« type »$.field« is rw»has« type »$!field
Ruby @ field = value [27]
Windows PowerShellAdd-Member
«-MemberType »NoteProperty
«-Name »Bar «-Value »value
-InputObject variable
OCamlval «mutable» field = value
F#let «mutable» field = value
JavaScriptthis.field = value
this["field"] = value
[27]
COBOLlevel-number field clauses. [29]
Cobravar field «as type» «= value»var__field «as type» «= value»var_field «as type» «= value»
ISLISP(field :initform value :accessor accessor-name :initarg keyword)

Methods

basic/void methodvalue-returning method
ABAP Objectsmethods name «importing parameter = argument» «exporting parameter = argument» «changing parameter = argument» «returning value(parameter)»
method name. instructions endmethod.
[30]
[31]
APL (Dyalog) «left argument» name «right arguments»
instructions
result «left argument» name «right arguments»
instructions
C++ [32]
type foo(«parameters»);

The implementation of methods is usually provided in a separate source file, with the following syntax

type class::foo(«parameters») { instructions } [33]
void foo(«parameters») { instructions }type foo(«parameters») { instructions ... return value; }
C#
D
Java
eCvoid ««type of 'this'»::»foo(«parameters») { instructions }type ««type of this»::»foo(«parameters») { instructions ... return value; }
Eiffelfoo ( «parameters» )
do
instructions
end
foo ( «parameters» ): TYPE
do
instructions...
Result := value
end
Objective-C- (void)foo«:parameter «bar:parameter ...»» { instructions }- (type)foo«:parameter «bar:parameter ...»» { instructions... return value; }
Swiftfunc foo(«parameters») { instructions }func foo(«parameters») -> type { instructions... return value }
Pythondef foo(self«, parameters»):
Tab ↹
instructions
def foo(self«, parameters»):
Tab ↹
instructions
Tab ↹ return
value
Visual Basic .NETSub Foo(«parameters»)
instructions
End Sub
Function Foo(«parameters») As type
instructions
...
Return value
End Function
XojoSub Foo(«parameters»)
instructions
End Sub
Function Foo(«parameters») As type
instructions
...
Return value
End Function
PHPfunction foo(«parameters»)«: void» { instructions }function foo(«parameters»)«: type» { instructions ... return value; }
Perlsub foo { my ($self«, parameters») = @_; instructions }sub foo { my ($self«, parameters») = @_; instructions ... return value; }
Raku«has »«multi »method foo(««$self: »parameters») { instructions }«has «type »»«multi »method foo(««$self: »parameters») { instructions ... return value; }
Rubydef foo«(parameters)»
instructions
end
def foo«(parameters)»
instructions
expression resulting in return value
end
or
def foo«(parameters
instructions
return value
end
Windows PowerShellAdd-Member «-MemberType» ScriptMethod «-Name» foo «-Value» { «param(parameters)»instructions } -InputObject variableAdd-Member «-MemberType» ScriptMethod «-Name» foo «-Value» { «param(parameters)»instructions ... return value } -InputObject variable
OCamlmethod foo «parameters» = expression
F#member this.foo(«parameters») = expression
JavaScriptthis.method = function(«parameters») {instructions}
name«.prototype.method = function(«parameters») {instructions}
[34]
this.method = function(«parameters») {instructions... return value;}
name«.prototype.method = function(«parameters») {instructions... return value;}
[34]
Javascript (ES6)foo(«parameters») {instructions}foo(«parameters») {instructions... return value;}
COBOLMETHOD-ID. foo.
«DATA DIVISION.
LINKAGE SECTION.
parameter declarations»
PROCEDURE DIVISION« USING parameters».
    instructions

END METHOD foo.

METHOD-ID. foo.
DATA DIVISION.
LINKAGE SECTION.
«parameter declarations»
result-var declaration
PROCEDURE DIVISION« USING parameters» RETURNING result-var.
    instructions

END METHOD foo.

Cobradef foo(parameters)
Tab ↹ instructions
def foo(parameters) as type
Tab ↹ instructions
Tab ↹return value
ISLISP(defgeneric method (arg1 arg2))
(defmethod method ((arg1 <class1> arg2 <class2>) ...)

Properties

How to declare a property named "Bar"

Manually implemented

read-writeread-onlywrite-only
ABAP Objects
APL (Dyalog):Property Bar
result ← Get
instructions

∇ Set arguments
instructions

:EndProperty Bar
:Property Bar
result ← Get
instructions

:EndProperty Bar
:Property Bar
∇ Set arguments
instructions

:EndProperty Bar
C++
C#type Bar {
get {
instructions ... return value;}
set {
instructions } }
type Bar { get { instructions ... return value;} }type Bar { set { instructions } }
D@property type bar() { instructions ... return value;}
@property
type bar(type value) { instructions ... return value;}
@property type bar() { instructions ... return value;}@property type bar(type value) { instructions ... return value;}
eCproperty type Bar {
get {
instructions ... return value;}
set {
instructions } }
property type Bar { get { instructions ... return value;} }property type Bar { set { instructions } }
Java
Objective-C 2.0 (Cocoa)@property (readwrite) type bar;
and then inside
@implementation
- (type)bar { instructions }
- (void)setBar:(type)value { instructions }
@property (readonly) type bar;
and then inside
@implementation
- (type)bar { instructions }
Swiftvar bar : type { get { instructions } set«(newBar)» { instructions } }var bar : type { instructions }
Eiffelfeature -- Access
x: TYPE assign set_x
feature -- Settings
set_x (a_x: like x) do instructions ensure x_set: verification end
Pythondef setBar(self, value):
Tab ↹ instructions
def
getBar(self):
Tab ↹
instructions
Tab ↹return value
bar = property(getBar, setBar)
[35]
def getBar(self):
Tab ↹ instructions
Tab ↹return value
bar = property(getBar)
def setBar(self, value):
Tab ↹ instructions
bar = property(fset = setBar)
Visual Basic .NETProperty Bar() As type
Get
instructions
Return value
End Get
Set (ByVal
Value As type)
instructions
End Set
End Property
ReadOnly Property Bar() As type
Get
instructions
Return value
End Get
End Property
WriteOnly Property Bar() As type
Set (ByVal Value As type)
instructions
End Set
End Property
XojoComputedProperty Bar() As type
Get
instructions
Return value
End Get
Set (ByVal
Value As type)
instructions
End Set
End ComputedProperty
ComputedProperty Bar() As type
Get
instructions
Return value
End Get
End ComputedProperty
ComputedProperty Bar() As type
Set (value As type)
instructions
End Set
End ComputedProperty
PHPfunction __get($property) {
switch (
$property) {
case
'Bar' : instructions ... return value;
} }
function __set(
$property, $value) {
switch (
$property) {
case
'Bar' : instructions
} }
function __get($property) {
switch ($
property) {
case
'Bar' : instructions ... return value;
} }
function __set($property, $value) {
switch (
$property) {
case
'Bar' : instructions
} }
Perlsub Bar {
my $self = shift;
if (my $Bar = shift) {
# setter
$self->{Bar} = $Bar;
return $self;
} else {
# getter
return $self->{Bar};
}
}
sub Bar {
my $self = shift;
if (my $Bar = shift) {
# read-only
die "Bar is read-only\n";
} else {
# getter
return $self->{Bar};
}
}
sub Bar {
my $self = shift;
if (my $Bar = shift) {
# setter
$self->{Bar} = $Bar;
return $self;
} else {
# write-only
die "Bar is write-only\n";
}
}
Raku
Rubydef bar
instructions
expression resulting in return value
end
def bar=(value)
instructions
end
def bar
instructions
expression resulting in return value
end
def bar=(value)
instructions
end
Windows PowerShellAdd-Member
«-MemberType »ScriptProperty
«-Name »Bar «-Value »{ instructions ... return value }
«-SecondValue »{ instructions }
-InputObject variable
Add-Member
«-MemberType »ScriptProperty
«-Name »Bar «-Value »{ instructions ... return value}
-InputObject variable
Add-Member
«-MemberType »ScriptProperty
«-Name »Bar -SecondValue { instructions }
-InputObject variable
OCaml
F#member this.Bar with get() = expression and set(value) = expressionmember this.Bar = expressionmember this.Bar with set(value) = expression
JavaScript (ES6)get bar(«parameters»){ instructions ... return value}set bar(«parameters») { instructions } get bar(«parameters»){ instructions ... return value}set bar(«parameters») { instructions }
COBOLMETHOD-ID. GET PROPERTY bar.
DATA DIVISION.
LINKAGE SECTION.
return-var declaration
PROCEDURE DIVISION RETURNING return-var.
    instructions

END METHOD.
METHOD-ID. SET PROPERTY bar.
DATA DIVISION.
LINKAGE SECTION.
value-var declaration
PROCEDURE DIVISION USING value-var.

    instructions

END METHOD.

METHOD-ID. GET PROPERTY bar.
DATA DIVISION.
LINKAGE SECTION.
return-var declaration
PROCEDURE DIVISION RETURNING return-var.
    instructions

END METHOD.

METHOD-ID. SET PROPERTY bar.
DATA DIVISION.
LINKAGE SECTION.
value-var declaration
PROCEDURE DIVISION USING value-var.
    instructions

END METHOD.

Cobrapro bar «as type»
Tab ↹get
Tab ↹Tab ↹ instructions
Tab ↹Tab ↹return value
Tab ↹set
Tab ↹Tab ↹ instructions
get bar «as type»
Tab ↹ instructions
Tab ↹return value
set bar «as type»
Tab ↹ instructions
ISLISP

Automatically implemented

read-writeread-onlywrite-only
ABAP Objects
C++
C#type Bar { get; set; }type Bar { get; private set; }type Bar { private get; set; }
D
Java
Objective-C 2.0 (Cocoa)@property (readwrite) type bar;
and then inside @implementation
@synthesize bar;
@property (readonly) type bar;
and then inside @implementation
@synthesize bar;
Swiftvar bar : typelet bar : type
Eiffel
Python@property
def bar(self):
Tab ↹instructions
@bar.setter
def bar(self, value):
Tab ↹instructions
@property
def bar(self):
Tab ↹instructions
bar = property()
@bar.setter
def bar(self, value):
Tab ↹instructions
Visual Basic .NETProperty Bar As type« = initial_value» (VB 10)
PHP
Perl [36] usebaseqw(Class::Accessor);
__PACKAGE__->mk_accessors('Bar');
usebaseqw(Class::Accessor);
__PACKAGE__->mk_ro_accessors('Bar');
usebaseqw(Class::Accessor);
__PACKAGE__->mk_wo_accessors('Bar');
Raku
Rubyattr_accessor :barattr_reader :barattr_writer :bar
Windows PowerShell
OCaml
F#member val Bar = value with get, set
COBOLlevel-number bar clauses PROPERTY.level-number bar clauses PROPERTY «WITH» NO SET.level-number bar clauses PROPERTY «WITH» NO GET.
Cobrapro bar from var «as type»get bar from var «as type»set bar from var «as type»

Overloaded operators

Standard operators

unarybinaryfunction call
ABAP Objects
C++type operator symbol () { instructions }type operator symbol (type operand2) { instructions }type operator () («parameters») { instructions }
C#static type operator symbol(type operand) { instructions }static type operator symbol(type operand1, type operand2) { instructions }
Dtype opUnary(string s)() if (s == "symbol") { instructions }type opBinary(string s)(type operand2) if (s == "symbol") { instructions }
type opBinaryRight(string s)(type operand1) if (s == "symbol") switch (s) { instructions }
type opCall(«parameters») { instructions }
Java
Objective-C
Swiftfunc symbol(operand1 : type) -> returntype { instructions } (outside class)func symbol(operand1 : type1, operand2 : type2) -> returntype { instructions } (outside class)
Eiffel [37] op_name alias "symbol": TYPE
do instructions end
op_name alias "symbol" (operand: TYPE1): TYPE2
do instructions end
Pythondef __opname__(self):
Tab ↹
instructions
Tab ↹ return
value
def __opname__(self, operand2):
Tab ↹
instructions
Tab ↹ return
value
def __call__(self«, parameters»):
Tab ↹
instructions
Tab ↹ return
value
Visual Basic .NETShared Operator symbol(operand As type) As type
instructions
End Operator
Shared Operator symbol(operand1 As type, operand2 As type) As type
instructions
End Operator
XojoFunction Operator_name(operand As type) As type
instructions
End Function
PHP [38] function __invoke(«parameters») { instructions } (PHP 5.3+)
Perluse overload "symbol" => sub { my ($self) = @_; instructions };use overload "symbol" => sub { my ($self, $operand2, $operands_reversed) = @_; instructions };
Raku«our «type »»«multi »method prefix:<symbol> («$operand: ») { instructions ... return value;} or
«our «type »»«multi »method postfix:<symbol> («$operand: ») { instructions ... return value;} or
«our «type »»«multi »method circumfix:<symbol1 symbol2> («$operand: ») { instructions ... return value;}
«our «type »»«multi »method infix:<symbol> («$operand1: » type operand2) { instructions ... return value;}«our «type »»«multi »method postcircumfix:<( )> («$self: » «parameters») { instructions }
Rubydef symbol
instructions
expression resulting in return value
end
def symbol(operand2)
instructions
expression resulting in return value
end
Windows PowerShell
OCaml
F#static member (symbol) operand = expressionstatic member (symbol)(operand1, operand2) = expression
COBOL
ISLISP

Indexers

read-writeread-onlywrite-only
ABAP Objects
APL (Dyalog):Property Numbered Default name
result ← Get
instructions

∇ Set arguments
instructions

:EndProperty Bar
:Property Numbered Default Bar
result ← Get
instructions

:EndProperty Bar
:Property Numbered Default Bar
∇ Set arguments
instructions

:EndProperty Bar
C++type& operator[](type index) { instructions }type operator[](type index) { instructions }
C#type this[type index] {
get{
instructions }
set{
instructions } }
type this[type index] { get{ instructions } }type this[type index] { set{ instructions } }
Dtype opIndex(type index) { instructions }
type opIndexAssign(type value, type index) { instructions }
type opIndex(type index) { instructions }type opIndexAssign(type value, type index) { instructions }
Java
Objective-C (recent Clang compiler)- (id)objectAtIndexedSubscript:(NSUInteger)index { instructions return value; } or
- (id)objectForKeyedSubscript:(id)index { instructions return value; }
- (void)setObject:(id)value atIndexedSubscript:(NSUInteger)index { instructions } or
- (void)setObject:(id)value forKeyedSubscript:(id)index { instructions }
Swiftsubscript (index : type) -> returntype { get { instructions } set«(newIndex)» { instructions } }subscript (index : type) -> returntype { instructions }
Eiffel [37] bracket_name alias "[]" (index: TYPE): TYPE assign set_item
do instructions end
set_item (value: TYPE; index: TYPE):
do instructions end
bracket_name alias "[]" (index: TYPE): TYPE
do instructions end
Pythondef __getitem__(self, index):
Tab ↹ instructions
Tab ↹return value
def __setitem__(self, index, value):
Tab ↹ instructions
def __getitem__(self, index):
Tab ↹ instructions
Tab ↹return value
def __setitem__(self, index, value):
Tab ↹ instructions
Visual Basic .NETDefault Property Item(Index As type) As type
Get
instructions
End Get
Set(ByVal
Value As type)
instructions
End Set
End Property
Default ReadOnly Property Item(Index As type) As type
Get
instructions
End Get
End Property
Default WriteOnly Property Item(Index As type) As type
Set(ByVal
Value As type)
instructions
End Set
End Property
PHP [39]
Perl [40]
Raku«our «type »»«multi »method postcircumfix:<[ ]> is rw («$self: » type $index) { instructions ... return value;} or
«our «type »»«multi »method postcircumfix:<{ }> is rw («$self: » type $key) { instructions ... return value;}
«our «type »»«multi »method postcircumfix:<[ ]>(«$self: » type $index) { instructions ... return value;} or
«our «type »»«multi »method postcircumfix:<{ }> («$self: » type $key) { instructions ... return value;}
Rubydef [](index)
instructions
expression resulting in return value
end
def []=(index, value)
instructions
end
def [](index)
instructions
expression resulting in return value
end
def []=(index, value)
instructions
end
Windows PowerShell
OCaml
F#member this.Item with get(index) = expression and set index value = expressionmember this.Item with get(index) = expressionmember this.Item with set index value = expression
COBOL
Cobrapro[index «as type»] as type
Tab ↹get
Tab ↹Tab ↹ instructions
Tab ↹Tab ↹return value
Tab ↹set
Tab ↹Tab ↹ instructions
get[index «as type»] as type
Tab ↹ instructions
Tab ↹return value
set[index «as type»] as type
Tab ↹ instructions

Type casts

downcastupcast
ABAP Objects
C++operator returntype() { instructions }
C#static explicit operator returntype(type operand) { instructions }static implicit operator returntype(type operand) { instructions }
DT opCast(T)() if (is(T == type)) { instructions }
eCproperty T { get { return «conversion code»; } }
Java
Objective-C
Eiffel [37]
Python
Visual Basic .NETShared Narrowing Operator CType(operand As type) As returntype
instructions
End Operator
Shared Widening Operator CType(operand As type) As returntype
instructions
End Operator
PHP
Perl
Rakumulti method type«($self:)» is export { instructions }
Ruby
Windows PowerShell
OCaml
F#
COBOL

Member access

How to access members of an object x

object memberclass membernamespace member
methodfieldproperty
ABAP Objectsx->methodparameters»). [41] x->fieldx=>field or x=>methodparameters [41] »).
C++x.method(parameters) or
ptr->method(parameters)
x.field or
ptr->field
cls::memberns::member
Objective-C[x method«:parameter «bar:parameter ...»»]x->fieldx.property (2.0 only) or
[x property]
[cls method«:parameter «bar:parameter ...»»]
Smalltalkx method«:parameter «bar:parameter ...»»cls method«:parameter «bar:parameter ...»»
Swiftx.method(parameters)x.propertycls.member
APL (Dyalog)left argument» x.method «right argument(s)»x.fieldx.propertycls.memberns.member
C#x.method(parameters)
Java
Dx.property
Python
Visual Basic .NET
Xojo
Windows PowerShell[cls]::member
F#cls.member
eCx.method«(parameters)»x.fieldx.propertycls::memberns::member
Eiffelx.method«(parameters)»x.field{cls}.member
Rubyx.propertycls.member
PHPx->method(parameters)x->fieldx->propertycls::memberns\member
Perlx->method«(parameters)»x->{field}cls->method«(parameters)»ns::member
Rakux.method«(parameters)» or
x!method«(parameters)»
x.field or
x!field
cls.method«(parameters)» or
cls!method«(parameters)»
ns::member
OCamlx#method «parameters»
JavaScriptx.method(parameters)
x["method"](parameters)
x.field
x["field"]
x.property
x["property"]
cls.member
cls["member"]
COBOLINVOKE x"method" «USING parameters» «RETURNING result» or
x::"method"«(«parameters»)»
property OF xINVOKE cls "method" «USING parameters» «RETURNING result» or
cls::"method"«(«parameters»)» or
property OF cls
Cobrax.method«(parameters)»x.fieldx.propertycls.memberns.member

Member availability

Has member?Handler for missing member
MethodFieldMethodField
APL (Dyalog)3=x.⎕NC'method'2=x.⎕NC'method'
ABAP Objects
C++
Objective-C (Cocoa)[x respondsToSelector:@selector(method)]forwardInvocation:
Smalltalkx respondsTo: selectordoesNotUnderstand:
C#(using reflection)
eC
Java
DopDispatch()
Eiffel
Pythonhasattr(x, "method") and callable(x.method)hasattr(x, "field")__getattr__()
Visual Basic .NET(using reflection)
Xojo(using Introspection)
Windows PowerShell(using reflection)
F#(using reflection)
Rubyx.respond_to?(:method)method_missing()
PHPmethod_exists(x, "method")property_exists(x, "field")__call()__get() / __set()
Perlx->can("method")exists x->{field}AUTOLOAD
Rakux.can("method")x.field.definedAUTOLOAD
OCaml
JavaScript typeof x.method === "function"field in x
COBOL

Special variables

current object current object's parent object null reference Current Context of Execution
SmalltalkselfsupernilthisContext
ABAP Objectsmesuperinitial
APL (Dyalog)⎕THIS⎕BASE⎕NULL
C++*this [42] NULL, nullptr
C#thisbase [43] null
Javasuper [43]
D
JavaScriptsuper [43] (ECMAScript 6)null, undefined [44]
eCthisnull
Objective-Cselfsuper [43] nil
Swiftselfsuper [43] nil [45]
Pythonself [46] super(current_class_name, self) [7]
super() (3.x only)
None
Visual Basic .NETMeMyBaseNothing
XojoMe / SelfParentNil
EiffelCurrentPrecursor «{superclass}» «(args)» [43] [47] Void
PHP$thisparent [43] null
Perl$self [46] $self->SUPER [43] undef
RakuselfSUPERNil
Rubyselfsuper«(args)» [48] nilbinding
Windows PowerShell$this$NULL
OCamlself [49] super [50] [51]
F#thisbase [43] null
COBOLSELFSUPERNULL
Cobrathisbasenil

Special methods

String representation Object copy Value equalityObject comparisonHash codeObject ID
Human-readableSource-compatible
ABAP Objects
APL (Dyalog)x⎕SRC x⎕NS xx = y
C++x == y [52] pointer to object can be converted into an integer ID
C#x.ToString()x.Clone()x.Equals(y)x.CompareTo(y)x.GetHashCode()System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(x)
Javax.toString()x.clone() [53] x.equals(y)x.compareTo(y) [54] x.hashCode()System.identityHashCode(x)
JavaScriptx.toString()
Dx.toString() or
std.conv.to!string(x)
x.stringofx == y or
x.opEquals(y)
x.opCmp(y)x.toHash()
eCx.OnGetString(tempString, null, null) or
PrintString(x)
y.OnCopy(x)x.OnCompare(y)object handle can be converted into an integer ID
Objective-C (Cocoa)x.descriptionx.debugDescription[x copy] [55] [x isEqual:y][x compare:y] [56] x.hashpointer to object can be converted into an integer ID
Swiftx.description [57] x.debugDescription [58] x == y [59] x < y [60] x.hashValue [61] reflect(x).objectIdentifier!.uintValue()
Smalltalkx displayStringx printStringx copyx = yx hashx identityHash
Pythonstr(x) [62] repr(x) [63] copy.copy(x) [64] x == y [65] cmp(x, y) [66] hash(x) [67] id(x)
Visual Basic .NETx.ToString()x.Clone()x.Equals(y)x.CompareTo(y)x.GetHashCode()
Eiffelx.outx.twinx.is_equal(y)When x is COMPARABLE, one can simply do x < yWhen x is HASHABLE, one can use x.hash_codeWhen x is IDENTIFIED, one can use x.object_id
PHP$x->__toString()clone x [68] x == yspl_object_hash(x)
Perl"$x" [69] Data::Dumper->Dump([$x],['x']) [70] Storable::dclone($x) [71] Scalar::Util::refaddr( $x ) [72]
Raku~x [69] x.perlx.clonex eqv yx cmp yx.WHICH
Rubyx.to_sx.inspectx.dup or
x.clone
x == y or
x.eql?(y)
x <=> yx.hashx.object_id
Windows PowerShellx.ToString()x.Clone()x.Equals(y)x.CompareTo(y)x.GetHashCode()
OCamlOo.copy xx = yHashtbl.hash xOo.id x
F#string x or x.ToString() or sprintf "%O" xsprintf "%A" xx.Clone()x = y or x.Equals(y)compare x y or x.CompareTo(y)hash x or x.GetHashCode()
COBOL

Type manipulation

Get object typeIs instance of (includes subtypes)Upcasting Downcasting
Runtime checkNo check
ABAP Objects [73] = ?=
C++ typeid(x) dynamic_cast<type *>(&x) != nullptr [74] dynamic_cast<type*>(ptr)(type*) ptr or
static_cast<type*>(ptr)
C#x.GetType()x is type(type) x or x as type
Dtypeid(x)cast(type) x
Delphix is typex as type
eCx._classeClass_IsDerived(x._class, type)(type) x
Javax.getClass()x instanceof class(type) x
Objective-C (Cocoa)[x class] [75] [x isKindOfClass:[class class]](type*) x
Swiftx.dynamicTypex is typex as! type
x as? type
JavaScriptx.constructor(If not rewritten.)x instanceof class [76]
Visual Basic .NETx.GetType() TypeOf x Is type [74] CType(x, type) or TryCast(x, type)
XojoIntrospection.GetType(x)x IsA typeCType(x, type)
Eiffelx.generating_typeattached {TYPE} xattached {TYPE} x as down_x
Pythontype(x)isinstance(x, type) [76]
PHPget_class(x)x instanceof class
Perlref(x)x->isa("class")
Rakux.WHATx.isa(class) [74] type(x) or
x.type
Rubyx.classx.instance_of?(type) or
x.kind_of?(type)
[76]
Smalltalkx classx isKindOf: class
Windows PowerShellx.GetType()x -is [type] [74] [type]x or x -as [type]
OCaml [77] (x :> type)
F#x.GetType()x :? type(x :?> type)
COBOLx AS type [74]

Namespace management

Import namespaceImport item
qualifiedunqualified
ABAP Objects
C++using namespace ns;using ns::item ;
C#using ns;using item = ns.item;
Dimport ns;import ns : item;
Javaimport ns.*;import ns.item;
Objective-C
Visual Basic .NETImports ns
Eiffel
Pythonimport nsfrom ns import *from ns import item
PHPuse ns;use ns\item;
Perluse ns;use ns qw(item);
Raku
Ruby
Windows PowerShell
OCamlopen ns
F#
COBOL

Contracts

PreconditionPostconditionCheckInvariantLoop
ABAP Objects
C++
C#Spec#:
type foo( «parameters» )
    requires expression
{
    body
}
Spec#:
type foo( «parameters» )
    ensures expression
{
    body
}
Java
Objective-C
Visual Basic .NET
Df
in { asserts }
body{
instructions }
f
out (result) { asserts }
body{
instructions }
assert(expression)invariant() { expression }
Eiffelf
require tag: expression
do end
f
do
ensure
tag: expression
end
f
do
check tag: expression end
end
class X
invariant tag: expression
end
from instructions
invariant
tag: expression
until
expr
loop
instructions
variant
tag: expression
end
Python
PHP
Perl
RakuPRE { condition }POST { condition }
Ruby
Windows PowerShell
OCaml
F#
COBOL

See also

References and notes

  1. parameter = argument may be repeated if the constructor has several parameters
  2. SAP reserved to himself the use of destruction
  3. 1 2 3 4 5 6 7 8 9 10 11 12 This language uses garbage collection to release unused memory.
  4. This syntax creates an object value with automatic storage duration
  5. This syntax creates an object with dynamic storage duration and returns a pointer to it
  6. OCaml objects can be created directly without going through a class.
  7. 1 2 3 4 5 6 7 This language supports multiple inheritance. A class can have more than one parent class
  8. Not providing a parent class makes the class a root class. In practice, this is almost never done. One should generally use the conventional base class of the framework one is using, which is NSObject for Cocoa and GNUstep, or Object otherwise.
  9. Usually the @interface portion is placed into a header file, and the @interface portion is placed into a separate source code file.
  10. Prefixes to class and protocol names conventionally used as a kind of namespace
  11. In Python interfaces are classes which methods have pass as their bodies
  12. The class is an Object.
    Just send a message to the superclass (st-80) or the destination namespace (Visualworks).
  13. The namespace is an Object.
    Just send a message to the parent namespace.
  14. A finalizer is called by the garbage collector when an object is about to be garbage-collected. There is no guarantee on when it will be called or if it will be called at all.
  15. In ABAP, the constructor is to be defined like a method (see comments about method) with the following restrictions: the method name must be "constructor", and only "importing" parameters can be defined
  16. An optional comma-separated list of initializers for member objects and parent classes goes here. The syntax for initializing member objects is
    "member_name(parameters)"
    This works even for primitive members, in which case one parameter is specified and that value is copied into the member. The syntax for initializing parent classes is
    "class_name(parameters)".
    If an initializer is not specified for a member or parent class, then the default constructor is used.
  17. Any Eiffel procedure can be used as a creation procedure, aka constructors. See Eiffel paragraph at Constructor (computer science).
  18. Implementing {DISPOSABLE}.dispose ensures that dispose will be called when object is garbage collected.
  19. This "initializer" construct is rarely used. Fields in OCaml are usually initialized directly in their declaration. Only when additional imperative operations are needed is "initializer" used. The "parameters to the constructor" in other languages are instead specified as the parameters to the class in OCaml. See the class declaration syntax for more details.
  20. This syntax is usually used to overload constructors
  21. In JavaScript, constructor is an object.
  22. Constructors can be emulated with a factory method returning a class instance.
  23. 1 2 3 Scope identifier must appear once in the file declaration, all variable declarations after this scope identifier have his scope, until another scope identifier or the end of class declaration is reached
  24. In ABAP, specific fields or methods are not declared as accessible by outside things. Rather, outside classes are declared as friends to have access to the class's fields or methods.
  25. In C++, specific fields are not declared as accessible by outside things. Rather, outside functions and classes are declared as friends to have access to the class's fields. See friend function and friend class for more details.
  26. Just send a message to the class
    classaddInstVarName:field.classremoveInstVarName:field.
  27. 1 2 3 4 Just assign a value to it in a method
  28. Python doesn't have private fields - all fields are publicly accessible at all times. A community convention exists to prefix implementation details with one underscore, but this is unenforced by the language.
  29. All class data is 'private' because the COBOL standard does not specify any way to access it.
  30. The declaration and implementation of methods in ABAP are separate. methods statement is to be used inside the class definition. method (without "s") is to be used inside the class implementation. parameter = argument can be repeated if there are several parameters.
  31. In ABAP, the return parameter name is explicitly defined in the method signature within the class definition
  32. In C++, declaring and implementing methods is usually separate. Methods are declared in the class definition (which is usually included in a header file) using the syntax
  33. Although the body of a method can be included with the declaration inside the class definition, as shown in the table here, this is generally bad practice. Because the class definition must be included with every source file which uses the fields or methods of the class, having code in the class definition causes the method code to be compiled with every source file, increasing the size of the code. Yet, in some circumstances, it is useful to include the body of a method with the declaration. One reason is that the compiler will try to inline methods that are included in the class declaration; so if a very short one-line method occurs, it may make it faster to allow a compiler to inline it, by including the body along with the declaration. Also, if a template class or method occurs, then all the code must be included with the declaration, because only with the code can the template be instantiated.
  34. 1 2 Just assign a function to it in a method
  35. Alternative implementation:
    defbar():doc="The bar property."deffget(self):returnself._bardeffset(self,value):self._bar=valuereturnlocals()bar=property(**bar())
  36. these examples need the Class::Accessor module installed
  37. 1 2 3 Although Eiffel does not support overloading of operators, it can define operators
  38. PHP does not support operator overloading natively, but support can be added using the "operator" PECL package.
  39. The class must implement the ArrayAccess interface.
  40. The class must overload '@{}' (array dereference) or subclass one of Tie::Array or Tie::StdArray to hook array operations
  41. 1 2 In ABAP, arguments must be passed using this syntax:
    x->method(«exporting parameter = argument» «importing parameter = argument» «changing parameter = argument» «returning value(parameter)»
    parameter = argument can be repeated if there are several parameters
  42. C++ doesn't have a "super" keyword, because multiple inheritance is possible, and so it may be ambiguous which base class is referenced. Instead, the BaseClassName::member syntax can be used to access an overridden member in the specified base class. Microsoft Visual C++ provides a non-standard keyword "__super" for this purpose; but this is unsupported in other compilers.
  43. 1 2 3 4 5 6 7 8 9 The keyword here is not a value, and it can only be used to access a method of the superclass.
  44. But be afraid, they have not the same value.
  45. only for Optional types
  46. 1 2 In this language, instance methods are passed the current object as the first parameter, which is conventionally named "self", but this is not required to be the case.
  47. "Precursor" in Eiffel is actually a call to the method of the same name in the superclass. So Precursor(args) is equivalent to "super.currentMethodName(args)" in Java. There is no way of calling a method of different name in the superclass.
  48. "super" in Ruby, unlike in other languages, is actually a call to the method of the same name in the superclass. So super(args) in Ruby is equivalent to "super.currentMethodName(args)" in Java. There is no way of calling a method of different name in the superclass.
  49. In OCaml, an object declaration can optionally start with a parameter which will be associated with the current object. This parameter is conventionally named "self", but this is not required to be the case. It is good practice to put a parameter there so that one can call one's own methods.
  50. In OCaml, an inheritance declaration ("inherit") can optionally be associated with a value, with the syntax "inherit parent_class «parameters» as super". Here "super" is the name given to the variable associated with this parent object. It can be named differently.
  51. However, if the ability to have an "optional" value in OCaml is needed, then wrap the value inside an option type, which values are None and Some x, which could be used to represent "null reference" and "non-null reference to an object" as in other languages.
  52. assuming that "x" and "y" are the objects (and not pointers). Can be customized by overloading the object's == operator
  53. Only accessible from within the class, since the clone() method inherited from Object is protected, unless the class overrides the method and makes it public. If using the clone() inherited from Object, the class must implement the Cloneable interface to allow cloning.
  54. The class should implement the interface Comparable for this method to be standardized.
  55. Implemented by the object's copyWithZone: method
  56. compare: is the conventional name for the comparison method in Foundation classes. However, no formal protocol exists
  57. Only if object conforms to the Printable protocol
  58. Only if object conforms to the DebugPrintable protocol
  59. Only if object conforms to the Equatable protocol
  60. Only if object conforms to the Comparable protocol
  61. Only if object conforms to the hashValue protocol
  62. Can be customized by the object's __str__() method
  63. Can be customized by the object's __repr__() method
  64. Can be customized by the object's __copy__() method
  65. Can be customized by the object's __eq__() method
  66. Only in Python 2.x and before (removed in Python 3.0). Can be customized by the object's __cmp__() method
  67. Can be customized by the object's __hash__() method. Not all types are hashable (mutable types are usually not hashable)
  68. Can be customized by the object's __clone() method
  69. 1 2 Can be customized by overloading the object's string conversion operator
  70. This example requires useing Data::Dumper
  71. This example requires useing Storable
  72. This example requires useing Scalar::Util
  73. Run-time type information in ABAP can be gathered by using different description Classes like CL_ABAP_CLASSDESCR.
  74. 1 2 3 4 5 Upcasting is implicit in this language. A subtype instance can be used where a supertype is needed.
  75. Only for non-class objects. If x is a class object, [x class] returns only x. The runtime method object_getClass(x) will return the class of x for all objects.
  76. 1 2 3 This language is dynamically typed. Casting between types is unneeded.
  77. This language doesn't give run-time type information. It is unneeded because it is statically typed and downcasting is impossible.

Related Research Articles

Multiple inheritance is a feature of some object-oriented computer programming languages in which an object or class can inherit features from more than one parent object or parent class. It is distinct from single inheritance, where an object or class may only inherit from one particular object or class.

A method in object-oriented programming (OOP) is a procedure associated with an object, and generally also a message. An object consists of state data and behavior; these compose an interface, which specifies how the object may be used. A method is a behavior of an object parametrized by a user.

ABAP is a high-level programming language created by the German software company SAP SE. It is currently positioned, alongside Java, as the language for programming the SAP NetWeaver Application Server, which is part of the SAP NetWeaver platform for building business applications.

In object-oriented programming such as is often used in C++ and Object Pascal, a virtual function or virtual method is an inheritable and overridable function or method that is dispatched dynamically. Virtual functions are an important part of (runtime) polymorphism in object-oriented programming (OOP). They allow for the execution of target functions that were not precisely identified at compile time.

In some programming languages, function overloading or method overloading is the ability to create multiple functions of the same name with different implementations. Calls to an overloaded function will run a specific implementation of that function appropriate to the context of the call, allowing one function call to perform different tasks depending on context.

In computer programming, a function object is a construct allowing an object to be invoked or called as if it were an ordinary function, usually with the same syntax. In some languages, particularly C++, function objects are often called functors.

This article compares two programming languages: C# with Java. While the focus of this article is mainly the languages and their features, such a comparison will necessarily also consider some features of platforms and libraries. For a more detailed comparison of the platforms, see Comparison of the Java and .NET platforms.

In compiler construction, name mangling is a technique used to solve various problems caused by the need to resolve unique names for programming entities in many modern programming languages.

In class-based, object-oriented programming, a constructor is a special type of function called to create an object. It prepares the new object for use, often accepting arguments that the constructor uses to set required member variables.

<span class="mw-page-title-main">Java syntax</span> Set of rules defining correctly structured program

The syntax of Java is the set of rules defining how a Java program is written and interpreted.

Many programming language type systems support subtyping. For instance, if the type Cat is a subtype of Animal, then an expression of type Cat should be substitutable wherever an expression of type Animal is used.

<span class="mw-page-title-main">Factory (object-oriented programming)</span> Object that creates other objects

In object-oriented programming, a factory is an object for creating other objects; formally, it is a function or method that returns objects of a varying prototype or class from some method call, which is assumed to be "new". More broadly, a subroutine that returns a "new" object may be referred to as a "factory", as in factory method or factory function. The factory pattern is the basis for a number of related software design patterns.

Metadata, in the Common Language Infrastructure (CLI), refers to certain data structures embedded within the Common Intermediate Language (CIL) code that describes the high-level structure of the code. Metadata describes all classes and class members that are defined in the assembly, and the classes and class members that the current assembly will call from another assembly. The metadata for a method contains the complete description of the method, including the class, the return type and all of the method parameters.

In computer science, a type class is a type system construct that supports ad hoc polymorphism. This is achieved by adding constraints to type variables in parametrically polymorphic types. Such a constraint typically involves a type class T and a type variable a, and means that a can only be instantiated to a type whose members support the overloaded operations associated with T.


A class in C++ is a user-defined type or data structure declared with any of the keywords class, struct or union that has data and functions as its members whose access is governed by the three access specifiers private, protected or public. By default access to members of a C++ class declared with the keyword class is private. The private members are not accessible outside the class; they can be accessed only through member functions of the class. The public members form an interface to the class and are accessible outside the class.

<span class="mw-page-title-main">Oxygene (programming language)</span> Object Pascal-based programming language

Oxygene is a programming language developed by RemObjects Software for Microsoft's Common Language Infrastructure, the Java Platform and Cocoa. Oxygene is based on Delphi's Object Pascal, but also has influences from C#, Eiffel, Java, F# and other languages.

PeopleCode is a proprietary object-oriented programming language used to express business logic for PeopleSoft applications. Syntactically, PeopleCode is similar to other programming languages, and can be found in both loosely-typed and strongly-typed forms. PeopleCode and its run-time environment is part of the larger PeopleTools framework. PeopleCode has evolved over time and its implementation through the PeopleSoft applications lack consistency. PeopleCode offers some interoperability with the Java programming language. Definition name references, for example, enable you to refer to PeopleTools definitions, such as record definitions or pages, without using hard-coded string literals. Other language features, such as PeopleCode data types and metastrings, reflect the close interaction of PeopleTools and Structured Query Language (SQL). Dot notation, classes and methods in PeopleCode are similar to other object oriented languages, like Java. Object syntax was an important feature of PeopleTools 8.

This article describes the syntax of the C# programming language. The features described are compatible with .NET Framework and Mono.

Objective-C is a high-level general-purpose, object-oriented programming language that adds Smalltalk-style messaging to the C programming language. Originally developed by Brad Cox and Tom Love in the early 1980s, it was selected by NeXT for its NeXTSTEP operating system. Due to Apple macOS’s direct lineage from NeXTSTEP, Objective-C was the standard programming language used, supported, and promoted by Apple for developing macOS and iOS applications until the introduction of the Swift programming language in 2014.