Comparison of programming languages (object-oriented programming)

| data variable type ref to class .
create object variable «exporting parameter = argument».parameter = argument may be repeated if the constructor has several parameters

|SAP reserved to himself the use of destructionThis language uses garbage collection to release unused memory.

| variable←⎕NEW class «parameters»

| ⎕EX 'variable'

| class variable«(parameters)»;This syntax creates an object value with automatic storage duration or
class *variable = new class«(parameters)»;This syntax creates an object with dynamic storage duration and returns a pointer to it

| delete pointer;

| rowspan=3|class variable = new class(parameters);

| variable.Dispose();

|

| destroy(variable);

| class «instance handle» { «properties/data members assignments, instance method overrides» }

| delete instance handle;

| class *variable = *variable = [[class alloc ] initWithFoo:parameter «bar:parameter ...»];

| [variable release];

| let variable = class(parameters)

|

| variable = class(parameters)

| del variable (Normally not needed)

| Dim variable As New class(parameters)

| variable.Dispose()

| Dim variable As New class(parameters)

| variable = Nil

| create variable or
create «{TYPE}» variable.make_foo «(parameters)» or
variable := create {TYPE} or
variable := create {TYPE}.make_foo «(parameters)»

|

| $variable = new class«(parameters)»;

| unset($variable);

| «my »$variable = class->new«(parameters)»;

| undef($variable);

| «my »$variable = class.new«(parameters)»;

| $variable.undefine;

| variable = class.new«(parameters)»

|

| $variable = New-Object «-TypeName» class ««-ArgumentList» parameters»

| Remove-Variable «-Name» variable

| let variable = new class «parameters» or
let variable = object members endOCaml objects can be created directly without going through a class.

| rowspan=2|

| let variable = «new »class(«parameters»)

| The class is an Object.
Just send a message to a class, usually #new or #new:, and many others, for example:

Point x: 10 y: 20.

Array with: -1 with: 3 with: 2.

|

| var variable = new class«(parameters)» or
var variable = { «key1: value1«, key2: value2 ...»»}

|

| ClassVar := ClassType.ConstructorName(parameters);

| ClassVar.Free;

|

val obj = new Object // no parameters

val obj = new Object(arg0, arg1, arg2...)

val obj = Object(arg0, arg1, arg2...) // case class

val obj = new Object(arg0, arg1, param1 = value1, ...) // named parameters

|

| INVOKE class "NEW" RETURNING variable or
MOVE class::"NEW" TO variable

|

| variable «as class» = class(parameters)

| variable.dispose

| (setq variable (create (class [:field-1 value-1 [:field-2 value-2] ..])))

|

| class name definition «inheriting from parentclass». «interfaces: interfaces.» method_and_field_declarations endclass.
class name implementation. method_implementations endclass.

| interface name. members endinterface.

| {{n/a}}

| :Class name «:parentclass» «,interfaces»
members
:EndClass

| :Interface name
members
:EndInterface

| :Namespace name
members
:EndNamespace

| class name« : public parentclassesThis language supports multiple inheritance. A class can have more than one parent class» { members };

|

| rowspan=2| namespace name { members }

| rowspan=2| class name« : «parentclass»«, interfaces»» { members }

| rowspan=2| interface name« : parentinterfaces» { members }

| module name;
members

| class name« : base class» { «default member values assignments» «members» }

|

| namespace name;

| rowspan=2| class name« extends parentclass»« implements interfaces» { members }

| rowspan=2| interface name« extends parentinterfaces» { members }

| package name; members

| namespace name; members

| @interface name« : parentclass»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.«< protocols >» { instance_fields } method_and_property_declarations @end
@implementation name method_implementations @endUsually the @interface portion is placed into a header file, and the @interface portion is placed into a separate source code file.

| @protocol name«< parentprotocols >» members @end

| {{n/a|Prefixes to class and protocol names conventionally used as a kind of namespace}}

| class name« : «parentclass»«, protocols»» { members }

| protocol name« : parentprotocols» { members }

|

| class name«(parentclasses)»:
{{keypress|Tab}} members

|In Python interfaces are classes which methods have pass as their bodies

| __all__ = [ member1,member2,... ]

| Class name« Inherits parentclass»« Implements interfaces»
members
End Class

| Interface name« Inherits parentinterfaces»
members
End Interface

| Namespace name
members
End Namespace

| Class name« Inherits parentclass»« Implements interfaces»
members
End Class

