Comparison of programming languages (object-oriented programming)

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.

Object construction and destruction

	construction	destruction
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);
eC	class «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 Objects	class 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 }
D			module name; members
eC	class name« : base class» { «default member values assignments» «members» }		namespace name;
Java	class name« extends parentclass»« implements interfaces» { members }	interface name« extends parentinterfaces» { members }	package name; members
PHP			namespace 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]
Swift	class name« : «parentclass»«, protocols»» { members }	protocol name« : parentprotocols» { members }
Python	class name«(parentclasses [7] )»: Tab ↹members	[11]	__all__ = [ member1,member2,... ]
Visual Basic .NET	Class name« Inherits parentclass»« Implements interfaces» members End Class	Interface name« Inherits parentinterfaces» members End Interface	Namespace name members End Namespace
Xojo	Class name« Inherits parentclass»« Implements interfaces» members End Class	Interface name« Inherits parentinterfaces» members End Interface	Module name members End Module
Eiffel	class name« inherit parentclasses [7] » members end	—
Perl	package name; «@ISA = qw(parentclasses [7] );» members 1;		package name; members
Raku	class name «is parentclass «is parentclass ... [7] »» «does role «does role ...»» { members }	role name «does role «does role ...»» { members }	module name { members }
Ruby	class name« < parentclass» members end		module name members end
Windows PowerShell	—
OCaml	class name «parameters» = object «(self)» «inherit parentclass «parameters» «inherit parentclass «parameters» ... [7] »» members end		module name members
F#	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
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 membersprotected// Protected memberspublished// Published membersend;		package name; members
Scala	classConcreteClass(constructorparams)extendsParentClasswithTrait1withTrait2withTrait2{// members}	traitTraitNameextendsOtherTrait1withOtherTrait2withOtherTrait3{// members}	packagename
COBOL	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.	—
Cobra	class 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 Objects	methods 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 }
D	this(«parameters») { instructions }		~this() { instructions }
eC	class() { instructions }	~class() { instructions }
Java	class(«parameters») { instructions }		void finalize() { instructions }
Eiffel	[17]		[18]
Objective-C (Cocoa)	-(id)init{instructions...returnself;} or - (id)initWithFoo:parameter «bar:parameter ...» { instructions... return self; }	-(void)dealloc{instructions }	-(void)finalize{instructions }
Swift	init(«parameters») { instructions }	deinit { instructions }
Python	def__init__(self«, parameters»): Tab ↹ instructions		def__del__(self): Tab ↹ instructions
Visual Basic .NET	SubNew(«parameters») instructions End Sub	SubDispose() instructions End Sub	OverridesSubFinalize() instructions End Sub
Xojo	Sub Constructor(«parameters») instructions End Sub	Sub Destructor() instructions End Sub
PHP	function__construct(«parameters») { instructions }	function__destruct(){instructions }
Perl	subnew{my($class«, parameters»)=@_;my$self={};instructions ...bless($self,$class);return$self;}	subDESTROY{my($self)=@_;instructions }
Raku	submethodBUILD { instructions } or «multi » methodnew(««$self: »parameters») { self.bless(*,field1 => value1, ...); ... instructions }	submethodDESTROY { instructions }
Ruby	def initialize«(parameters)» instructions end	—
Windows PowerShell	—
OCaml	initializer instructions [19]	—
F#	do instructions or new(parameters) = expression [20]	memberthis.Dispose() = instructions	overridethis.Finalize() = instructions
JavaScript	function name(«parameters»){ instructions } [21]	—
JavaScript (ES6)	constructor(«parameters») { instructions }
COBOL	— [22]	—
Cobra	cue init(parameters) Tab ↹base.init Tab ↹ instructions	def dispose Tab ↹ instructions
ISLISP	(defmethod initialize-object ((instance <class-name>) initvalues)

Fields

	public	private	protected	friend
ABAP Objects	public 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»;
D				package type field «= value»;
Java			protected type field «= value»;	type field «= value»;
eC	public type field;	private type field;
Eiffel	feature 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]	—
Python	self.field = value [27]	— [28]	—
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»	—
PHP	public $field «= value»;	private $field «= value»;	protected $field «= value»;
Perl	$self->{field} = value; [27]	—
Raku	has« type »$.field« is rw»	has« type »$!field	—
Ruby	—		@ field = value [27]
Windows PowerShell	Add-Member «-MemberType »NoteProperty «-Name »Bar «-Value »value -InputObject variable	—
OCaml	—		val «mutable» field = value	—
F#	—	let «mutable» field = value	—
JavaScript	this.field = value this["field"] = value [27]
COBOL	—	level-number field clauses. [29]	—	—
Cobra	var 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 method	value-returning method
ABAP Objects	methods 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
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»): Tab ↹instructions	def foo(self«, parameters»): Tab ↹instructions 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	—	method foo «parameters» = expression
F#		member this.foo(«parameters») = expression
JavaScript	this.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;}
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.
Cobra	def 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-write	read-only	write-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;}
eC	property 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 }	—
Swift	var bar : type { get { instructions } set«(newBar)» { instructions } }	var bar : type { instructions }	—
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): 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 .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	—
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	—
F#	member this.Bar with get() = expression and set(value) = expression	member this.Bar = expression	member 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 }
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.
Cobra	pro 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-write	read-only	write-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;	—
Swift	var bar : type	let 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 .NET	Property 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	—
Ruby	attr_accessor :bar	attr_reader :bar	attr_writer :bar
Windows PowerShell
OCaml	—
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.
Cobra	pro bar from var «as type»	get bar from var «as type»	set bar from var «as type»

