Porovnání programovacích jazyků (objektově orientované programování) - Comparison of programming languages (object-oriented programming)

Tento srovnání programovacích jazyků porovnává jak objektově orientované programování jazyky jako C ++, Jáva, Pokec, Objekt Pascal, Perl, Krajta a další manipulují datové struktury.

Konstrukce a ničení objektů

	konstrukce	zničení
Objekty ABAP	`data proměnná typ ref třída . vytvořit objekt proměnná «export parametr = argument ».`^[1]	^[2]^[3]
APL (Dyalog)	`proměnná← ⎕NOVINKA «parametry» třídy`	`⎕EX 'proměnná'`
C ++ (STL )	`proměnná třídy «(parametry)»;` nebo `třída *proměnná = Novýtřída"(parametry)»;`	`vymazat ukazatel;`
C#	`proměnná třídy = nový třída(parametry);`	`proměnná.Dispose ();`^[3]
Jáva		^[3]
D		`zničit(proměnná);`
eC	`třída «popisovač instance» { «Přiřazení vlastností / datových členů, přepsání metody instance» }`	`vymazat popisovač instance;`
Cíl-C (Kakao )	`třída proměnná = [[třída alloc] init];` nebo `třída proměnná = [[třída přidělit] initWithFoo:parametr «bar:parametr ..."];`	`[proměnná uvolnění];`
Rychlý	`nechat proměnná = třída(parametry)`
Krajta	`proměnná = třída(parametry)`	`del proměnná`^[3] (Normálně není potřeba)
Visual Basic .NET	`Ztlumit proměnná Jako nový třída(parametry)`	`proměnná. Zlikvidujte ()`^[3]
Xojo	`Ztlumit proměnná Jako nový třída(parametry)`	`proměnná = Nula`
Eiffelova	`vytvořit proměnná` nebo `vytvořit «{TYP}»Proměnná.make_foo «(parametry)»` nebo `proměnná : = vytvořit {TYP}` nebo `proměnná : = vytvořit {TYP}.make_foo «(parametry)»`	^[3]
PHP	`$proměnná = nový třída«(parametry)»;`	`zrušeno ($proměnná);`^[3]
Perl 5	`«můj »$proměnná = třída-> nový«(parametry)»;`	`undef ($proměnná);`
Raku	`«můj »$ Proměnná = třída.Nový«(parametry)»;`	`$ proměnná. nedefinovat;`
Rubín	`proměnná = třída.Nový«(parametry)»`	^[3]
Windows PowerShell	`$proměnná = Nový objekt «-TypeName»Třída« «-ArgumentList»Parametry»`	`Odebrat proměnnou «-Název»Proměnná`
OCaml	`nechat proměnná = nový «parametry» třídy` nebo `nechat proměnná = objekt členů konec`^[4]	^[3]
F#	`nechat proměnná = «Nový "třída(«Parametry»)`	^[3]
Pokec	Třída je Object. Stačí obvykle poslat zprávu do kurzu `#Nový` nebo `#Nový:`a mnoho dalších, například: Směřovat X: 10 y: 20.Pole s: -1 s: 3 s: 2.
JavaScript	`var proměnná = nový třída «(parametry)»` nebo `var proměnná = { «Klíč1: hodnota1 «, klíč2: hodnota2 ... »»}`	^[3]
Objekt Pascal (Delphi )	`ClassVar := ClassType.ConstructorName(parametry);`	`ClassVar.Volný, uvolnit;`
Scala	val obj = Nový Objekt // žádné parametryval obj = Nový Objekt(arg0, arg1, arg2...)val obj = Objekt(arg0, arg1, arg2...) // třída případůval obj = Nový Objekt(arg0, arg1, param1 = hodnota1, ...) // pojmenované parametry	^[3]
COBOL	`FAKTURUJTE třída "NOVÝ" VRÁCENÍ proměnná` nebo `HÝBAT SE třída::"NOVÝ" NA proměnná`
Kobra	`proměnná «tak jako třída" = třída(parametry)`	`proměnná.zlikvidujte`
ISLISP	`(setq proměnná (vytvořit (třída [: hodnota pole-1-1 [: hodnota pole-2-2] ..])))`	^[3]

Deklarace třídy

	třída	protokol	jmenný prostor