| Interface name« Inherits parentinterfaces»
members
End Interface

| Module name
members
End Module

| class name« inherit parentclasses»
members
end

| colspan=2 {{n/a}}

| package name; «@ISA = qw(parentclasses);» members 1;

|

| package name; members

| class name «is parentclass «is parentclass ...»» «does role «does role ...»» { members }

| role name «does role «does role ...»» { members }

| module name { members }

| class name« < parentclass»
members
end

|

| module name
members
end

| colspan=3 {{n/a}}

| class name «parameters» = object «(self)» «inherit parentclass «parameters» «inherit parentclass «parameters» ...»» members end

|

| module name
members

| type name«(parameters)» «as this» = class «inherit parentclass«(parameters)» «as base»» members «interface interface with implementation «interface interface with implementation ...»» end

| type name = interface members end

| namespace name
members

|The class is an Object.
Just send a message to the superclass (st-80) or the destination namespace (Visualworks).

|

|The namespace is an Object.
Just send a message to the parent namespace.

|class name «extends parentclass» { members }

|

|

| ClassName = Class «(ClassParent, Interfaces)»

end;

|

| package name; members

|

class ConcreteClass(constructor params)

extends ParentClass

with Trait1 with Trait2 with Trait2 {

// members

}

|

trait TraitName

extends OtherTrait1

with OtherTrait2 with OtherTrait3 {

// members

}

|

package name

| CLASS-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.

| {{n/a}}

| class name «inherits parentclass» «implements interfaces»
{{keypress|Tab}} members

| interface name «inherits parentinterfaces»
{{keypress|Tab}} members

| namespace name
{{keypress|Tab}} members

| (defclass name (base-class) ((x :initform 0 :accessor get-x :initarg x)) (:abstractp nil))

|

|

| methods constructor «importing parameter = argument»
method constructor. instructions endmethod.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

| colspan=2 {{n/a}}

| ∇ name
:Implements Constructor «:Base «expr»»
instructions
∇

|

| ∇ name
:Implements Destructor
instructions
∇

| class(«parameters») «: initializersAn 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.» { instructions }

| ~class() { instructions }

|

| class(«parameters») { instructions }

| void Dispose(){ instructions }

| ~class() { instructions }

| this(«parameters») { instructions }

|

| ~this() { instructions }

| class() { instructions }

| ~class() { instructions }

|

| class(«parameters») { instructions }

|

| void finalize() { instructions }

|Any Eiffel procedure can be used as a creation procedure, aka constructors. See Eiffel paragraph at Constructor (computer science).

|

|Implementing {DISPOSABLE}.dispose ensures that dispose will be called when object is garbage collected.

| - (id)init { instructions... return self; } or
- (id)initWithFoo:parameter «bar:parameter ...» { instructions... return self; }

| - (void)dealloc { instructions }

| - (void)finalize { instructions }

| init(«parameters») { instructions }

| deinit { instructions }

|

| def __init__(self«, parameters»):
{{keypress|Tab}} instructions

|

| def __del__(self):
{{keypress|Tab}} instructions

| Sub New(«parameters»)
instructions
End Sub

| Sub Dispose()
instructions
End Sub

| Overrides Sub Finalize()
instructions
End Sub

| Sub Constructor(«parameters»)
instructions
End Sub

| Sub Destructor()
instructions
End Sub

|

| function __construct(«parameters») { instructions }

| function __destruct() { instructions }

|

| sub new { my ($class«, parameters») = @_; my $self = {}; instructions ... bless($self, $class); return $self; }

| sub DESTROY { my ($self) = @_; instructions }

|

| submethod BUILD { instructions } or
«multi » method new(««$self: »parameters») { self.bless(*, field1 => value1, ...); ... instructions }

| submethod DESTROY { instructions }

|

| def initialize«(parameters)»
instructions
end

| colspan=2 {{n/a}}

| colspan=3 {{n/a}}

| initializer instructionsThis "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.

| colspan=2 {{n/a}}

| do instructions or
new(parameters) = expressionThis syntax is usually used to overload constructors

| member this.Dispose() = instructions

| override this.Finalize() = instructions

| function name(«parameters») { instructions }In JavaScript, constructor is an object.

| colspan=2 {{n/a}}

|constructor(«parameters») { instructions }

| {{n/a}}Constructors can be emulated with a factory method returning a class instance.

| colspan=2 {{n/a}}

| cue init(parameters)
{{keypress|Tab}} base.init
{{keypress|Tab}} instructions