Overloaded operators

Standard operators

	unary	binary	function 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 }	—
D	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 }
Java	—
Objective-C
Swift	func 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
Python	def __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 .NET	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	—
Xojo	Function Operator_name(operand As type) As type instructions End Function	—
PHP	[38]		function __invoke(«parameters») { instructions } (PHP 5.3+)
Perl	use 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 }
Ruby	def 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 = expression	static member (symbol)(operand1, operand2) = expression	—
COBOL	—
ISLISP	—

Indexers

	read-write	read-only	write-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 } }
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	—
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 }
Swift	subscript (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
Python	def __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 .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	[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;}	—
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	—
OCaml
F#	member this.Item with get(index) = expression and set index value = expression	member this.Item with get(index) = expression	member this.Item with set index value = expression
COBOL	—
Cobra	pro[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

	downcast	upcast
ABAP Objects	—
C++		operator returntype() { instructions }
C#	static explicit operator returntype(type operand) { instructions }	static implicit operator returntype(type operand) { instructions }
D		T opCast(T)() if (is(T == type)) { instructions }
eC		property T { get { return «conversion code»; } }
Java	—
Objective-C
Eiffel [37]
Python
Visual Basic .NET	Shared 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
Raku		multi method type«($self:)» is export { instructions }
Ruby	—
Windows PowerShell
OCaml
F#
COBOL	—

Member access

How to access members of an object x

	object member			class member	namespace member
	method	field	property
ABAP Objects	x->method(«parameters»). [41]	x->field	—	x=>field or x=>method(«parameters [41] »).	—
C++	x.method(parameters) or ptr->method(parameters)	x.field or ptr->field		cls::member	ns::member
Objective-C	[x method«:parameter «bar:parameter ...»»]	x->field	x.property (2.0 only) or [x property]	[cls method«:parameter «bar:parameter ...»»]
Smalltalk	x method«:parameter «bar:parameter ...»»	—		cls method«:parameter «bar:parameter ...»»
Swift	x.method(parameters)		x.property	cls.member
APL (Dyalog)	left argument» x.method «right argument(s)»	x.field	x.property	cls.member	ns.member
C#	x.method(parameters)
Java			—
D			x.property
Python
Visual Basic .NET
Xojo
Windows PowerShell				[cls]::member
F#		—		cls.member
eC	x.method«(parameters)»	x.field	x.property	cls::member	ns::member
Eiffel	x.method«(parameters)»	x.field		{cls}.member	—
Ruby		—	x.property	cls.member
PHP	x->method(parameters)	x->field	x->property	cls::member	ns\member
Perl	x->method«(parameters)»	x->{field}		cls->method«(parameters)»	ns::member
Raku	x.method«(parameters)» or x!method«(parameters)»	x.field or x!field		cls.method«(parameters)» or cls!method«(parameters)»	ns::member
OCaml	x#method «parameters»	—
JavaScript	x.method(parameters) x["method"](parameters)	x.field x["field"]	x.property x["property"]	cls.member cls["member"]	—
COBOL	INVOKE x"method" «USING parameters» «RETURNING result» or x::"method"«(«parameters»)»	—	property OF x	INVOKE cls "method" «USING parameters» «RETURNING result» or cls::"method"«(«parameters»)» or property OF cls	—
Cobra	x.method«(parameters)»	x.field	x.property	cls.member	ns.member

Member availability

	Has member?		Handler for missing member
	Method	Field	Method	Field
APL (Dyalog)	3=x.⎕NC'method'	2=x.⎕NC'method'	—
ABAP Objects	—
C++
Objective-C (Cocoa)	[x respondsToSelector:@selector(method)]	—	forwardInvocation:	—
Smalltalk	x respondsTo: selector	—	doesNotUnderstand:	—
C#	(using reflection)
eC
Java
D			opDispatch()
Eiffel	—
Python	hasattr(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)
Ruby	x.respond_to?(:method)	—	method_missing()	—
PHP	method_exists(x, "method")	property_exists(x, "field")	__call()	__get() / __set()
Perl	x->can("method")	exists x->{field}	AUTOLOAD
Raku	x.can("method")	x.field.defined	AUTOLOAD
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
Smalltalk	self	super	nil	thisContext
ABAP Objects	me	super	initial
APL (Dyalog)	⎕THIS	⎕BASE	⎕NULL
C++	*this	[42]	NULL, nullptr
C#	this	base [43]	null
Java		super [43]
D
JavaScript		super [43] (ECMAScript 6)	null, undefined [44]
eC	this		null
Objective-C	self	super [43]	nil
Swift	self	super [43]	nil [45]
Python	self [46]	super(current_class_name, self) [7] super() (3.x only)	None
Visual Basic .NET	Me	MyBase	Nothing
Xojo	Me / Self	Parent	Nil
Eiffel	Current	Precursor «{superclass}» «(args)» [43] [47]	Void
PHP	$this	parent [43]	null
Perl	$self [46]	$self->SUPER [43]	undef
Raku	self	SUPER	Nil
Ruby	self	super«(args)» [48]	nil	binding
Windows PowerShell	$this		$NULL
OCaml	self [49]	super [50]	— [51]
F#	this	base [43]	null
COBOL	SELF	SUPER	NULL
Cobra	this	base	nil

Special methods

	String representation		Object copy	Value equality	Object comparison	Hash code	Object ID
	Human-readable	Source-compatible
ABAP Objects	—
APL (Dyalog)	⍕x	⎕SRC x	⎕NS x	x = 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)
Java	x.toString()		x.clone() [53]	x.equals(y)	x.compareTo(y) [54]	x.hashCode()	System.identityHashCode(x)
JavaScript	x.toString()
D	x.toString() or std.conv.to!string(x)	x.stringof		x == y or x.opEquals(y)	x.opCmp(y)	x.toHash()
eC	x.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.description	x.debugDescription	[x copy] [55]	[x isEqual:y]	[x compare:y] [56]	x.hash	pointer to object can be converted into an integer ID
Swift	x.description [57]	x.debugDescription [58]		x == y [59]	x < y [60]	x.hashValue [61]	reflect(x).objectIdentifier!.uintValue()
Smalltalk	x displayString	x printString	x copy	x = y		x hash	x identityHash
Python	str(x) [62]	repr(x) [63]	copy.copy(x) [64]	x == y [65]	cmp(x, y) [66]	hash(x) [67]	id(x)
Visual Basic .NET	x.ToString()		x.Clone()	x.Equals(y)	x.CompareTo(y)	x.GetHashCode()
Eiffel	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
PHP	$x->__toString()		clone x [68]	x == y			spl_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.perl	x.clone	x eqv y	x cmp y		x.WHICH
Ruby	x.to_s	x.inspect	x.dup or x.clone	x == y or x.eql?(y)	x <=> y	x.hash	x.object_id
Windows PowerShell	x.ToString()		x.Clone()	x.Equals(y)	x.CompareTo(y)	x.GetHashCode()
OCaml			Oo.copy x	x = y		Hashtbl.hash x	Oo.id x
F#	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()
COBOL	—

Type manipulation

	Get object type	Is instance of (includes subtypes)	Upcasting	Downcasting
				Runtime check	No 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
D	typeid(x)			cast(type) x
Delphi		x is type		x as type
eC	x._class	eClass_IsDerived(x._class, type)			(type) x
Java	x.getClass()	x instanceof class		(type) x
Objective-C (Cocoa)	[x class] [75]	[x isKindOfClass:[class class]]			(type*) x
Swift	x.dynamicType	x is type		x as! type x as? type
JavaScript	x.constructor(If not rewritten.)	x instanceof class	— [76]
Visual Basic .NET	x.GetType()	TypeOf x Is type	— [74]	CType(x, type) or TryCast(x, type)
Xojo	Introspection.GetType(x)	x IsA type	—	CType(x, type)	—
Eiffel	x.generating_type	attached {TYPE} x	attached {TYPE} x as down_x
Python	type(x)	isinstance(x, type)	— [76]
PHP	get_class(x)	x instanceof class
Perl	ref(x)	x->isa("class")
Raku	x.WHAT	x.isa(class)	— [74]	type(x) or x.type
Ruby	x.class	x.instance_of?(type) or x.kind_of?(type)	— [76]
Smalltalk	x class	x isKindOf: class
Windows PowerShell	x.GetType()	x -is [type]	— [74]	[type]x or x -as [type]
OCaml	— [77]		(x :> type)	—
F#	x.GetType()	x :? type		(x :?> type)
COBOL	—		x AS type [74]	—

Namespace management

	Import namespace		Import item
	qualified	unqualified
ABAP Objects
C++		using namespace ns;	using ns::item ;
C#		using ns;	using item = ns.item;
D		import ns;	import ns : item;
Java		import ns.*;	import ns.item;
Objective-C
Visual Basic .NET		Imports ns
Eiffel
Python	import ns	from ns import *	from ns import item
PHP		use ns;	use ns\item;
Perl	use ns;		use ns qw(item);
Raku
Ruby
Windows PowerShell
OCaml		open ns
F#
COBOL	—

Contracts

	Precondition	Postcondition	Check	Invariant	Loop
ABAP Objects	—
C++
C#	Spec#: type foo( «parameters» )     requires expression {     body }	Spec#: type foo( «parameters» )     ensures expression {     body }
Java	—
Objective-C
Visual Basic .NET
D	f in { asserts } body{ instructions }	f out (result) { asserts } body{ instructions }	assert(expression)	invariant() { expression }
Eiffel	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
Python	—
PHP
Perl
Raku	PRE { condition }	POST { condition }
Ruby	—
Windows PowerShell
OCaml
F#
COBOL

See also

• Object-oriented programming

Notes

1. parameter = argument may be repeated if the constructor has several parameters
2. SAP reserved to himself the use of destruction
3. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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.