Objekty ABAP	`třída název definice «dědí z nadřazená třída ». «rozhraní: rozhraní.»Prohlášení o metodě a poli endclass. třída název implementace. method_implementations endclass.`	`rozhraní název. členů endinterface.`	N / A
APL (Dyalog)	`:Třída název ":rodičovská třída »«,rozhraní »` `členů` `: EndClass`	`:Rozhraní název` `členů` `: Konec rozhraní`	`: Jmenný prostor název` `členů` `: EndNamespace`
C ++ (STL)	`třída název" : veřejné rodičovské třídy`^[5]`» { členů };`		`jmenný prostor název { členů }`
C#	`třída název" : «Parentclass» «, rozhraní »» { členů }`	`rozhraní název": nadřazená rozhraní » { členů }`	`jmenný prostor název { členů }`
D	`třída název" : «Parentclass» «, rozhraní »» { členů }`	`rozhraní název": nadřazená rozhraní » { členů }`	`modul název; členů`
eC	`třída název": základní třída » { «Výchozí přiřazení hodnot členů» «členové» }`		`jmenný prostor název;`
Jáva	`třída název" rozšiřuje rodičovská třída »« nářadí rozhraní » { členů }`	`rozhraní název"rozšiřuje nadřazená rozhraní » { členů }`	`balík název; členů`
PHP		`rozhraní název"rozšiřuje nadřazená rozhraní » { členů }`	`jmenný prostor název; členů`
Cíl-C	`@rozhraní název" : nadřazená třída »`^[6]`«< protokoly >» { pole_instance } method_and_property_declarations @konec @implementace název method_implementations @konec`^[7]	`@protokol název"< rodičovské protokoly >»Členové @konec`	^[8]
Rychlý	`třída název" : «Parentclass» «, protokoly »» { členů }`	`protokol název" : rodičovské protokoly » { členů }`
Krajta	`třída název"(rodičovské třídy^[5])»: Záložka ↹členů`	^[9]	`__all__ = [ člen1,člen2,... ]`
Visual Basic .NET	`Třída název" Dědí rodičovská třída »« Nářadí rozhraní » členů Konec třídy`	`Rozhraní název" Dědí nadřazená rozhraní » členů Konec rozhraní`	`Jmenný prostor název členů Konec jmenného prostoru`
Xojo	`Třída název" Dědí rodičovská třída »« Nářadí rozhraní » členů Konec třídy`	`Rozhraní název" Dědí nadřazená rozhraní » členů Konec rozhraní`	`Modul název členů Koncový modul`
Eiffelova	`třída název" zdědit rodičovské třídy^[5]» členů konec`	N / A
Perl	`balík název; «@ISA = qw (rodičovské třídy^[5]);»Členové 1;`		`balík název; členů`
Raku	`třída název "je rodičovská třída «je rodičovská třída ...^[5]»» «dělá role «dělá role ... »» { členů }`	`role název "dělá role «dělá role ... »» { členů }`	`modul název { členů }`
Rubín	`třída název"< nadřazená třída » členů konec`		`modul název členů konec`
Windows PowerShell	N / A
OCaml	`třída název «parametry» = objekt «(já)» «zdědit «parametry» «rodičovská třídazdědit «parametry» nadřazené třídy ... ...^[5]»» Členové konec`		`modul název členů`
F#	`typ název"(parametry)»«jako toto» = třída «zdědit rodičovská třída «(parametry)» «jako základna»» Členové «rozhraní rozhraní s implementace "rozhraní rozhraní s implementace ..."" konec`	`typ název = rozhraní členů konec`	`jmenný prostor název členů`
Pokec	^[10]		^[11]
JavaScript (ES6)	`třída` `název "rozšiřuje nadřazená třída » { členů }`
Objekt Pascal (Delphi)	`ClassName = Třída «(ClassParent, rozhraní)» soukromé // Soukromí členové (zahrnují metody a pole) veřejnost // Veřejní členové chráněný // Chránění členové zveřejněno // Publikovaní členové konec;`		`balík název; členů`
Scala	třída ConcreteClass(konstruktor parametry)rozšiřuje Nadřazená třídas Vlastnost 1 s Vlastnost 2 s Vlastnost 2 {// členové}	vlastnost Název_vlastnostirozšiřuje OtherTrait1s OtherTrait2 s OtherTrait3 {// členové}	balík název
COBOL	`ČÍSLO TŘÍDY. název"DĚDÍCÍ« Z»Rodičovské třídy».` `TOVÁRNA« NÁSTROJE rozhraní ».` `členy třídy` `KONEC TOVÁRNY.` `OBJEKT« NÁSTROJE rozhraní ».` `členové instance` `KONEC OBJEKTU.` `KONEC TŘÍDY název.`	`ID ROZHRANÍ. název"DĚDÍCÍ« Z»Rozhraní».` `členů` `KONEC ROZHRANÍ název.`	N / A
Kobra	`třída název "dědí rodičovská třída »«nářadí rozhraní » Záložka ↹ členů`	`rozhraní název "dědí nadřazená rozhraní » Záložka ↹ členů`	`jmenný prostor název Záložka ↹ členů`
ISLISP	`(defclass name (základní třída) ((x : initform 0 : přistupující osoba get-x : initarg X)) (: abstractp nula))`

Členové třídy

Konstruktory a destruktory

	konstruktor	destruktor	finalizátor^[12]
Objekty ABAP	`konstruktor metod «import parametr = argument » konstruktor metody. instrukce endmethod.`^[13]	N / A
APL (Dyalog)	`∇ název` `: Implementuje konstruktor «:Základna «Expr» »` `instrukce` `∇`		`∇ název` `: Implementuje destruktor` `instrukce` `∇`
C ++ (STL)	`třída(«Parametry») «: inicializátory`^[14]`» { instrukce }`	`~třída() { instrukce }`
C#	`třída(«Parametry») { instrukce }`	`void Dispose () { instrukce }`	`~třída() { instrukce }`
D	`tento(«Parametry») { instrukce }`		`~ toto () { instrukce }`
eC	`třída() { instrukce }`	`~ třída() { instrukce }`
Jáva	`třída(«Parametry») { instrukce }`		`void finalize () { instrukce }`
Eiffelova	^[15]		^[16]
Objective-C (kakao)	`- (id) init { instrukce... návrat já; } nebo - (id)initWithFoo:parametr «bar:parametr ..." { instrukce... návrat já; }`	`- (void) dealloc { instrukce }`	`- (void) finalize { instrukce }`
Rychlý	`init («Parametry») { instrukce }`	`deinit { instrukce }`
Krajta	`def __init __ (vlastní«, parametry »): Záložka ↹ instrukce`		`def __del __ (já): Záložka ↹ instrukce`
Visual Basic .NET	`Sub nový («Parametry») instrukce End Sub`	`Sub Dispose () instrukce End Sub`	`Přepíše Sub Finalize () instrukce End Sub`
Xojo	`Pomocný konstruktér («Parametry») instrukce End Sub`	`Sub destruktor () instrukce End Sub`
PHP	`funkce __construct («Parametry») { instrukce }`	`funkce __destruct () { instrukce }`
Perl	`pod nový {my ($ class«, parametry ») = @_; moje $ self = {}; pokyny ... žehnej ($ self, $ class); vrátit $ self; }`	`sub DESTROY {my ($ self) = @_; instrukce }`
Raku	`podmet BUILD { instrukce } nebo «multi » metoda nová («« $ Já: »Parametry») {self.bless (*, pole1 => hodnota1, ...); ... pokyny }`	`podmetoda ZNIČIT { instrukce }`
Rubín	`def inicializovat«(parametry)» instrukce konec`	N / A
Windows PowerShell	N / A
OCaml	`inicializátor instrukce`^[17]	N / A
F#	`dělat pokyny nebo Nový(parametry) = výraz`^[18]	`člen this.Dispose () = instrukce`	`přepsat this.Finalize () = instrukce`
JavaScript	`funkce název(«Parametry») { instrukce }`^[19]	N / A
JavaScript (ES6)	`konstruktor (``«Parametry») { instrukce }`
COBOL	N / A^[20]	N / A
Kobra	`cue init (parametry) Záložka ↹ base.init Záložka ↹ instrukce`	`def zlikvidovat Záložka ↹ instrukce`
ISLISP	`(defmethod initialize-object ((instance ) initvalues)`

Pole

	veřejnost	soukromé	chráněný	příteli
Objekty ABAP	`veřejná sekce.^[21] data pole typ typ.`	`soukromá sekce.^[21] data pole typ typ.`	`chráněná sekce.^[21] data pole typ typ.`	^[22]
APL (Dyalog)	`: Polní veřejnost pole «← hodnota»`	`:Pole «Soukromé»Pole«← hodnota»`
C ++ (STL)	`veřejnost: pole typu;`	`soukromé: zadejte pole;`	`chráněný: zadejte pole;`	^[23]
C#	`veřejnost zadejte pole «= hodnota";`	`soukromé zadejte pole «= hodnota";`	`chráněný zadejte pole «= hodnota";`	`vnitřní zadejte pole «= hodnota";`
D				`balík zadejte pole «= hodnota";`
Jáva			`chráněný zadejte pole «= hodnota";`	`zadejte pole «= hodnota";`
eC	`veřejnost pole typu;`	`soukromé pole typu;`
Eiffelova	`Vlastnosti pole: TYPE`	`funkce {NONE} pole: TYPE`	`Vlastnosti {current_class} pole: TYPE`	`funkce {FRIEND} pole: TYPE`
Cíl-C	`@veřejnost pole typu;`	`@ soukromý pole typu;`	`@chráněný pole typu;`	`@balík pole typu;`
Rychlý	N / A
Pokec	N / A		^[24]	N / A
Krajta	`já.pole = hodnota`^[25]	N / A^[26]	N / A
Visual Basic .NET	`Veřejnost pole Tak jako typ «= hodnota"`	`Soukromé pole Tak jako typ «= hodnota"`	`Chráněný pole Tak jako typ «= hodnota"`	`Příteli pole Tak jako typ «= hodnota"`
Xojo	`Veřejnost pole Tak jako typ «= hodnota"`	`Soukromé pole Tak jako typ «= hodnota"`	`Chráněný pole Tak jako typ «= hodnota"`	N / A
PHP	`veřejné $pole «= hodnota";`	`soukromé $pole «= hodnota";`	`chráněno $pole «= hodnota";`
Perl	`$ self -> {pole} = hodnota;`^[25]	N / A
Raku	`má«Typ» $.pole"je rw»`	`má«Typ» $!pole`	N / A
Rubín	N / A		`@pole = hodnota`^[25]
Windows PowerShell	`Přidat člena «-MemberType »Poznámka Vlastnost «-Název "Bar "-Hodnota "hodnota -InputObject proměnná`	N / A
OCaml	N / A		`val «proměnlivý»Pole = hodnota`	N / A
F#	N / A	`nechat «proměnlivý»Pole = hodnota`	N / A	N / A
JavaScript	`tento.pole = hodnota tento["pole"] = hodnota`^[25]
COBOL	N / A	klauzule pole číslo-úrovně.^[27]	N / A	N / A
Kobra	`var pole «tak jako typ »«= hodnota"`	`var __pole «tak jako typ »«= hodnota"`	`var _pole «tak jako typ »«= hodnota"`
ISLISP	`(pole : initform hodnota : přistupující osoba název přístupového objektu : initarg klíčové slovo)`

Metody

	základní / neplatná metoda	metoda vracející hodnotu
Objekty ABAP	`metody název "import parametr = argument »«export parametr = argument »«měnící se parametr = argument »«návratová hodnota (parametr)» metoda název. instrukce endmethod.`^[28]	^[29]
APL (Dyalog)	`∇ «Levý argument» název «pravý argument»` `instrukce` `∇`	`∇ výsledek ← «Levý argument» název «pravý argument»` `instrukce` `∇`
C ++^[30] `typ foo(«Parametry»);` Implementace metod je obvykle poskytována v samostatném zdrojovém souboru s následující syntaxí `typová třída::foo(«Parametry») { instrukce }`^[31]	`prázdnota foo(«Parametry») { instrukce }`	`typ foo(«Parametry») { pokyny ... vrátit se hodnota; }`
C#
D
Jáva
eC	`prázdnota «« Typ 'tohoto' »::»Foo(«Parametry») { instrukce }`	`typ «« typ tohoto »::»Foo(«Parametry») { pokyny ... vrátit se hodnota; }`
Eiffelova	`foo ( «Parametry» ) dělat instrukce konec`	`foo ( «Parametry» ): TYP dělat instrukce... Výsledek : = hodnota konec`
Cíl-C	`- (neplatné)foo «:parametr «bar:parametr ..."" { instrukce }`	`- (typ)foo «:parametr «bar:parametr ..."" { instrukce... vrátit se hodnota; }`
Rychlý	`func foo(«Parametry») { instrukce }`	`func foo(«Parametry») -> typ { instrukce... vrátit se hodnota }`
Krajta	`def foo(já«, parametry »): Záložka ↹instrukce`	`def foo(já«, parametry »): Záložka ↹instrukce Záložka ↹ vrátit se hodnota`
Visual Basic .NET	`Sub Foo(«Parametry») instrukce End Sub`	`Funkce Foo(«Parametry») Tak jako typ instrukce ... Vrátit se hodnota Ukončit funkci`
Xojo	`Sub Foo(«Parametry») instrukce End Sub`	`Funkce Foo(«Parametry») Tak jako typ instrukce ... Vrátit se hodnota Ukončit funkci`
PHP	`funkce foo(«Parametry») «: Void» { instrukce }`	`funkce foo(«Parametry»)«: typ» { pokyny ... vrátit se hodnota; }`
Perl	`sub foo {my ($ self«, parametry ») = @_; instrukce }`	`sub foo {my ($ self«, parametry ») = @_; pokyny ... vrátit se hodnota; }`
Raku	`«má »«multi »metoda foo(«« $ Já: »Parametry») { instrukce }`	`«má «Typ» »«multi »metoda foo(«« $ Já: »Parametry») { pokyny ... vrátit se hodnota; }`
Rubín	`def foo «(parametry)» instrukce konec`	`def foo «(parametry)» instrukce výraz vedoucí k návratové hodnotě konec nebo def foo «(parametry)» instrukce vrátit se hodnota konec`
Windows PowerShell	`Přidat člena «-MemberType» ScriptMethod «-Název»Foo«-Hodnota» { «param (parametry)»instrukce } -InputObject proměnná`	`Přidat člena «-MemberType» ScriptMethod «-Název»Foo«-Hodnota» { «param (parametry)»pokyny ... vrátit se hodnota } -InputObject proměnná`
OCaml	N / A	`metoda foo «parametry» = výraz`
F#	N / A	`člen to.foo(«Parametry») = výraz`
JavaScript	`tento.metoda = funkce («Parametry») {instrukce} název".prototyp.metoda = funkce («Parametry») {instrukce}`^[32]	`tento.metoda = funkce («Parametry») {instrukce... vrátit se hodnota;} název".prototyp.metoda = funkce («Parametry») {instrukce... vrátit se hodnota;}`^[32]
Javascript (ES6)	`foo(«Parametry») {instrukce}`	`foo(«Parametry») {instrukce... vrátit se hodnota;}`
COBOL	`ID METODY. foo. «DIVIZE DAT. SEKCE LINKAGE. deklarace parametrů » ROZDĚLENÍ POSTUPŮ« POUŽITÍM parametry ».` `instrukce` `KONECNÍ METODA foo.`	`ID METODY. foo. DIVIZE DAT. SEKCE LINKAGE. «Deklarace parametrů» result-var deklarace ROZDĚLENÍ POSTUPŮ« POUŽITÍM parametry » VRÁCENÍ výsledek-var.` `instrukce` `KONECNÍ METODA foo.`
Kobra	`def foo(parametry) Záložka ↹ instrukce`	`def foo(parametry) tak jako typ Záložka ↹ instrukce Záložka ↹ vrátit se hodnota`
ISLISP	`(defgenerický metoda (arg1 arg2)) (defmethod metoda ((arg1 arg2 ) ...)`

Vlastnosti

Jak deklarovat vlastnost s názvem "Bar"

Ručně implementováno

	číst psát	pouze ke čtení	pouze pro zápis
Objekty ABAP	N / A
APL (Dyalog)	`:Vlastnictví Bar` `∇ výsledek ← Získat` `instrukce` `∇` `∇ Nastavit argumenty` `instrukce` `∇` `: EndProperty Bar`	`:Vlastnictví Bar` `∇ výsledek ← Získat` `instrukce` `∇` `: EndProperty Bar`	`:Vlastnictví Bar` `∇ Nastavit argumenty` `instrukce` `∇` `: EndProperty Bar`
C ++ (STL)	N / A
C#	`typ Bar { dostat { pokyny ... vrátit se hodnota; } nastavit { instrukce } }`	`typ Bar { dostat { pokyny ... vrátit se hodnota; } }`	`typ Bar {set { instrukce } }`
D	`@vlastnictví lišta typu() { pokyny ... vrátit se hodnota; } @vlastnictví lišta typu(hodnota typu) { pokyny ... vrátit se hodnota; }`	`@vlastnictví lišta typu() { pokyny ... vrátit se hodnota; }`	`@vlastnictví lišta typu(hodnota typu) { pokyny ... vrátit se hodnota; }`
eC	`vlastnictví typ Bar { dostat { pokyny ... vrátit se hodnota; } nastavit { instrukce } }`	`vlastnictví typ Bar { dostat { pokyny ... vrátit se hodnota; } }`	`vlastnictví typ Bar {set { instrukce } }`
Jáva	N / A
Objective-C 2.0 (kakao)	`@property (readwrite) lišta typu;` a pak dovnitř `@implementace - (typ)bar { instrukce } - (neplatné)setBar:(typ)hodnota { instrukce }`	`@property (pouze pro čtení) lišta typu;` a pak dovnitř `@implementace - (typ)bar { instrukce }`	N / A
Rychlý	`var bar : typ { dostat { instrukce } nastavit«(newBar)» { instrukce } }`	`var bar : typ { instrukce }`	N / A
Eiffelova	`Vlastnosti -- Přístup x: TYPE přiřadit set_x Vlastnosti - Nastavení set_x (a_x: jako X) dělat instrukce zajistit x_set: ověření konec`
Krajta	`def setBar(já, hodnota): Záložka ↹ instrukce def getBar(já): Záložka ↹instrukce Záložka ↹ vrátit se hodnota bar = vlastnost (getBar, setBar)`^[33]	`def getBar(já): Záložka ↹ instrukce Záložka ↹ vrátit se hodnota bar = vlastnost (getBar)`	`def setBar(já, hodnota): Záložka ↹ instrukce bar = vlastnost (fset = setBar)`
Visual Basic .NET	`Vlastnictví Bar() Tak jako typ Dostat instrukce Vrátit se hodnota Konec Get Nastavit (ByVal Hodnota Tak jako typ) instrukce Konec sady Ukončit vlastnost`	`Vlastnost ReadOnly Bar() Tak jako typ Dostat instrukce Vrátit se hodnota Konec Get Ukončit vlastnost`	`Vlastnost WriteOnly Bar() Tak jako typ Nastavit (ByVal Hodnota Tak jako typ) instrukce Konec sady Ukončit vlastnost`
Xojo	`ComputedProperty Bar() Tak jako typ Dostat instrukce Vrátit se hodnota Konec Get Nastavit (ByVal Hodnota Tak jako typ) instrukce Konec sady Ukončit vypočítané vlastnictví`	`ComputedProperty Bar() Tak jako typ Dostat instrukce Vrátit se hodnota Konec Get Ukončit vypočítané vlastnictví`	`ComputedProperty Bar() Tak jako typ Set (hodnota Tak jako typ) instrukce Konec sady Ukončit vypočítané vlastnictví`
PHP	`funkce __get ($ nemovitost) { přepínač ($ nemovitost) { případ 'Bar' : pokyny ... vrátit se hodnota; } } funkce __set ($ nemovitost, $ hodnota) { přepínač ($ nemovitost) { případ 'Bar' : instrukce } }`	`funkce __get ($ nemovitost) { přepínač ($vlastnictví) { případ 'Bar' : pokyny ... vrátit se hodnota; } }`	`funkce __set ($ nemovitost, $ hodnota) { přepínač ($ nemovitost) { případ 'Bar' : instrukce } }`
Perl	`sub Bar { můj $ self = posun; -li (můj $ Bar = posun) { # seřizovač $ self -> {Bar} = $ Bar; vrátit $ self; } jiný { # getter vrátit se $ self -> {Bar}; } }`	`sub Bar { můj $ self = posun; -li (můj $ Bar = posun) { # pouze ke čtení zemřít "Bar je jen pro čtení"; } jiný { # getter vrátit se $ self -> {Bar}; } }`	`sub Bar { můj $ self = posun; -li (můj $ Bar = posun) { # seřizovač $ self -> {Bar} = $ Bar; vrátit $ self; } jiný { # pouze pro zápis zemřít "Bar je pouze pro zápis"; } }`
Raku	N / A
Rubín	`def bar instrukce výraz vedoucí k návratové hodnotě konec def bar=(hodnota) instrukce konec`	`def bar instrukce výraz vedoucí k návratové hodnotě konec`	`def bar=(hodnota) instrukce konec`
Windows PowerShell	`Přidat člena «-MemberType »ScriptProperty «-Název "Bar "-Hodnota »{ pokyny ... vrátit se hodnota } «-Druhá hodnota »{ instrukce } -InputObject proměnná`	`Přidat člena «-MemberType »ScriptProperty «-Název "Bar "-Hodnota »{ pokyny ... vrátit se hodnota} -InputObject proměnná`	`Přidat člena «-MemberType »ScriptProperty «-Název "Bar -Druhá hodnota { instrukce } -InputObject proměnná`
OCaml	N / A
F#	`člen to.Bar s get () = výraz a nastavit (hodnota) = výraz`	`člen to.Bar = výraz`	`člen to.Bar se sadou (hodnota) = výraz`
JavaScript (ES6)	`dostat bar(«Parametry») { pokyny ... vrátit se hodnota}set bar(«Parametry») { instrukce }`	`dostat` `bar(«Parametry») { pokyny ... vrátit se hodnota}`	`soubor bar(«Parametry») { instrukce }`
COBOL	`ID METODY. ZÍSKEJTE VLASTNICTVÍ bar. DIVIZE DAT. SEKCE LINKAGE. deklarace return-var NÁVRATNOST ROZDĚLENÍ POSTUPŮ návratová var.` `instrukce` `KONECNÍ METODA. ID METODY. NASTAVTE VLASTNICTVÍ bar. DIVIZE DAT. SEKCE LINKAGE. deklarace value-var POUŽITÍ DIVIZE POSTUPŮ hodnota-var.` `instrukce` `KONECNÍ METODA.`	`ID METODY. ZÍSKEJTE VLASTNICTVÍ bar. DIVIZE DAT. SEKCE LINKAGE. deklarace return-var NÁVRATNOST ROZDĚLENÍ POSTUPŮ návratová var.` `instrukce` `KONECNÍ METODA.`	`ID METODY. NASTAVTE VLASTNICTVÍ bar. DIVIZE DAT. SEKCE LINKAGE. deklarace value-var POUŽITÍ DIVIZE POSTUPŮ hodnota-var.` `instrukce` `KONECNÍ METODA.`
Kobra	`pro bar "tak jako typ" Záložka ↹ dostat Záložka ↹Záložka ↹ instrukce Záložka ↹Záložka ↹ vrátit se hodnota Záložka ↹ soubor Záložka ↹Záložka ↹ instrukce`	`dostat bar "tak jako typ" Záložka ↹ instrukce Záložka ↹ vrátit se hodnota`	`soubor bar "tak jako typ" Záložka ↹ instrukce`
ISLISP	N / A

Automaticky implementováno

	číst psát	pouze ke čtení	pouze pro zápis
Objekty ABAP	N / A
C ++ (STL)	N / A
C#	`typ Bar { dostat; soubor; }`	`typ Bar { dostat; soukromá sada; }`	`typ Bar {soukromé získání; soubor; }`
D	N / A
Jáva	N / A
Objective-C 2.0 (kakao)	`@property (readwrite) lišta typu;`a pak dovnitř `@implementace @syntetizovat bar;`	`@property (pouze pro čtení) lišta typu;`a pak dovnitř `@implementace @syntetizovat bar;`	N / A
Rychlý	`var bar : typ`	`nechat bar : typ`	N / A
Eiffelova
Krajta	`@vlastnictví def bar(já): Záložka ↹instrukce @bar. nastavovač def bar(já, hodnota): Záložka ↹instrukce`	`@vlastnictví def bar(já): Záložka ↹instrukce`	`bar = vlastnost () @bar. nastavovač def bar(já, hodnota): Záložka ↹instrukce`
Visual Basic .NET	`Vlastnictví Bar Tak jako typ"= initial_value »(VB 10)`
PHP
Perl^[34]	`použití základna Q w(Class :: Accessor); __BALÍK__->mk_accessors('Bar');`	`použití základna Q w(Class :: Accessor); __BALÍK__->mk_ro_accessors('Bar');`	`použití základna Q w(Class :: Accessor); __BALÍK__->mk_wo_accessors('Bar');`
Raku	N / A
Rubín	`attr_accessor :bar`	`attr_reader :bar`	`attr_writer :bar`
Windows PowerShell
OCaml	N / A
F#	`člen val Bar = hodnota s dostat, nastavit`
COBOL	`klauzule s číslem úrovně VLASTNICTVÍ.`	`klauzule s číslem úrovně VLASTNICTVÍ «S» BEZ SET`	`klauzule s číslem úrovně VLASTNICTVÍ «S» NENÍ ZÍSKÁNO.`
Kobra	`pro bar od var «tak jako typ"`	`dostat bar od var «tak jako typ"`	`soubor bar od var «tak jako typ"`

Přetížené operátory

Standardní operátoři

	unární	binární	volání funkce
Objekty ABAP	N / A
C ++ (STL)	`typ operátor symbol () { instrukce }`	`typ operátor symbol (zadejte operand2) { instrukce }`	`typ operátor () («Parametry») { instrukce }`
C#	`statický typ operátor symbol(zadejte operand) { instrukce }`	`statický typ operátor symbol(zadejte operand1, zadejte operand2) { instrukce }`	N / A
D	`typ opUnary (řetězec s) () pokud (s == "symbol") { instrukce }`	`typ opBinary (řetězec s)(zadejte operand2) pokud (s == "symbol") { instrukce } typ opBinaryRight (řetězec s)(zadejte operand1) pokud (s == "symbol") přepínač (s) { instrukce }`	`typ opCall («Parametry») { instrukce }`
Jáva	N / A
Cíl-C	N / A
Rychlý	`func symbol(operand1 : typ) -> návratový typ { instrukce }` (mimo třídu)	`func symbol(operand1 : typ1, operand2 : typ2) -> návratový typ { instrukce }` (mimo třídu)
Eiffelova^[35]	`op_name alias "symbol": TYP dělat instrukce konec`	`op_name alias "symbol" (operand: TYPE1): TYP 2 dělat instrukce konec`
Krajta	`def __opname__(já): Záložka ↹instrukce Záložka ↹ vrátit se hodnota`	`def __opname__(já, operand2): Záložka ↹instrukce Záložka ↹ vrátit se hodnota`	`def __call __ (self«, parametry »): Záložka ↹instrukce Záložka ↹ vrátit se hodnota`
Visual Basic .NET	`Sdílený operátor symbol(operand Tak jako typ) Tak jako typ instrukce Koncový operátor`	`Sdílený operátor symbol(operand1 Tak jako typ, operand2 Tak jako typ) Tak jako typ instrukce Koncový operátor`	N / A
Xojo	`Funkce Operátor_název(operand Tak jako typ) Tak jako typ instrukce Ukončit funkci`	N / A
PHP	^[36]		`funkce __invoke («Parametry») { instrukce } (PHP 5,3+)`
Perl	`použít přetížení "symbol"=> sub {my ($ self) = @_; instrukce };`	`použít přetížení "symbol"=> sub {my ($ self, $ operand2, $ operands_reversed) = @_; instrukce };`
Raku	`«náš «Typ» »«multi »prefix metody: <symbol> («$ Operand: ») { pokyny ... vrátit se hodnota; } nebo «náš «Typ» »«multi »postfix metody: <symbol> («$ Operand: ») { pokyny ... vrátit se hodnota; } nebo «náš «Typ» »«multi »metoda circumfix: <symbol1 symbol2> («$ Operand: ») { pokyny ... vrátit se hodnota; }`	`«náš «Typ» »«multi »metoda infix: <symbol> («$ Operand1: »Typ operand2) { pokyny ... vrátit se hodnota; }`	`«náš «Typ» »«multi »metoda postcircumfix: <()> («$ Já: »« Parametry ») { instrukce }`
Rubín	`def symbol instrukce výraz vedoucí k návratové hodnotě konec`	`def symbol(operand2) instrukce výraz vedoucí k návratové hodnotě konec`	N / A
Windows PowerShell	N / A
OCaml	N / A
F#	`statický člen (symbol) operand = výraz`	`statický člen (symbol) (operand1, operand2) = výraz`	N / A
COBOL	N / A
ISLISP	N / A

Indexery

	číst psát	pouze ke čtení	pouze pro zápis
Objekty ABAP	N / A
APL (Dyalog)	`: Vlastnost očíslovaná jako výchozí název` `∇ výsledek ← Získat` `instrukce` `∇` `∇ Nastavit argumenty` `instrukce` `∇` `: EndProperty Bar`	`: Vlastnost očíslovaná jako výchozí Bar` `∇ výsledek ← Získat` `instrukce` `∇` `: EndProperty Bar`	`: Vlastnost očíslovaná jako výchozí Bar` `∇ Nastavit argumenty` `instrukce` `∇` `: EndProperty Bar`
C ++ (STL)	`typ& operator [] (index typu) { instrukce }`	`typ operátor[](index typu) { instrukce }`
C#	`typ tento[index typu] { dostat{ instrukce } soubor{ instrukce } }`	`typ tento[index typu] { dostat{ instrukce } }`	`typ tento[index typu] {set { instrukce } }`
D	`typ opIndex (index typu) { instrukce } typ opIndexAssign (hodnota typu, index typu) { instrukce }`	`typ opIndex (index typu) { instrukce }`	`typ opIndexAssign (hodnota typu, index typu) { instrukce }`
Jáva	N / A
Objective-C (nedávný kompilátor Clang)	N / A	`- (id) objectAtIndexedSubscript: (NSUInteger)index { instrukce vrátit se hodnota; } nebo - (id) objectForKeyedSubscript: (id)index { instrukce vrátit se hodnota; }`	`- (void) setObject: (id)hodnota atIndexedSubscript: (NSUInteger)index { instrukce } nebo - (void) setObject: (id)hodnota forKeyedSubscript: (id)index { instrukce }`
Rychlý	`dolní index (index : typ) -> návratový typ { dostat { instrukce } nastavit«(novýIndex)» { instrukce } }`	`dolní index (index : typ) -> návratový typ { instrukce }`
Eiffelova^[35]	`bracket_name alias „[]“ (index: TYP): TYP přiřadit set_item dělat instrukce konec set_item (typ hodnoty; index: TYP): dělat instrukce konec`	`bracket_name alias „[]“ (index: TYP): TYP dělat instrukce konec`
Krajta	`def __getitem __ (já, index): Záložka ↹ instrukce Záložka ↹ vrátit se hodnota def __setitem __ (vlastní, index, hodnota): Záložka ↹ instrukce`	`def __getitem __ (já, index): Záložka ↹ instrukce Záložka ↹ vrátit se hodnota`	`def __setitem __ (vlastní, index, hodnota): Záložka ↹ instrukce`
Visual Basic .NET	`Výchozí položka vlastnosti (Index Tak jako typ) Tak jako typ Dostat instrukce Konec Get Nastavit (ByVal Hodnota Tak jako typ) instrukce Konec sady Ukončit vlastnost`	`Výchozí položka vlastnosti ReadOnly (Index Tak jako typ) Tak jako typ Dostat instrukce Konec Get Ukončit vlastnost`	`Výchozí položka vlastnosti WriteOnly (Index Tak jako typ) Tak jako typ Nastavit (ByVal Hodnota Tak jako typ) instrukce Konec sady Ukončit vlastnost`
PHP	^[37]
Perl	^[38]
Raku	`«náš «Typ» »«multi »metoda postcircumfix: <[]> je rw («$ Já: »Zadejte $ index) { pokyny ... vrátit se hodnota; } nebo «náš «Typ» »«multi »metoda postcircumfix: <{}> je rw («$ Já: »Zadejte klíč $) { pokyny ... vrátit se hodnota; }`	`«náš «Typ» »«multi »metoda postcircumfix: <[]> («$ Já: »Zadejte $ index) { pokyny ... vrátit se hodnota; } nebo «náš «Typ» »«multi »metoda postcircumfix: <{}> («$ Já: »Zadejte klíč $) { pokyny ... vrátit se hodnota; }`	N / A
Rubín	`def [] (index) instrukce výraz vedoucí k návratové hodnotě konec def [] = (index, hodnota) instrukce konec`	`def [] (index) instrukce výraz vedoucí k návratové hodnotě konec`	`def [] = (index, hodnota) instrukce konec`
Windows PowerShell	N / A
OCaml	N / A
F#	`člen this.Item s get (index) = výraz a nastavit hodnota indexu = výraz`	`člen this.Item s get (index) = výraz`	`člen this.Item se sadou hodnota indexu = výraz`
COBOL	N / A
Kobra	`pro [index «tak jako typ"] tak jako typ Záložka ↹ dostat Záložka ↹Záložka ↹ instrukce Záložka ↹Záložka ↹ vrátit se hodnota Záložka ↹ soubor Záložka ↹Záložka ↹ instrukce`	`dostat[index «tak jako typ"] tak jako typ Záložka ↹ instrukce Záložka ↹ vrátit se hodnota`	`soubor[index «tak jako typ"] tak jako typ Záložka ↹ instrukce`

Zadejte odlitky

	skleslý	upadlý
Objekty ABAP	N / A
C ++ (STL)		`operátor návratový typ() { instrukce }`
C#	`statický explicitní operátor návratový typ(zadejte operand) { instrukce }`	`implicitní statický operátor návratový typ(zadejte operand) { instrukce }`
D		`T opCast (T)() Pokud je(T == typ)) { instrukce }`
eC		`vlastnictví T {získat {vrátit «Konverzní kód»; } }`
Jáva	N / A
Cíl-C
Eiffelova^[35]
Krajta
Visual Basic .NET	`Shared Narrowing Operator CType (operand Tak jako typ) Tak jako návratový typ instrukce Koncový operátor`	`Shared Widening Operator CType (operand Tak jako typ) Tak jako návratový typ instrukce Koncový operátor`
PHP	N / A
Perl	N / A
Raku		`multi metoda typ"($ já:)» je export { instrukce }`
Rubín	N / A
Windows PowerShell
OCaml
F#
COBOL	N / A

Členský přístup

Jak přistupovat ke členům objektu x

	člen objektu			člen třídy	člen oboru názvů
	metoda	pole	vlastnictví	člen třídy	člen oboru názvů
Objekty ABAP	`x->metoda(«parametry »).`^[39]	`x->pole`	N / A	`x =>pole nebo x =>metoda(«parametry^[39]»).`	N / A
C ++ (STL)	`X.metoda(parametry) nebo ptr->metoda(parametry)`	`X.pole nebo ptr->pole`		`cls::člen`	`ns::člen`
Cíl-C	`[X metoda":parametr «bar:parametr ...""]`	`x->pole`	`X.vlastnost (pouze 2.0) nebo [X vlastnictví]`	`[metoda cls «:parametr «bar:parametr ...""]`
Pokec	`X metoda":parametr «bar:parametr ...""`	N / A		`metoda cls «:parametr «bar:parametr ...""`
Rychlý	`X.metoda(parametry)`		`X.vlastnictví`	`cls.člen`
APL (Dyalog)	`levý argument » X.metoda «správný argument (y)»`	`X.pole`	`X.vlastnictví`	`cls.člen`	`ns.člen`
C#	`X.metoda(parametry)`
Jáva			N / A
D			`X.vlastnictví`
Krajta
Visual Basic .NET
Xojo
Windows PowerShell				`[cls]::člen`
F#		N / A		`cls.člen`
eC	`X.metoda"(parametry)»`	`X.pole`	`X.vlastnictví`	`cls::člen`	`ns::člen`
Eiffelova	`X.metoda"(parametry)»`	`X.pole`		`{cls}.člen`	N / A
Rubín	`X.metoda"(parametry)»`	N / A	`X.vlastnictví`	`cls.člen`	N / A
PHP	`x->metoda(parametry)`	`x->pole`	`x->vlastnictví`	`cls::člen`	`nsčlen`
Perl	`x->metoda"(parametry)»`	`x -> {pole}`		`cls->metoda"(parametry)»`	`ns::člen`
Raku	`X.metoda"(parametry)»Nebo X!metoda"(parametry)»`	`X.pole nebo X!pole`		`cls.metoda"(parametry)»Nebo cls!metoda"(parametry)»`	`ns::člen`
OCaml	`X#metoda «parametry»`	N / A
JavaScript	`X.metoda(parametry) X["metoda"](parametry)`	`X.pole X["pole"]`	`X.vlastnictví X["vlastnictví"]`	`cls.člen cls["člen"]`	N / A
COBOL	`INVOKE x "metoda" «POUŽITÍM parametry »«VRÁCENÍ výsledek »nebo X::"metoda"«(«Parametry»)»`	N / A	`vlastnictví OF x`	`FAKTURUJTE cls "metoda" «POUŽITÍM parametry »«VRÁCENÍ výsledek »nebo cls::"metoda"«(«Parametry»)»Nebo vlastnictví Z cls`	N / A
Kobra	`X.metoda"(parametry)»`	`X.pole`	`X.vlastnictví`	`cls.člen`	`ns.člen`

Dostupnost členů

	Má člena?		Obsluha pro chybějící člen
	Metoda	Pole	Metoda	Pole
APL (Dyalog)	`3 = x.⎕NC 'metoda'`	`2 = x.⎕NC 'metoda'`	N / A
Objekty ABAP	N / A
C ++ (STL)	N / A
Objective-C (kakao)	`[X respondsToSelector: @selector (metoda)]`	N / A	`forwardInvocation:`	N / A
Pokec	`X odpovídáTo: volič`	N / A	`nerozumí:`	N / A
C#	(pomocí reflexe)
eC
Jáva
D			`opDispatch ()`
Eiffelova	N / A
Krajta	`hasattr (X, "metoda") a volatelné (X.metoda)`	`hasattr (X, "pole")`	`__getattr __ ()`
Visual Basic .NET	(pomocí reflexe)
Xojo	(pomocí Introspection)
Windows PowerShell	(pomocí reflexe)
F#	(pomocí reflexe)
Rubín	`X.reagovat?(:metoda)`	N / A	`method_missing ()`	N / A
PHP	`metoda_existuje (X, "metoda")`	`vlastnost_existuje (X, "pole")`	`__volání()`	`__get () / __set ()`
Perl	`X-> může ("metoda")`	`existuje X->{pole}`	AUTOLOAD
Raku	`X.umět("metoda")`	`X.pole.definovaný`	AUTOLOAD
OCaml	N / A
JavaScript	`TypX.metoda === "funkce"`	`pole v X`
COBOL	N / A

Speciální proměnné

	aktuální objekt	aktuální objekt je nadřazený objekt	nulový odkaz	Aktuální kontext provádění
Pokec	`já`	`super`	`nula`	`thisContext`
Objekty ABAP	`mě`	`super`	`počáteční`
APL (Dyalog)	`⎕TOTO`	`⎕BASE`	`⎕NULL`
C ++ (STL)	`*tento`	^[40]	`NULA, nullptr`
C#	`tento`	`základna`^[41]	`nula`
Jáva		`super`^[41]
D		`super`^[41]
JavaScript		`super`^[41] (ECMAScript 6)	`nula, nedefinováno`^[42]
eC	`tento`		`nula`
Cíl-C	`já`	`super`^[41]	`nula`
Rychlý	`já`	`super`^[41]	`nula`^[43]
Krajta	`já`^[44]	`super (current_class_name, já)`^[5] `super ()` (Pouze 3.x)	`Žádný`
Visual Basic .NET	`Mě`	`MyBase`	`Nic`
Xojo	`Já / já`	`Rodič`	`Nula`
Eiffelova	`Proud`	`Předchůdce «{nadtřída}» «(args)»`^[41]^[45]	`Neplatné`
PHP	`$ toto`	`rodič`^[41]	`nula`
Perl	`$ já`^[44]	`$ self-> SUPER`^[41]	`undef`
Raku	`já`	`SUPER`	`Nula`
Rubín	`já`	`super«(args)»`^[46]	`nula`	`vazba`
Windows PowerShell	`$ toto`		`$ NULL`
OCaml	`já`^[47]	`super`^[48]	N / A^[49]
F#	`tento`	`základna`^[41]	`nula`
COBOL	`JÁ`	`SUPER`	`NULA`
Kobra	`tento`	`základna`	`nula`

Speciální metody

	Řetězcová reprezentace		Kopie objektu	Hodnotová rovnost	Porovnání objektů	Hash kód	ID objektu
	Člověk čitelný	Kompatibilní se zdroji	Kopie objektu	Hodnotová rovnost	Porovnání objektů	Hash kód	ID objektu
Objekty ABAP	N / A
APL (Dyalog)	`⍕X`	`⎕SRC X`	`⎕NS X`	`X = y`	N / A
C ++ (STL)				`X == y`^[50]			ukazatel na objekt lze převést na celé číslo ID
C#	`X.ToString ()`		`X.Clone ()`	`X.Rovná se(y)`	`X.Porovnat s(y)`	`X.GetHashCode ()`	`Systém.Runtime.CompilerServices.RuntimeHelpers.GetHashCode (X)`
Jáva	`X.toString ()`		`X.klon ()`^[51]	`X.rovná se(y)`	`X.porovnat s(y)`^[52]	`X.hashCode ()`	`Systém.identityHashCode(X)`
JavaScript	`X.toString ()`
D	`X.toString () nebo std.conv.to! řetězec(X)`	`X.stringof`		`X == y nebo X.opEquals (y)`	`X.opCmp (y)`	`X.toHash ()`
eC	`X.OnGetString (tempString, null, null) nebo PrintString (X)`		`y.OnCopy (X)`		`X.OnCompare (y)`		popisovač objektu lze převést na celé číslo ID
Objective-C (kakao)	`X.popis`	`X.debug Popis`	`[X kopírovat]`^[53]	`[X je roven:y]`	`[X porovnat:y]`^[54]	`X.haš`	ukazatel na objekt lze převést na celé číslo ID
Rychlý	`X.popis`^[55]	`X.debug Popis`^[56]		`X == y`^[57]	`X < y`^[58]	`X.hashValue`^[59]	`odrážet (X).objectIdentifier!.uintValue ()`
Pokec	`X displayString`	`X printString`	`X kopírovat`	`X = y`		`X hash`	`X identityHash`
Krajta	`str (X)`^[60]	`repr (X)`^[61]	`copy.copy (X)`^[62]	`X == y`^[63]	`cmp (X, y)`^[64]	`hash (X)`^[65]	`id (X)`
Visual Basic .NET	`X.ToString ()`		`X.Clone ()`	`X.Rovná se(y)`	`X.Porovnat s(y)`	`X.GetHashCode ()`
Eiffelova	`X.ven`		`X.dvojče`	`X.je roven(y)`	Když x je `SROVNATELNÝ`, lze jednoduše udělat `X < y`	Když x je `HASHABLE`, lze použít `X.hash_code`	Když x je `IDENTIFIKOVANÉ`, lze použít `X.object_id`
PHP	`$ x -> __ toString ()`		`klon X`^[66]	`X == y`			`spl_object_hash (X)`
Perl	`"$ x"`^[67]	`Data :: Dumper-> Vypsat([$ x],['X'])`^[68]	`Skladovatelný:: dclone($ x)`^[69]				`Skalární:: Využití:: refaddr( $ x )`^[70]
Raku	`~X`^[67]	`X.perl`	`X.clone`	`X ekv y`	`X cmp y`		`X.KTERÝ`
Rubín	`X.to_s`	`X.kontrolovat`	`X.dup nebo X.clone`	`X == y nebo X.eql? (y)`	`X <=> y`	`X.haš`	`X.object_id`
Windows PowerShell	`X.ToString ()`		`X.Clone ()`	`X.Rovná se(y)`	`X.Porovnat s(y)`	`X.GetHashCode ()`
OCaml			`O.kopie X`	`X = y`		`Hashtbl.haš X`	`Oo.id X`
F#	`tětiva x nebo x.ToString () nebo sprintf "% O" X`	`sprintf "% A" X`	`X.Clone ()`	`X = y nebo x.Rovná se(y)`	`porovnat x y nebo x.Porovnat s(y)`	`hash x nebo x.GetHashCode ()`
COBOL	N / A

Typ manipulace

	Získat typ objektu	Je instance (zahrnuje podtypy)	Upcasting	Downcasting
	Získat typ objektu	Je instance (zahrnuje podtypy)	Upcasting	Kontrola běhu	Bez kontroly
Objekty ABAP	N / A^[71]		=	?=
C ++ (STL)	`psí typ (X)`	`dynamic_cast <typ *>(&X) != nullptr`	N / A^[72]	`dynamic_cast <typ*>(ptr)`	`(typ) ptr nebo static_cast <typ>(ptr)`
C#	`X.GetType ()`	`X je typ`		`(typ) x nebo x tak jako typ`
D	`psí typ (X)`			`obsazení(typ) X`
Delphi		`X je typ`		`X tak jako typ`
eC	`X._třída`	`eClass_IsDerived (x._class, zadejte)`			`(typ) X`
Jáva	`X.getClass ()`	`X instanceof třída`		`(typ) X`
Objective-C (kakao)	`[X třída]`^[73]	`[X isKindOfClass: [třída třída]]`			`(typ*) X`
Rychlý	`X.dynamicType`	`X je typ`		`X tak jako! typ` `X tak jako? typ`
JavaScript	`X.konstruktor (Pokud není přepsáno.)`	`X instanceof třída`	N / A^[74]
Visual Basic .NET	`X.GetType ()`	`Typ X Je typ`	N / A^[72]	`CType (X, typ) nebo TryCast (X, typ)`
Xojo	`Introspection.GetType (x)`	`X Je typ`	N / A	`CType (X, typ)`	N / A
Eiffelova	`X.generating_type`	`připojeno {TYPE} X`	`připojeno {TYPE} X tak jako dolů_x`
Krajta	`typ(X)`	`instance (X, typ)`	N / A^[74]
PHP	`get_class (X)`	`X instanceof třída`
Perl	`ref (X)`	`X-> isa ("třída")`
Raku	`X.CO`	`X.je(třída)`	N / A^[72]	`typ(X) nebo X.typ`
Rubín	`X.třída`	`X.instance_of? (typ) nebo X.druh?(typ)`	N / A^[74]
Pokec	`X třída`	`X isKindOf: třída`	N / A^[74]
Windows PowerShell	`X.GetType ()`	`X -je [typ]`	N / A^[72]	`[typ]x nebo x -tak jako [typ]`
OCaml	N / A^[75]		`(X :> typ)`	N / A
F#	`X.GetType ()`	`X :? typ`	`(X :> typ)`	`(X :?> typ)`
COBOL	N / A		`X TAK JAKO typ`^[72]	N / A

Správa jmenného prostoru

	Importujte jmenný prostor		Importovat položku
	kvalifikovaný	nekvalifikovaný	Importovat položku
Objekty ABAP
C ++ (STL)		`pomocí jmenného prostoru ns;`	`použitím ns :: položka ;`
C#		`použitím ns;`	`použitím položka = ns.položka;`
D		`import ns;`	`import ns : položka;`
Jáva		`import ns.*;`	`import ns.položka;`
Cíl-C
Visual Basic .NET		`Dovoz ns`
Eiffelova
Krajta	`import ns`	`z ns import *`	`z ns import položka`
PHP		`použití ns;`	`použití nspoložka;`
Perl	`použití ns;`		`použití ns qw (položka);`
Raku	`použití ns;`
Rubín
Windows PowerShell
OCaml		`otevřeno ns`
F#		`otevřeno ns`
COBOL	N / A

Smlouvy

	Předpoklad	Dodatečná podmínka	Šek	Invariantní	Smyčka
Objekty ABAP	N / A
C ++ (STL)	N / A
C#	`Spec #: typ foo( «Parametry» ) vyžaduje výraz { tělo }`	`Spec #: typ foo( «Parametry» ) zajišťuje výraz { tělo }`
Jáva	N / A
Cíl-C
Visual Basic .NET
D	`F v { tvrdí } tělo{ instrukce }`	`F ven (výsledek) { tvrdí } tělo{ instrukce }`	`tvrdit (výraz)`	`invariant () { výraz }`
Eiffelova	`F vyžadovat tag: výraz konec`	`F dělat zajistit tag: výraz konec`	`F dělat šek tag: výraz konec konec`	`třída X neměnný tag: výraz konec`	`z instrukce neměnný tag: výraz dokud expr smyčka instrukce varianta tag: výraz konec`
Krajta	N / A
PHP
Perl
Raku	`PRE { stav }`	`POŠTA { stav }`
Rubín	N / A
Windows PowerShell
OCaml
F#
COBOL

Viz také

Objektově orientované programování

Odkazy a poznámky

^ parametr = argument lze opakovat, pokud má konstruktor několik parametrů
^ MÍZA vyhrazuje si použití zkázy
^ ^A ^b ^C ^d ^E ^F ^G ^h ⁱ ^j ^k ^l Tento jazyk používá odvoz odpadu uvolnit nepoužívanou paměť.
^ Objekty OCaml lze vytvářet přímo, aniž byste procházeli třídou.
^ ^A ^b ^C ^d ^E ^F ^G Tento jazyk podporuje vícenásobné dědictví. Třída může mít více než jednu nadřazenou třídu
^ Neposkytování nadřazené třídy dělá z této třídy kořenovou třídu. V praxi se to téměř nikdy nedělá. Jeden by měl obecně používat konvenční základní třídu rámce, který používá, což je NSObject pro kakao a GNUstep, nebo Objekt v opačném případě.
^ Obvykle @rozhraní část je umístěna do a hlavičkový soubor a @rozhraní část je umístěna do samostatného souboru zdrojového kódu.
^ Předpony názvů tříd a protokolů se běžně používají jako druh oboru názvů
^ V rozhraní Pythonu jsou třídy, které metody mají složit jako jejich těla
^ Třída je Object.
Stačí poslat zprávu do nadtřídy (st-80) nebo cílového jmenného prostoru (Visualworks).
^ Obor názvů je Object.
Stačí odeslat zprávu do nadřazeného oboru názvů.
^ A finalizátor je volán sběratelem odpadků, když má být objekt zbaven odpadu. Neexistuje žádná záruka, kdy bude vyvolána nebo zda bude vůbec vyvolána.
^ V ABAP má být konstruktor definován jako metoda (viz komentáře k metodě) s následujícími omezeními: název metody musí být „konstruktor“ a lze definovat pouze parametry „importu“
^ Zde se zobrazí seznam inicializátorů oddělených čárkami pro členské objekty a nadřazené třídy. Syntaxe pro inicializaci členských objektů je
"jméno člena(parametry)"
To funguje i pro primitivní členy, v takovém případě je zadán jeden parametr a tato hodnota je zkopírována do člena. Syntaxe pro inicializaci nadřazených tříd je
"jméno třídy(parametry)".
Pokud inicializátor není zadán pro členskou nebo nadřazenou třídu, pak výchozí konstruktor se používá.
^ Jako postup vytváření lze použít jakoukoli proceduru Eiffel, aka konstruktory. Viz odstavec Eiffel v Konstruktor (informatika).
^ Provádí se {DISPOSABLE} .dispose zajišťuje to zlikvidovat bude voláno, když je objekt shromažďován odpadky.
^ Tato konstrukce „inicializátoru“ se používá jen zřídka. Pole v OCaml jsou obvykle inicializována přímo v jejich deklaraci. Inicializátor se používá pouze v případě, že jsou nutné další imperativní operace. "Parametry konstruktoru" v jiných jazycích jsou místo toho specifikovány jako parametry třídy v OCaml. Další podrobnosti najdete v syntaxi deklarace třídy.
^ Tato syntaxe se obvykle používá přetížení konstruktéři
^ V JavaScriptu konstruktor je objekt.
^ Konstruktory lze emulovat pomocí tovární metody vracející instanci třídy.
^ ^A ^b ^C Identifikátor oboru se musí v deklaraci souboru objevit jednou, všechny deklarace proměnných po tomto identifikátoru oboru mají svůj obor, dokud nebude dosaženo jiného identifikátoru oboru nebo konce deklarace třídy
^ V ABAP nejsou konkrétní pole nebo metody deklarovány jako přístupné vnějšími věcmi. Spíše jsou vnější třídy deklarovány jako přátelé, kteří mají přístup k polím nebo metodám třídy.
^ V C ++ nejsou konkrétní pole deklarována jako přístupná vnějšími věcmi. Spíše jsou vnější funkce a třídy deklarovány jako přátelé, kteří mají přístup k polím třídy. Vidět funkce přítele a třída přátel Více podrobností.

^ Stačí poslat zprávu třídě

třída addInstVarName: pole.třída removeInstVarName: pole.

^ ^A ^b ^C ^d Stačí mu přiřadit hodnotu metodou
^ Python nemá soukromá pole - všechna pole jsou vždy veřejně přístupná. Existuje komunitní konvence pro prefix implementace detailů s jedním podtržítkem, ale jazyk je nevynucován.
^ Všechna data třídy jsou „soukromá“, protože standard COBOL neurčuje žádný způsob přístupu k nim.
^ Deklarace a implementace metod v ABAP jsou samostatné. metody příkaz má být použit uvnitř definice třídy. metoda (bez "s") má být použito uvnitř implementace třídy. parametr = argument lze opakovat, pokud existuje několik parametrů.
^ V ABAP je název návratového parametru explicitně definován v podpisu metody v rámci definice třídy
^ V C ++ je deklarace a implementace metod obvykle samostatná. Metody jsou deklarovány v definici třídy (která je obvykle součástí a hlavičkový soubor ) pomocí syntaxe
^ Ačkoli tělo metody umět být součástí deklarace uvnitř definice třídy, jak je uvedeno v tabulce zde, je to obecně špatná praxe. Protože definice třídy musí být zahrnuta do každého zdrojového souboru, který používá pole nebo metody třídy, kód v definici třídy způsobí, že kód metody bude zkompilován s každým zdrojovým souborem, čímž se zvětší velikost kódu. Přesto je za určitých okolností užitečné zahrnout tělo metody do deklarace. Jedním z důvodů je, že se kompilátor pokusí v souladu metody, které jsou zahrnuty v deklaraci třídy; takže pokud je velmi krátká jednořádkový dojde k metodě, může to zrychlit, aby ji kompilátor mohl vložit vložením těla spolu s deklarací. Také pokud a šablona dojde k třídě nebo metodě, musí být do deklarace zahrnut veškerý kód, protože pouze s kódem lze vytvořit instanci šablony.
^ ^A ^b Stačí mu přiřadit funkci metodou

^ Alternativní implementace:

def bar():    doc = „Barový majetek.“    def fget(já):        vrátit se já._bar    def fset(já, hodnota):        já._bar = hodnota    vrátit se místní obyvatelé()bar = vlastnictví(**bar())

^ tyto příklady potřebují Třída :: Accessor modul nainstalován
^ ^A ^b ^C Ačkoli Eiffel nepodporuje přetížení operátorů, může definovat operátory
^ PHP nepodporuje nativní přetížení operátora, ale podporu lze přidat pomocí "operátor" balíček PECL.
^ Třída musí implementovat Rozhraní ArrayAccess.
^ Třída musí přetížit '@ {}' (dereference pole) nebo podtřídu jednoho z Tie :: Array nebo Tie :: StdArray, aby zahákla operace pole
^ ^A ^b V ABAP musí být argumenty předány pomocí této syntaxe:
x->metoda(«export parametr = argument »«import parametr = argument »«měnící se parametr = argument »«návratová hodnota (parametr)»
parametr = argument lze opakovat, pokud existuje několik parametrů
^ C ++ nemá klíčové slovo „super“, protože je možné více dědičností, a proto může být nejednoznačné, na kterou základní třídu se odkazuje. Místo toho BaseClassName :: člen syntaxi lze použít pro přístup k přepsanému členu v zadané základní třídě. Microsoft Visual C ++ pro tento účel poskytuje nestandardní klíčové slovo „__super“; ale to není podporováno v jiných kompilátorech.[1]
^ ^A ^b ^C ^d ^E ^F ^G ^h ⁱ Klíčové slovo zde není hodnota, a lze jej použít pouze pro přístup k metodě nadtřídy.
^ Ale obávejte se, že nemají stejnou hodnotu.
^ pouze pro volitelné typy
^ ^A ^b V tomto jazyce jsou instanční metody předávány aktuálnímu objektu jako první parametr, který je konvenčně pojmenován „self“, ale není tomu tak.
^ „Prekurzor“ v Eiffelově jazyce je vlastně volání metody se stejným názvem v nadtřídě. Precursor (args) je tedy v Javě ekvivalentní „super.currentMethodName (args)“. V nadtřídě nelze zavolat metodu jiného jména.
^ „super“ v Ruby, na rozdíl od jiných jazyků, je ve skutečnosti volání stejnojmenné metody v nadtřídě. Takže super (args) v Ruby je ekvivalentní "super.currentMethodName (args)" v Javě. V nadtřídě nelze zavolat metodu jiného jména.
^ V OCaml může deklarace objektu volitelně začínat parametrem, který bude přidružen k aktuálnímu objektu. Tento parametr je konvenčně pojmenován „self“, ale není tomu tak. Je dobrým zvykem vložit tam parametr, aby bylo možné volat vlastní metody.
^ V OCaml může být deklarace dědičnosti ("inherit") volitelně přidružena k hodnotě se syntaxí "zdědit parent_class «parametry» tak jako super ". Zde" super "je název proměnné přidružené k tomuto nadřazenému objektu. Lze jej pojmenovat odlišně.
^ Pokud je však potřeba mít v OCamlu „volitelnou“ hodnotu, zalomte ji dovnitř volba typ, které hodnoty jsou Žádný a Některé x, kterou lze použít k vyjádření „nulové reference“ a „nenulové reference na objekt“ jako v jiných jazycích.
^ za předpokladu, že „x“ a „y“ jsou objekty (a nikoli ukazatel). Lze přizpůsobit přetížením objektu == operátor
^ Přístupné pouze zevnitř třídy, protože klon () metoda zděděná z Objekt je chráněn, pokud třída přepíše metodu a nezveřejní ji. Pokud používáte klon () zdědil od Objekt, třída musí implementovat Cloneable rozhraní umožňující klonování.
^ Třída by měla implementovat rozhraní Srovnatelný aby byla tato metoda standardizována.
^ Implementováno objektem copyWithZone: metoda
^ porovnat: je konvenční název pro metodu porovnání ve třídách Foundation. Formální protokol však neexistuje
^ Pouze v případě, že objekt odpovídá Tisknutelné protokol
^ Pouze v případě, že objekt odpovídá DebugTisknutelné protokol
^ Pouze v případě, že objekt odpovídá Vyrovnatelné protokol
^ Pouze v případě, že objekt odpovídá Srovnatelný protokol
^ Pouze v případě, že objekt odpovídá hashValue protokol
^ Lze přizpůsobit podle objektu __str __ () metoda
^ Lze přizpůsobit podle objektu __repr __ () metoda
^ Lze přizpůsobit podle objektu __kopírovat__() metoda
^ Lze přizpůsobit podle objektu __eq __ () metoda
^ Pouze v Pythonu 2.xa dříve (odstraněno v Pythonu 3.0). Lze přizpůsobit podle objektu __cmp __ () metoda
^ Lze přizpůsobit podle objektu __hash __ () metoda. Ne všechny typy jsou hashovatelné (proměnlivé typy obvykle hashovatelné nejsou)
^ Lze přizpůsobit podle objektu __clone () metoda
^ ^A ^b Lze přizpůsobit přetížením operátoru převodu řetězce objektu
^ Tento příklad vyžaduje použitíing Data :: Dumper
^ Tento příklad vyžaduje použitíing Skladovatelný
^ Tento příklad vyžaduje použitíing Skalární :: Využití
^ Informace o typu běhu v ABAP lze získat pomocí různých tříd popisu, jako je CL_ABAP_CLASSDESCR.
^ ^A ^b ^C ^d ^E Upcasting je v tomto jazyce implicitní. Instanci podtypu lze použít tam, kde je potřeba supertyp.
^ Pouze pro objekty jiné třídy. Li X je objekt třídy, [x třída] pouze vrací X. Runtime metoda object_getClass (x) vrátí třídu X pro všechny objekty.
^ ^A ^b ^C Tento jazyk je psán dynamicky. Casting mezi typy není nutný.
^ Tento jazyk neposkytuje informace o typu běhu. Je nepotřebný, protože je staticky napsaný a downcasting je nemožný.

[1] parametr = argument lze opakovat, pokud má konstruktor několik parametrů

[2] MÍZA vyhrazuje si použití zkázy

[gc-3] A ^b ^C ^d ^E ^F ^G ^h ⁱ ^j ^k ^l Tento jazyk používá odvoz odpadu uvolnit nepoužívanou paměť.

[4] Objekty OCaml lze vytvářet přímo, aniž byste procházeli třídou.

[multi-5] A ^b ^C ^d ^E ^F ^G Tento jazyk podporuje vícenásobné dědictví. Třída může mít více než jednu nadřazenou třídu

[6] Neposkytování nadřazené třídy dělá z této třídy kořenovou třídu. V praxi se to téměř nikdy nedělá. Jeden by měl obecně používat konvenční základní třídu rámce, který používá, což je NSObject pro kakao a GNUstep, nebo Objekt v opačném případě.

[7] Obvykle @rozhraní část je umístěna do a hlavičkový soubor a @rozhraní část je umístěna do samostatného souboru zdrojového kódu.

[8] Předpony názvů tříd a protokolů se běžně používají jako druh oboru názvů

[9] V rozhraní Pythonu jsou třídy, které metody mají složit jako jejich těla

[10] Třída je Object.
Stačí poslat zprávu do nadtřídy (st-80) nebo cílového jmenného prostoru (Visualworks).

[11] Obor názvů je Object.
Stačí odeslat zprávu do nadřazeného oboru názvů.

[12] A finalizátor je volán sběratelem odpadků, když má být objekt zbaven odpadu. Neexistuje žádná záruka, kdy bude vyvolána nebo zda bude vůbec vyvolána.

[13] V ABAP má být konstruktor definován jako metoda (viz komentáře k metodě) s následujícími omezeními: název metody musí být „konstruktor“ a lze definovat pouze parametry „importu“

[14] Zde se zobrazí seznam inicializátorů oddělených čárkami pro členské objekty a nadřazené třídy. Syntaxe pro inicializaci členských objektů je
"jméno člena(parametry)"
To funguje i pro primitivní členy, v takovém případě je zadán jeden parametr a tato hodnota je zkopírována do člena. Syntaxe pro inicializaci nadřazených tříd je
"jméno třídy(parametry)".
Pokud inicializátor není zadán pro členskou nebo nadřazenou třídu, pak výchozí konstruktor se používá.

[creation_routine-15] Jako postup vytváření lze použít jakoukoli proceduru Eiffel, aka konstruktory. Viz odstavec Eiffel v Konstruktor (informatika).

[16] Provádí se {DISPOSABLE} .dispose zajišťuje to zlikvidovat bude voláno, když je objekt shromažďován odpadky.

[17] Tato konstrukce „inicializátoru“ se používá jen zřídka. Pole v OCaml jsou obvykle inicializována přímo v jejich deklaraci. Inicializátor se používá pouze v případě, že jsou nutné další imperativní operace. "Parametry konstruktoru" v jiných jazycích jsou místo toho specifikovány jako parametry třídy v OCaml. Další podrobnosti najdete v syntaxi deklarace třídy.

[18] Tato syntaxe se obvykle používá přetížení konstruktéři

[19] V JavaScriptu konstruktor je objekt.

[20] Konstruktory lze emulovat pomocí tovární metody vracející instanci třídy.

[abapsection-21] A ^b ^C Identifikátor oboru se musí v deklaraci souboru objevit jednou, všechny deklarace proměnných po tomto identifikátoru oboru mají svůj obor, dokud nebude dosaženo jiného identifikátoru oboru nebo konce deklarace třídy

[22] V ABAP nejsou konkrétní pole nebo metody deklarovány jako přístupné vnějšími věcmi. Spíše jsou vnější třídy deklarovány jako přátelé, kteří mají přístup k polím nebo metodám třídy.

[23] V C ++ nejsou konkrétní pole deklarována jako přístupná vnějšími věcmi. Spíše jsou vnější funkce a třídy deklarovány jako přátelé, kteří mají přístup k polím třídy. Vidět funkce přítele a třída přátel Více podrobností.

[24] Stačí poslat zprávu třídě
třída addInstVarName: pole.třída removeInstVarName: pole.

[assign_value-25] A ^b ^C ^d Stačí mu přiřadit hodnotu metodou

[26] Python nemá soukromá pole - všechna pole jsou vždy veřejně přístupná. Existuje komunitní konvence pro prefix implementace detailů s jedním podtržítkem, ale jazyk je nevynucován.

[27] Všechna data třídy jsou „soukromá“, protože standard COBOL neurčuje žádný způsob přístupu k nim.

[28] Deklarace a implementace metod v ABAP jsou samostatné. metody příkaz má být použit uvnitř definice třídy. metoda (bez "s") má být použito uvnitř implementace třídy. parametr = argument lze opakovat, pokud existuje několik parametrů.

[29] V ABAP je název návratového parametru explicitně definován v podpisu metody v rámci definice třídy

[30] V C ++ je deklarace a implementace metod obvykle samostatná. Metody jsou deklarovány v definici třídy (která je obvykle součástí a hlavičkový soubor ) pomocí syntaxe

[31] Ačkoli tělo metody umět být součástí deklarace uvnitř definice třídy, jak je uvedeno v tabulce zde, je to obecně špatná praxe. Protože definice třídy musí být zahrnuta do každého zdrojového souboru, který používá pole nebo metody třídy, kód v definici třídy způsobí, že kód metody bude zkompilován s každým zdrojovým souborem, čímž se zvětší velikost kódu. Přesto je za určitých okolností užitečné zahrnout tělo metody do deklarace. Jedním z důvodů je, že se kompilátor pokusí v souladu metody, které jsou zahrnuty v deklaraci třídy; takže pokud je velmi krátká jednořádkový dojde k metodě, může to zrychlit, aby ji kompilátor mohl vložit vložením těla spolu s deklarací. Také pokud a šablona dojde k třídě nebo metodě, musí být do deklarace zahrnut veškerý kód, protože pouze s kódem lze vytvořit instanci šablony.

[assign_func-32] A ^b Stačí mu přiřadit funkci metodou

[33] Alternativní implementace:
def bar(): doc = „Barový majetek.“ def fget(já): vrátit se já._bar def fset(já, hodnota): já._bar = hodnota vrátit se místní obyvatelé()bar = vlastnictví(**bar())

[34] tyto příklady potřebují Třída :: Accessor modul nainstalován

[Eiffel_operators-35] A ^b ^C Ačkoli Eiffel nepodporuje přetížení operátorů, může definovat operátory

[36] PHP nepodporuje nativní přetížení operátora, ale podporu lze přidat pomocí "operátor" balíček PECL.

[37] Třída musí implementovat Rozhraní ArrayAccess.

[38] Třída musí přetížit '@ {}' (dereference pole) nebo podtřídu jednoho z Tie :: Array nebo Tie :: StdArray, aby zahákla operace pole

[abapparam-39] A ^b V ABAP musí být argumenty předány pomocí této syntaxe:
x->metoda(«export parametr = argument »«import parametr = argument »«měnící se parametr = argument »«návratová hodnota (parametr)»
parametr = argument lze opakovat, pokud existuje několik parametrů

[40] C ++ nemá klíčové slovo „super“, protože je možné více dědičností, a proto může být nejednoznačné, na kterou základní třídu se odkazuje. Místo toho BaseClassName :: člen syntaxi lze použít pro přístup k přepsanému členu v zadané základní třídě. Microsoft Visual C ++ pro tento účel poskytuje nestandardní klíčové slovo „__super“; ale to není podporováno v jiných kompilátorech.[1]

[limited_super-41] A ^b ^C ^d ^E ^F ^G ^h ⁱ Klíčové slovo zde není hodnota, a lze jej použít pouze pro přístup k metodě nadtřídy.

[42] Ale obávejte se, že nemají stejnou hodnotu.

[43] uze pro volitelné typy

[first_param_self-44] A ^b V tomto jazyce jsou instanční metody předávány aktuálnímu objektu jako první parametr, který je konvenčně pojmenován „self“, ale není tomu tak.

[45] „Prekurzor“ v Eiffelově jazyce je vlastně volání metody se stejným názvem v nadtřídě. Precursor (args) je tedy v Javě ekvivalentní „super.currentMethodName (args)“. V nadtřídě nelze zavolat metodu jiného jména.

[46] „super“ v Ruby, na rozdíl od jiných jazyků, je ve skutečnosti volání stejnojmenné metody v nadtřídě. Takže super (args) v Ruby je ekvivalentní "super.currentMethodName (args)" v Javě. V nadtřídě nelze zavolat metodu jiného jména.

[47] V OCaml může deklarace objektu volitelně začínat parametrem, který bude přidružen k aktuálnímu objektu. Tento parametr je konvenčně pojmenován „self“, ale není tomu tak. Je dobrým zvykem vložit tam parametr, aby bylo možné volat vlastní metody.

[48] V OCaml může být deklarace dědičnosti ("inherit") volitelně přidružena k hodnotě se syntaxí "zdědit parent_class «parametry» tak jako super ". Zde" super "je název proměnné přidružené k tomuto nadřazenému objektu. Lze jej pojmenovat odlišně.

[49] Pokud je však potřeba mít v OCamlu „volitelnou“ hodnotu, zalomte ji dovnitř volba typ, které hodnoty jsou Žádný a Některé x, kterou lze použít k vyjádření „nulové reference“ a „nenulové reference na objekt“ jako v jiných jazycích.

[50] za předpokladu, že „x“ a „y“ jsou objekty (a nikoli ukazatel). Lze přizpůsobit přetížením objektu == operátor

[51] Přístupné pouze zevnitř třídy, protože klon () metoda zděděná z Objekt je chráněn, pokud třída přepíše metodu a nezveřejní ji. Pokud používáte klon () zdědil od Objekt, třída musí implementovat Cloneable rozhraní umožňující klonování.

[52] Třída by měla implementovat rozhraní Srovnatelný aby byla tato metoda standardizována.

[53] Implementováno objektem copyWithZone: metoda

[54] porovnat: je konvenční název pro metodu porovnání ve třídách Foundation. Formální protokol však neexistuje

[55] Pouze v případě, že objekt odpovídá Tisknutelné protokol

[56] Pouze v případě, že objekt odpovídá DebugTisknutelné protokol

[57] Pouze v případě, že objekt odpovídá Vyrovnatelné protokol

[58] Pouze v případě, že objekt odpovídá Srovnatelný protokol

[59] Pouze v případě, že objekt odpovídá hashValue protokol

[60] Lze přizpůsobit podle objektu __str __ () metoda

[61] Lze přizpůsobit podle objektu __repr __ () metoda

[62] Lze přizpůsobit podle objektu __kopírovat__() metoda

[63] Lze přizpůsobit podle objektu __eq __ () metoda

[64] Pouze v Pythonu 2.xa dříve (odstraněno v Pythonu 3.0). Lze přizpůsobit podle objektu __cmp __ () metoda

[65] Lze přizpůsobit podle objektu __hash __ () metoda. Ne všechny typy jsou hashovatelné (proměnlivé typy obvykle hashovatelné nejsou)

[66] Lze přizpůsobit podle objektu __clone () metoda

[perl_string-67] A ^b Lze přizpůsobit přetížením operátoru převodu řetězce objektu

[68] Tento příklad vyžaduje použitíing Data :: Dumper

[69] Tento příklad vyžaduje použitíing Skladovatelný

[70] Tento příklad vyžaduje použitíing Skalární :: Využití

[71] Informace o typu běhu v ABAP lze získat pomocí různých tříd popisu, jako je CL_ABAP_CLASSDESCR.

[implicit_cast-72] A ^b ^C ^d ^E Upcasting je v tomto jazyce implicitní. Instanci podtypu lze použít tam, kde je potřeba supertyp.

[73] Pouze pro objekty jiné třídy. Li X je objekt třídy, [x třída] pouze vrací X. Runtime metoda object_getClass (x) vrátí třídu X pro všechny objekty.

[nocast-74] A ^b ^C Tento jazyk je psán dynamicky. Casting mezi typy není nutný.

[75] Tento jazyk neposkytuje informace o typu běhu. Je nepotřebný, protože je staticky napsaný a downcasting je nemožný.

[1]

[2]

[3]

[4]

[5]

[6]

[7]

[8]

[9]

[10]

[11]

[12]

[13]

[14]

[15]

[16]

[17]

[18]

[19]

[20]

[21]

[22]

[23]

[24]

[25]

[26]

[27]

[28]

[29]

[30]

[31]

[32]

[33]

[34]

[35]

[36]

[37]

[38]

[39]

[40]

[41]

[42]

[43]

[44]

[45]

[46]

[47]

[48]

[49]

[50]

[51]

[52]

[53]

[54]

[55]

[56]

[57]

[58]

[59]

[60]

[61]

[62]

[63]

[64]

[65]

[66]

[67]

[68]

[69]

[70]

[71]

[72]

[73]

[74]

[75]