| def dispose
{{keypress|Tab}} instructions

|

| (defmethod initialize-object ((instance ) initvalues)

| public section.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 data field type type.

| private section. data field type type.

| protected section. data field type type.

|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.

| :Field Public field «← value»

| :Field «Private» field «← value»

|

|

| public: type field;

| private: type field;

| protected: type field;

|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.

| rowspan=3| public type field «= value»;

| rowspan=3| private type field «= value»;

| protected type field «= value»;

| internal type field «= value»;

|

| package type field «= value»;

| protected type field «= value»;

| type field «= value»;

| public type field;

| private type field;

| feature
field: TYPE

| feature {NONE}
field: TYPE

| feature {current_class}
field: TYPE

| feature {FRIEND}
field: TYPE

| @public type field;

| @private type field;

| @protected type field;

| @package type field;

| colspan=4 {{n/a}}

| colspan=2 {{n/a}}

|Just send a message to the class

class addInstVarName: field.

class removeInstVarName: field.

| {{n/a}}

| self.field = valueJust assign a value to it in a method

| {{n/a}}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.

| colspan=2 {{n/a}}

| Visual Basic .NET

| Public field As type «= value»

| Private field As type «= value»

| Protected field As type «= value»

| Friend field As type «= value»

| Xojo

| Public field As type «= value»

| Private field As type «= value»

| Protected field As type «= value»

| {{n/a}}

| public $field «= value»;

| private $field «= value»;

| protected $field «= value»;

|

| $self->{field} = value;

| colspan=3 {{n/a}}

| has« type »$.field« is rw»

| has« type »$!field

| colspan=2 {{n/a}}

| colspan=2 {{n/a}}

| @field = value

|

| Add-Member
«-MemberType »NoteProperty
«-Name »Bar «-Value »value
-InputObject variable

| colspan=3 {{n/a}}

| colspan=2 {{n/a}}

| val «mutable» field = value

| rowspan=2 {{n/a}}

| {{n/a}}

| let «mutable» field = value

| {{n/a}}

| this.field = value
this["field"] = value

|

|

|

| {{n/a}}

| level-number field clauses.All class data is 'private' because the COBOL standard does not specify any way to access it.

| {{n/a}}

| {{n/a}}

| var field «as type» «= value»

| var __field «as type» «= value»

| var _field «as type» «= value»

|

| (field :initform value :accessor accessor-name :initarg keyword)

|

|

|

!

! basic/void method

! value-returning method

| ABAP Objects

| methods name «importing parameter = argument» «exporting parameter = argument» «changing parameter = argument» «returning value(parameter)»
method name. instructions endmethod.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.

|In ABAP, the return parameter name is explicitly defined in the method signature within the class definition

| APL (Dyalog)

| ∇ «left argument» name «right arguments»
instructions
∇

| ∇ result ← «left argument» name «right arguments»
instructions
∇

| C++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

: type foo(«parameters»);

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

: type class::foo(«parameters») { instructions }

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.

| rowspan=4| void foo(«parameters») { instructions }

| rowspan=4| type foo(«parameters») { instructions ... return value; }

| C#

| D

| Java

| eC

| void ««type of 'this'»::»foo(«parameters») { instructions }

| type ««type of this»::»foo(«parameters») { instructions ... return value; }

| Eiffel

| foo ( «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; }

| Swift

| func foo(«parameters») { instructions }

| func foo(«parameters») -> type { instructions... return value }

| Python

| def foo(self«, parameters»):
{{keypress|Tab}} instructions

| def foo(self«, parameters»):
{{keypress|Tab}} instructions
{{keypress|Tab}} return value

| Visual Basic .NET

| Sub Foo(«parameters»)
instructions
End Sub

| Function Foo(«parameters») As type
instructions
...
Return value
End Function

| Xojo

| Sub Foo(«parameters»)
instructions
End Sub

| Function Foo(«parameters») As type
instructions
...
Return value
End Function

| PHP

| function foo(«parameters»)«: void» { instructions }

| function foo(«parameters»)«: type» { instructions ... return value; }

| Perl

| sub 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; }

| Ruby

| def foo«(parameters)»
instructions
end

| def foo«(parameters)»
instructions
expression resulting in return value
end
or
def foo«(parameters)»
instructions
return value
end

| Windows PowerShell

| Add-Member «-MemberType» ScriptMethod «-Name» foo «-Value» { «param(parameters)» instructions } -InputObject variable

