This article may require cleanup to meet Wikipedia's quality standards. The specific problem is: This article's reference section contains many footnotes, but lists no external references or sources.(June 2013) |
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.
construction | destruction | |
---|---|---|
ABAP Objects | data variable type ref to class . [1] | [2] [3] |
APL (Dyalog) | variable←⎕NEW class «parameters» | ⎕EX 'variable' |
C++ | class variable«(parameters)»; [4] orclass * 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 orcreate «{TYPE}» variable.make_foo «(parameters)» orvariable := create{TYPE} orvariable := 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 orMOVE 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 | protocol | namespace | |
---|---|---|---|
ABAP Objects | class name definition «inheriting from parentclass». «interfaces: interfaces.» method_and_field_declarations 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; | ||
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 [9] | @protocol name«< parentprotocols >» members @end | [10] |
Swift | class name« : «parentclass»«, protocols»» { members } | protocol name« : parentprotocols» { members } | |
Python | class name«(parentclasses [7] )»: | [11] | __all__ = [ member1,member2,... ] |
Visual Basic .NET | Class name« Inherits parentclass»« Implements interfaces» | Interface name« Inherits parentinterfaces» | Namespace name |
Xojo | Class name« Inherits parentclass»« Implements interfaces» | Interface name« Inherits parentinterfaces» | Module name |
Eiffel | class name« inherit parentclasses [7] » | — | |
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» | module name | |
Windows PowerShell | — | ||
OCaml | class name «parameters» = object «(self)» «inherit parentclass «parameters» «inherit parentclass «parameters» ... [7] »» members end | module name | |
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 |
Smalltalk | [12] | [13] | |
JavaScript (ES6) | class name «extends parentclass» { members } | ||
Object Pascal (Delphi) |
| 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.
| INTERFACE-ID. name« INHERITS« FROM» interfaces». members
| — |
Cobra | class name «inherits parentclass» «implements interfaces» | interface name «inherits parentinterfaces» | namespace name |
ISLISP | (defclass name (base-class) ((x :initform 0 :accessor get-x :initarg x)) (:abstractp nil)) |
constructor | destructor | finalizer [14] | |
---|---|---|---|
ABAP Objects | methods constructor «importing parameter = argument» [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... return self; } or | - (void)dealloc { instructions } | - (void)finalize { instructions } |
Swift | init(«parameters») { instructions } | deinit { instructions } | |
Python | def __init__(self«, parameters»): | def __del__(self): | |
Visual Basic .NET | Sub New(«parameters») | Sub Dispose() | Overrides Sub Finalize() |
Xojo | Sub Constructor(«parameters») | Sub Destructor() | |
PHP | function __construct(«parameters») { instructions } | function __destruct() { instructions } | |
Perl | sub new { my ($class«, parameters») = @_; my $self = {}; instructions ... bless($self, $class); return $self; } | sub DESTROY { my ($self) = @_; instructions } | |
Raku | submethod BUILD { instructions } or | submethod DESTROY { instructions } | |
Ruby | def initialize«(parameters)» | — | |
Windows PowerShell | — | ||
OCaml | initializer instructions [19] | — | |
F# | do instructions or [20] | member this.Dispose() = instructions | override this.Finalize() = instructions |
JavaScript | function name(«parameters»){ instructions } [21] | — | |
JavaScript (ES6) | constructor( «parameters») { instructions } | ||
COBOL | — [22] | — | |
Cobra | cue init(parameters) | def dispose | |
ISLISP | (defmethod initialize-object ((instance <class-name>) initvalues) |
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 | feature {NONE} | feature {current_class} | feature {FRIEND} |
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 | — | ||
OCaml | — | val «mutable» field = value | — | |
F# | — | let «mutable» field = value | — | |
JavaScript | 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) |
basic/void method | value-returning method | ||
---|---|---|---|
ABAP Objects | methods name «importing parameter = argument» «exporting parameter = argument» «changing parameter = argument» «returning value(parameter)» [30] | [31] | |
APL (Dyalog) | ∇ «left argument» name «right arguments» instructions ∇ | ∇ result ← «left argument» name «right arguments» instructions ∇ | |
C++ [32]
The implementation of methods is usually provided in a separate source file, with the following syntax
| 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» ) | foo ( «parameters» ): TYPE | |
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»): | def foo(self«, parameters»): | |
Visual Basic .NET | Sub Foo(«parameters») | Function Foo(«parameters») As type | |
Xojo | Sub Foo(«parameters») | Function Foo(«parameters») As type | |
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)» | def foo«(parameters)» | |
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} [34] | this.method = function(«parameters») {instructions... return value;} [34] | |
Javascript (ES6) | foo(«parameters») {instructions} | foo(«parameters») {instructions... return value;} | |
COBOL | METHOD-ID. foo. instructions
| METHOD-ID. foo. instructions
| |
Cobra | def foo(parameters) | def foo(parameters) as type | |
ISLISP | (defgeneric method (arg1 arg2)) |
How to declare a property named "Bar"
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 { | type Bar { get { instructions ... return value;} } | type Bar { set { instructions } } |
D | @property type bar() { instructions ... return value;} | @property type bar() { instructions ... return value;} | @property type bar(type value) { instructions ... return value;} |
eC | property type Bar { | 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 | @property (readonly) type bar; and then inside @implementation | — |
Swift | var bar : type { get { instructions } set«(newBar)» { instructions } } | var bar : type { instructions } | — |
Eiffel | feature -- Access | ||
Python | def setBar(self, value): [35] | def getBar(self): | def setBar(self, value): |
Visual Basic .NET | Property Bar() As type | ReadOnly Property Bar() As type | WriteOnly Property Bar() As type |
Xojo | ComputedProperty Bar() As type | ComputedProperty Bar() As type | ComputedProperty Bar() As type |
PHP | function __get($property) { | function __get($property) { | function __set($property, $value) { |
Perl | sub Bar { | sub Bar { | sub Bar { |
Raku | — | ||
Ruby | def bar | def bar | def bar=(value) |
Windows PowerShell | Add-Member | Add-Member | Add-Member |
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. instructions
instructions
| METHOD-ID. GET PROPERTY bar. instructions
| METHOD-ID. SET PROPERTY bar. instructions
|
Cobra | pro bar «as type» | get bar «as type» | set bar «as type» |
ISLISP | — |
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 | @property (readonly) type bar; and then inside @implementation | — |
Swift | var bar : type | let bar : type | — |
Eiffel | |||
Python | @property | @property | bar = property() |
Visual Basic .NET | Property Bar As type« = initial_value» (VB 10) | ||
PHP | |||
Perl [36] | usebaseqw(Class::Accessor); | usebaseqw(Class::Accessor); | usebaseqw(Class::Accessor); |
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» |
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 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 | op_name alias "symbol" (operand: TYPE1): TYPE2 | |
Python | def __opname__(self): | def __opname__(self, operand2): | def __call__(self«, parameters»): |
Visual Basic .NET | Shared Operator symbol(operand As type) As type | Shared Operator symbol(operand1 As type, operand2 As type) As type | — |
Xojo | Function Operator_name(operand As type) As type | — | |
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 infix:<symbol> («$operand1: » type operand2) { instructions ... return value;} | «our «type »»«multi »method postcircumfix:<( )> («$self: » «parameters») { instructions } |
Ruby | def symbol | def symbol(operand2) | — |
Windows PowerShell | — | ||
OCaml | |||
F# | static member (symbol) operand = expression | static member (symbol)(operand1, operand2) = expression | — |
COBOL | — | ||
ISLISP | — | ||
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] { | type this[type index] { get{ instructions } } | type this[type index] { set{ instructions } } |
D | type opIndex(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 | - (void)setObject:(id)value atIndexedSubscript:(NSUInteger)index { instructions } or |
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 | bracket_name alias "[]" (index: TYPE): TYPE | |
Python | def __getitem__(self, index): | def __getitem__(self, index): | def __setitem__(self, index, value): |
Visual Basic .NET | Default Property Item(Index As type) As type | Default ReadOnly Property Item(Index As type) As type | Default WriteOnly Property Item(Index As type) As type |
PHP | [39] | ||
Perl | [40] | ||
Raku | «our «type »»«multi »method postcircumfix:<[ ]> is rw («$self: » type $index) { instructions ... return value;} or | «our «type »»«multi »method postcircumfix:<[ ]>(«$self: » type $index) { instructions ... return value;} or | — |
Ruby | def [](index) | def [](index) | def []=(index, value) |
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 | get[index «as type»] as type | set[index «as type»] as type |
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 | Shared Widening Operator CType(operand As type) As returntype |
PHP | — | |
Perl | ||
Raku | multi method type«($self:)» is export { instructions } | |
Ruby | — | |
Windows PowerShell | ||
OCaml | ||
F# | ||
COBOL | — | |
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 | x.field or | cls::member | ns::member | |
Objective-C | [x method«:parameter «bar:parameter ...»»] | x->field | x.property (2.0 only) or | [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.field or | cls.method«(parameters)» or | ns::member | |
OCaml | x#method «parameters» | — | |||
JavaScript | x.method(parameters) | x.field | x.property | cls.member | — |
COBOL | INVOKE x"method" «USING parameters» «RETURNING result» or | — | property OF x | INVOKE cls "method" «USING parameters» «RETURNING result» or | — |
Cobra | x.method«(parameters)» | x.field | x.property | cls.member | ns.member |
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 | — |
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 |
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 | |
Java | x.toString() | x.clone() [53] | x.equals(y) | x.compareTo(y) [54] | x.hashCode() | System | |
JavaScript | x.toString() | ||||||
D | x.toString() or | x.stringof | x == y or | x.opCmp(y) | x.toHash() | ||
eC | x.OnGetString(tempString, null, null) or | 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) | |
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 [70] | Storable [71] | Scalar [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 == y or | 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 | Oo.id x | |||
F# | string x or x | sprintf "%A" x | x.Clone() | x = y or x | compare x y or x | hash x or x | |
COBOL | — |
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 |
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 | |
Ruby | x.class | x.instance_of?(type) or | — [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] | — | ||
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 | — |
Precondition | Postcondition | Check | Invariant | Loop | |
---|---|---|---|---|---|
ABAP Objects | — | ||||
C++ | |||||
C# | Spec#: | Spec#: | |||
Java | — | ||||
Objective-C | |||||
Visual Basic .NET | |||||
D | f | f | assert(expression) | invariant() { expression } | |
Eiffel | f | f | f | class X | from instructions |
Python | — | ||||
PHP | |||||
Perl | |||||
Raku | PRE { condition } | POST { condition } | |||
Ruby | — | ||||
Windows PowerShell | |||||
OCaml | |||||
F# | |||||
COBOL |
NSObject
for Cocoa and GNUstep, or Object
otherwise.@interface
portion is placed into a header file, and the @interface
portion is placed into a separate source code file."member_name(parameters)"
"class_name(parameters)".
classaddInstVarName:field.classremoveInstVarName:field.
defbar():doc="The bar property."deffget(self):returnself._bardeffset(self,value):self._bar=valuereturnlocals()bar=property(**bar())
x->method(«exporting parameter = argument» «importing parameter = argument» «changing parameter = argument» «returning value(parameter)»
parameter = argument
can be repeated if there are several parametersBaseClassName::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.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.==
operatorclone()
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.Comparable
for this method to be standardized.copyWithZone:
methodcompare:
is the conventional name for the comparison method in Foundation classes. However, no formal protocol existsPrintable
protocolDebugPrintable
protocolEquatable
protocolComparable
protocolhashValue
protocol__str__()
method__repr__()
method__copy__()
method__eq__()
method__cmp__()
method__hash__()
method. Not all types are hashable (mutable types are usually not hashable)__clone()
methodx
is a class object, [x class]
returns only x
. The runtime method object_getClass(x)
will return the class of x
for all objects.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.
In object-oriented (OO) and functional programming, an immutable object is an object whose state cannot be modified after it is created. This is in contrast to a mutable object, which can be modified after it is created. In some cases, an object is considered immutable even if some internally used attributes change, but the object's state appears unchanging from an external point of view. For example, an object that uses memoization to cache the results of expensive computations could still be considered an immutable object.
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.
In object-oriented programming (OOP), the object lifetime of an object is the time between an object's creation and its destruction. Rules for object lifetime vary significantly between languages, in some cases between implementations of a given language, and lifetime of a particular object may vary from one run of the program to another.
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, in languages such as C++, and Object Pascal, a virtual function or virtual method is an inheritable and overridable function or method for which dynamic dispatch is facilitated. This concept is an important part of the (runtime) polymorphism portion of object-oriented programming (OOP). In short, a virtual function defines a target function to be executed, but the target might not be known at compile time.
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 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.
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.
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.
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 keyword class
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 is private. The private members are not accessible outside the class; they can be accessed only through methods of the class. The public members form an interface to the class and are accessible outside the class.
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.
C++11 is a version of the ISO/IEC 14882 standard for the C++ programming language. C++11 replaced the prior version of the C++ standard, called C++03, and was later replaced by C++14. The name follows the tradition of naming language versions by the publication year of the specification, though it was formerly named C++0x because it was expected to be published before 2010.
clone
is a method in the Java programming language for object duplication. In Java, objects are manipulated through reference variables, and there is no operator for copying an object—the assignment operator duplicates the reference, not the object. The clone method provides this missing functionality.
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.