| Add-Member «-MemberType» ScriptMethod «-Name» foo «-Value» { «param(parameters)» instructions ... return value } -InputObject variable

| OCaml

| rowspan=2 {{n/a}}

| method foo «parameters» = expression

| F#

| member this.foo(«parameters») = expression

| JavaScript

| this.method = function(«parameters») {instructions}
name«.prototype.method = function(«parameters») {instructions}Just assign a function to it in a method

| this.method = function(«parameters») {instructions... return value;}
name«.prototype.method = function(«parameters») {instructions... return value;}

|foo(«parameters») {instructions}

|foo(«parameters») {instructions... return value;}

| COBOL

| METHOD-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.

| def foo(parameters)
{{keypress|Tab}} instructions

| def foo(parameters) as type
{{keypress|Tab}} instructions
{{keypress|Tab}} return value

|

| (defgeneric method (arg1 arg2))
(defmethod method ((arg1 arg2 ) ...)

|

!

! read-write

! read-only

! write-only

| ABAP Objects

| colspan=3 {{n/a}}

| 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++

| colspan=3 {{n/a}}

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

| eC

| property type Bar {
get { instructions ... return value; }
set { instructions } }

| property type Bar { get { instructions ... return value; } }

| property type Bar { set { instructions } }

| Java

| colspan=3 {{n/a}}

| 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 }

| {{n/a}}

| Swift

| var bar : type { get { instructions } set«(newBar)» { instructions } }

| var bar : type { instructions }

| {{n/a}}

| Eiffel

| feature -- Access
x: TYPE assign set_x
feature -- Settings
set_x (a_x: like x) do instructions ensure x_set: verification end

|

|

| Python

| def setBar(self, value):
{{keypress|Tab}} instructions
def getBar(self):
{{keypress|Tab}} instructions
{{keypress|Tab}} return value
bar = property(getBar, setBar)Alternative implementation:

def bar():

doc = "The bar property."

def fget(self):

return self._bar

def fset(self, value):

self._bar = value

return locals()

bar = property(**bar())

| def getBar(self):
{{keypress|Tab}} instructions
{{keypress|Tab}} return value
bar = property(getBar)

| def setBar(self, value):
{{keypress|Tab}} instructions
bar = property(fset = setBar)

| Visual Basic .NET

| Property 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

| Xojo

| ComputedProperty 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

| PHP

| function __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
} }

| Perl

| sub 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

| colspan=3 {{n/a}}

| Ruby

| def 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 PowerShell

| Add-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

| colspan=3 {{n/a}}

| F#

| member this.Bar with get() = expression and set(value) = expression

| member this.Bar = expression

| member this.Bar with set(value) = expression

|get bar(«parameters») { instructions ... return value}set bar(«parameters») { instructions }

|get bar(«parameters») { instructions ... return value}

|set bar(«parameters») { instructions }

| COBOL

| 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.

| 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.

| pro bar «as type»
{{keypress|Tab}} get
{{keypress|Tab}}{{keypress|Tab}} instructions
{{keypress|Tab}}{{keypress|Tab}} return value
{{keypress|Tab}} set
{{keypress|Tab}}{{keypress|Tab}} instructions

| get bar «as type»
{{keypress|Tab}} instructions
{{keypress|Tab}} return value

| set bar «as type»
{{keypress|Tab}} instructions

| ISLISP

| colspan=3 {{n/a}}

!

! read-write

! read-only

! write-only

| ABAP Objects

| colspan=3 {{n/a}}

| C++

| colspan=3 {{n/a}}

| C#

| type Bar { get; set; }

| type Bar { get; private set; }

| type Bar { private get; set; }

| D

| colspan=3 {{n/a}}

| Java

| colspan=3 {{n/a}}

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

| {{n/a}}

| Swift

| var bar : type

| let bar : type

| {{n/a}}

| Eiffel

|

|

|

| Python

| @property
def bar(self):
{{keypress|Tab}}instructions
@bar.setter
def bar(self, value):
{{keypress|Tab}}instructions

| @property
def bar(self):
{{keypress|Tab}}instructions

| bar = property()
@bar.setter
def bar(self, value):
{{keypress|Tab}}instructions

| Visual Basic .NET

| Property Bar As type« = initial_value» (VB 10)

|

|

| PHP

|

|

|

| Perlthese examples need the [https://metacpan.org/module/Class::Accessor Class::Accessor] module installed

| use base qw(Class::Accessor);
__PACKAGE__->mk_accessors('Bar');

| use base qw(Class::Accessor);
__PACKAGE__->mk_ro_accessors('Bar');

| use base qw(Class::Accessor);
__PACKAGE__->mk_wo_accessors('Bar');

| Raku

| colspan=3 {{n/a}}

| Ruby

| attr_accessor :bar

| attr_reader :bar

| attr_writer :bar

| Windows PowerShell

|

|

|

| OCaml

| colspan=3 {{n/a}}

| F#

| member val Bar = value with get, set

|

|

| COBOL

| level-number bar clauses PROPERTY.

| level-number bar clauses PROPERTY «WITH» NO SET.

| level-number bar clauses PROPERTY «WITH» NO GET.

| pro bar from var «as type»

| get bar from var «as type»

| set bar from var «as type»

|

! unary

! binary

! function call

| colspan=3 {{n/a}}

| type operator symbol () { instructions }

| type operator symbol (type operand2) { instructions }

| type operator () («parameters») { instructions }

| static type operator symbol(type operand) { instructions }

| static type operator symbol(type operand1, type operand2) { instructions }

| {{n/a}}

| type 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 }

| rowspan=2 colspan=3 {{n/a}}

| func symbol(operand1 : type) -> returntype { instructions } (outside class)

| func symbol(operand1 : type1, operand2 : type2) -> returntype { instructions } (outside class)

|

| op_name alias "symbol": TYPE
do instructions end

| op_name alias "symbol" (operand: TYPE1): TYPE2
do instructions end

|

| def __opname__(self):
{{keypress|Tab}} instructions
{{keypress|Tab}} return value

| def __opname__(self, operand2):
{{keypress|Tab}} instructions
{{keypress|Tab}} return value

| def __call__(self«, parameters»):
{{keypress|Tab}} instructions
{{keypress|Tab}} return value

| Shared Operator symbol(operand As type) As type
instructions
End Operator

| Shared Operator symbol(operand1 As type, operand2 As type) As type
instructions
End Operator

| {{n/a}}

| Function Operator_name(operand As type) As type
instructions
End Function

| colspan=2 {{n/a}}

| colspan=2|PHP does not support operator overloading natively, but support can be added using the [http://pecl.php.net/package/operator "operator" PECL package].

| function __invoke(«parameters») { instructions } (PHP 5.3+)

| use overload "symbol" => sub { my ($self) = @_; instructions };

| use overload "symbol" => sub { my ($self, $operand2, $operands_reversed) = @_; instructions };

|

| «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 }

| def symbol
instructions
expression resulting in return value
end

| def symbol(operand2)
instructions
expression resulting in return value
end

| {{n/a}}

| rowspan=2 colspan=3 {{n/a}}

| static member (symbol) operand = expression

| static member (symbol) (operand1, operand2) = expression

| {{n/a}}

| colspan=3 {{n/a}}

| colspan=3 {{n/a}}

|

! read-write

! read-only

! write-only

| ABAP Objects

| colspan=3 {{n/a}}

| 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 } }

| D

| type opIndex(type index) { instructions }
type opIndexAssign(type value, type index) { instructions }

| type opIndex(type index) { instructions }

| type opIndexAssign(type value, type index) { instructions }

| Java

| colspan=3 {{n/a}}

| Objective-C (recent Clang compiler)

| {{n/a}}

| - (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 }

| Swift

| subscript (index : type) -> returntype { get { instructions } set«(newIndex)» { instructions } }

| subscript (index : type) -> returntype { instructions }

|

| Eiffel

| 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

|

| Python

| def __getitem__(self, index):
{{keypress|Tab}} instructions
{{keypress|Tab}} return value
def __setitem__(self, index, value):
{{keypress|Tab}} instructions

| def __getitem__(self, index):
{{keypress|Tab}} instructions
{{keypress|Tab}} return value

| def __setitem__(self, index, value):
{{keypress|Tab}} instructions

| Visual Basic .NET

| Default 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

|colspan=3|The class must implement the [http://www.php.net/manual/en/class.arrayaccess.php ArrayAccess interface].

| Perl

|colspan=3|The class must overload '@{}' (array dereference) or subclass one of Tie::Array or Tie::StdArray to hook array operations

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

| {{n/a}}

| Ruby

| def [](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

| rowspan=2 colspan=3 {{n/a}}

| OCaml

| F#

| member this{{Not a typo|.}}Item with get(index) = expression and set index value = expression

| member this{{Not a typo|.}}Item with get(index) = expression

| member this{{Not a typo|.}}Item with set index value = expression

| COBOL

| colspan=3 {{n/a}}

| pro[index «as type»] as type
{{keypress|Tab}} get
{{keypress|Tab}}{{keypress|Tab}} instructions
{{keypress|Tab}}{{keypress|Tab}} return value
{{keypress|Tab}} set
{{keypress|Tab}}{{keypress|Tab}} instructions

| get[index «as type»] as type
{{keypress|Tab}} instructions
{{keypress|Tab}} return value

| set[index «as type»] as type
{{keypress|Tab}} instructions

|

! downcast

! upcast

| colspan=2 {{n/a}}

|

| operator returntype() { instructions }

| static explicit operator returntype(type operand) { instructions }

| static implicit operator returntype(type operand) { instructions }

|

| T opCast(T)() if (is(T == type)) { instructions }

|

| property T { get { return «conversion code»; } }

| rowspan=4 colspan=2 {{n/a}}

| Shared Narrowing Operator CType(operand As type) As returntype
instructions
End Operator

| Shared Widening Operator CType(operand As type) As returntype
instructions
End Operator

| rowspan=2 colspan=2 {{n/a}}

|

| multi method type«($self:)» is export { instructions }

| rowspan=3 colspan=2 {{n/a}}

|

|

| colspan=2 {{n/a}}

| x->method(«parameters»).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

| x->field

| {{n/a}}

| x=>field or x=>method(«parameters»).

| {{n/a}}

| x.method(parameters) or
ptr->method(parameters)

| x.field or
ptr->field

|

| cls::member

| ns::member

| [x method«:parameter «bar:parameter ...»»]

| x->field

| x.property (2.0 only) or
[x property]

| [cls method«:parameter «bar:parameter ...»»]

|

| x method«:parameter «bar:parameter ...»»

| {{n/a}}

|

| cls method«:parameter «bar:parameter ...»»

|

| x.method(parameters)

|

| x.property

| cls.member

|

| left argument» x.method «right argument(s)»

| rowspan=8| x.field

| x.property

| rowspan=7| cls.member

| rowspan=9| ns.member

| rowspan=8| x.method(parameters)

| {{n/a}}

| rowspan=6| x.property

| [cls]::member

| {{n/a}}

| cls.member

| x.method«(parameters)»

| x.field

| x.property

| cls::member

| ns::member

| rowspan=2|x.method«(parameters)»

| x.field

|

| {cls}.member

| rowspan=2 {{n/a}}

| {{n/a}}

| x.property

| cls.member

| x->method(parameters)

| x->field

| x->property

| cls::member

| ns\member

| x->method«(parameters)»

| x->{field}

|

| cls->method«(parameters)»

| ns::member

| x.method«(parameters)» or
x!method«(parameters)»

| x.field or
x!field

|

| cls.method«(parameters)» or
cls!method«(parameters)»

| ns::member

| x#method «parameters»

| colspan=2 {{n/a}}

|

|

| x.method(parameters)
x["method"](parameters)

| x.field
x["field"]

| x.property
x["property"]

| cls.member
cls["member"]

| {{n/a}}

| INVOKE x "method" «USING parameters» «RETURNING result» or
x::"method"«(«parameters»)»

| {{n/a}}

| property OF x

| INVOKE cls "method" «USING parameters» «RETURNING result» or
cls::"method"«(«parameters»)» or
property OF cls

| {{n/a}}

| x.method«(parameters)»

| x.field

| x.property

| cls.member

| ns.member

| 3=x.⎕NC'method'

| 2=x.⎕NC'method'

| colspan=2 {{n/a}}

| rowspan=2 colspan=4 {{n/a}}

| [x respondsToSelector:@selector(method)]

| {{n/a}}

| forwardInvocation:

| {{n/a}}

| x respondsTo: selector

| {{n/a}}

| doesNotUnderstand:

| {{n/a}}

| rowspan=3 colspan=4| (using reflection)

|

|

| colspan=2| opDispatch()

| colspan=4 {{n/a}}

| hasattr(x, "method") and callable(x.method)

| hasattr(x, "field")

| colspan=2 | __getattr__()

| colspan=4 |(using reflection)

| colspan=4 |(using Introspection)

| colspan=4 |(using reflection)

| colspan=4 |(using reflection)

| x.respond_to?(:method)

| {{n/a}}

| method_missing()

| {{n/a}}

| method_exists(x, "method")

| property_exists(x, "field")

| __call()

| __get() / __set()

| x->can("method")

| exists x->{field}

| AUTOLOAD

|

| x.can("method")

| x.field.defined

| AUTOLOAD

|

| colspan=4 {{n/a}}

| typeof x.method === "function"

| field in x

|

|

| colspan=4 {{n/a}}

| self

| super

| nil

| thisContext

| me

| super

| initial

|

| ⎕THIS

| ⎕BASE

| ⎕NULL

|

| *this

|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.[http://msdn.microsoft.com/en-us/library/94dw1w7x.aspx]

| NULL, nullptr

|

| rowspan=4| this

| baseThe keyword here is not a value, and it can only be used to access a method of the superclass.

| rowspan=3| null

|

| rowspan=2| super

|

|

| super (ECMAScript 6)

| null, undefinedBut be afraid, they have not the same value.

|

| this

|

| null

|

| self

| super

| nil

|

| self

| super

| nilonly for Optional types

|

| selfIn 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.

| super(current_class_name, self)
super() (3.x only)

| None

|

| Me

| MyBase

| Nothing

|

| Me / Self

| Parent

| Nil

|

| Current

| Precursor «{superclass}» «(args)»"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.

| Void

|

| $this

| parent

| null

|

| $self

| $self->SUPER

| undef

|

| self

| SUPER

| Nil

|

| self

| super«(args)»"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.

| nil

| binding

| $this

|

| $NULL

|

| selfIn 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.

| superIn 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.

| {{n/a}}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.

|

| this

| base

| null

|

| SELF

| SUPER

| NULL

|

| this

| base

| nil

|

| colspan=7 {{n/a}}

| ⍕x

| ⎕SRC x

| ⎕NS x

| x = y

| colspan=2 {{n/a}}

|

|

|

| x == yassuming that "x" and "y" are the objects (and not pointers). Can be customized by overloading the object's == operator

|

|

| pointer to object can be converted into an integer ID

| x.ToString()

|

| x.Clone()

| x.Equals(y)

| x.CompareTo(y)

| x.GetHashCode()

| System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(x)

| x.toString()

|

| x.clone()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.

| x.equals(y)

| x.compareTo(y)The class should implement the interface Comparable for this method to be standardized.

| x.hashCode()

| System.identityHashCode(x)

| x.toString()

|

|

|

|

|

|

| x.toString() or
std.conv.to!string(x)

| x.stringof

|

| x == y or
x.opEquals(y)

| x.opCmp(y)

| x.toHash()

|

| x.OnGetString(tempString, null, null) or
PrintString(x)

|

| y.OnCopy(x)

|

| x.OnCompare(y)

|

| object handle can be converted into an integer ID

| x.description

| x.debugDescription

| [x copy]Implemented by the object's copyWithZone: method

| [x isEqual:y]

| [x compare:y]compare: is the conventional name for the comparison method in Foundation classes. However, no formal protocol exists

| x.hash

| pointer to object can be converted into an integer ID

| x.descriptionOnly if object conforms to the Printable protocol

| x.debugDescriptionOnly if object conforms to the DebugPrintable protocol

|

| x == yOnly if object conforms to the Equatable protocol

| x < yOnly if object conforms to the Comparable protocol

| x.hashValueOnly if object conforms to the hashValue protocol

| reflect(x).objectIdentifier!.uintValue()

| x displayString

| x printString

| x copy

| x = y

|

| x hash

| x identityHash

| str(x)Can be customized by the object's __str__() method

| repr(x)Can be customized by the object's __repr__() method

| copy.copy(x)Can be customized by the object's __copy__() method

| x == yCan be customized by the object's __eq__() method

| cmp(x, y)Only in Python 2.x and before (removed in Python 3.0). Can be customized by the object's __cmp__() method

| hash(x)Can be customized by the object's __hash__() method. Not all types are hashable (mutable types are usually not hashable)

| id(x)

| x.ToString()

|

| x.Clone()

| x.Equals(y)

| x.CompareTo(y)

| x.GetHashCode()

|

| x.out

|

| x.twin

| x.is_equal(y)

| When x is COMPARABLE, one can simply do x < y

| When x is HASHABLE, one can use x.hash_code

| When x is IDENTIFIED, one can use x.object_id

| $x->__toString()

|

| clone xCan be customized by the object's __clone() method

| x == y

|

|

| spl_object_hash(x)

| "$x"Can be customized by overloading the object's string conversion operator

| Data::Dumper->Dump([$x],[{{'}}x{{'}}])This example requires useing Data::Dumper

| Storable::dclone($x)This example requires useing Storable

|

|

|

| Scalar::Util::refaddr( $x )This example requires useing Scalar::Util

| ~x

| x.perl

| x.clone

| x eqv y

| x cmp y

|

| x.WHICH

| x.to_s

| x.inspect

| x.dup or
x.clone

| x == y or
x.eql?(y)

| x <=> y

| x.hash

| x.object_id

| x.ToString()

|

| x.Clone()

| x.Equals(y)

| x.CompareTo(y)

| x.GetHashCode()

|

|

|

| Oo.copy x

| x = y

|

| Hashtbl.hash x

| Oo.id x

| string x or x.ToString() or sprintf "%O" x

| sprintf "%A" x

| x.Clone()

| x = y or x.Equals(y)

| compare x y or x.CompareTo(y)

| hash x or x.GetHashCode()

|

| colspan=7 {{n/a}}

| colspan=2 {{n/a}}Run-time type information in ABAP can be gathered by using different description Classes like CL_ABAP_CLASSDESCR.

| =

| ?=

| typeid(x)

| dynamic_cast<type *>(&x) != nullptr

| rowspan=8 {{n/a}}Upcasting is implicit in this language. A subtype instance can be used where a supertype is needed.

| dynamic_cast<type*>(ptr)

| (type*) ptr or
static_cast<type*>(ptr)

| x.GetType()

| x is type

| (type) x or x as type

|

| typeid(x)

|

| cast(type) x

|

|

| x is type

| x as type

|

| x._class

| eClass_IsDerived(x._class, type)

|

| (type) x

| x.getClass()

| x instanceof class

| (type) x

|

| [x class]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.

| [x isKindOfClass:[class class]]

|

| (type*) x

| x.dynamicType

| x is type

| x as! type
x as? type

| x.constructor (If not rewritten.)

| x instanceof class

| colspan=3 {{n/a}}This language is dynamically typed. Casting between types is unneeded.

| x.GetType()

| TypeOf x Is type

| {{n/a}}

| CType(x, type) or TryCast(x, type)

|

| Introspection.GetType(x)

| x IsA type

| {{n/a}}

| CType(x, type)

| {{n/a}}

| x.generating_type

| attached {TYPE} x

| attached {TYPE} x as down_x

|

| type(x)

| isinstance(x, type)

| colspan=3 rowspan=3 {{n/a}}

| get_class(x)

| x instanceof class

| ref(x)

| x->isa("class")

| x.WHAT

| x.isa(class)

| {{n/a}}

| type(x) or
x.type

|

| x.class

| x.instance_of?(type) or
x.kind_of?(type)

| colspan=3 rowspan=2 {{n/a}}

| x class

| x isKindOf: class

| x.GetType()

| x -is [type]

| {{n/a}}

| [type]x or x -as [type]

|

| colspan=2 {{n/a}}This language doesn't give run-time type information. It is unneeded because it is statically typed and downcasting is impossible.

| rowspan=2| (x :> type)

| colspan=2 {{n/a}}

| x.GetType()

| x :? type

| (x :?> type)

|

| colspan=2 {{n/a}}

| x AS type

| colspan=2 {{n/a}}

|

|

|

|

| using namespace ns;

| using ns::item ;

|

| using ns;

| using item = ns.item;

|

| import ns;

| import ns : item;

|

| import ns.*;

| import ns.item;

|

|

|

|

| Imports ns

|

|

|

|

| import ns

| from ns import *

| from ns import item

|

| use ns;

| use ns\item;

| rowspan=2| use ns;

|

| use ns qw(item);

|

|

|

|

|

|

|

|

|

| rowspan=2| open ns

|

|

|

| colspan=3 {{n/a}}

| colspan=5 rowspan=2 {{n/a}}

| Spec#:
type foo( «parameters» )
    requires expression
{
    body
}

| Spec#:
type foo( «parameters» )
    ensures expression
{
    body
}

| colspan=5 rowspan=3 {{n/a}}

| f
in { asserts }
body{ instructions }

| f
out (result) { asserts }
body{ instructions }

| assert(expression)

| invariant() { expression }

|

| f
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

| colspan=5 rowspan=3 {{n/a}}

| PRE { condition }

| POST { condition }

|

|

|

| colspan=5 rowspan=5 {{n/a}}