Informaatikas võib **objekt** olla muutuja, andmestruktuur, alamprogramm või meetod. Nagu ka muude mälupiirkondade puhul, viidetakse objekti sisule identifikaatori abil.

Objektorienteeritud programmeerimise (OOP) paradigma puhul võib objekt koosneda muutujatest, funktsioonidest ja andmestruktuuridest. Klassipõhistes paradigma variatsioonides nimetatakse objektiks klassi instantsi.

Suhetepõhise andmebaasi halduse puhul on objektiks tabel, tulp või suhe andmete ja andmebaasi üksuse vahel (näiteks vanus ja isik).

Objektipõhised keeled
---------------------

 *Pikemalt artiklis Objektipõhised keeled*
Keelt nimetatakse objektipõhiseks juhul, kui selle objektid vastavad alljärgnevatele (kehtivuse ja sisalduvuse) nõuetele:

* Identiteet: objektide loomupärane erinevus, isegi võrdväärse sisu korral.
* Omadused (*properties*): objekti kirjeldavad infokillud, mis on võrreldavad nii andmeväljade kui ka meetoditega. Kuigi süntaktiliselt on objekti omaduse ja andmevälja lugemine ning muutmine eristamatu, transleeritakse omadused *getter* ja *setter* meetodite väljakutseteks.
* Andmeatribuudid: objektil asuvad muutujad. Erinevalt omadustest ei ole atribuudid töödeldav eksklusiivselt *getter* ja *setter* meetodite abil.

Objektorienteeritud keeled
--------------------------

 *Pikemalt artiklis Objektorienteeritud keeled*
Keelt loetakse objektorienteerituks, kui see täidab objektipõhise keele nõudeid ning lisaks võimaldab järgmiseid võtteid:

* Polümorfism – funktsioonide ülekoormamine (*overload*), mis võimaldab erinevat käitumist (*behaviour*) sõltuvalt argumentidena edastatud objektidest.
* Pärimine – võimalus luua alamklass (*subclass*), millel on kõik vanema (*parent*) klassi piirangud ja omadused, seejuures võimaldades uue funktsionaalsuse lisamist.

InheritanceinObjectOrientedProgrammingPärimise tüüpe
* Kapseldamine – protsess, mis seisneb omavahel seotud andmete ja meetodite ülejäänud programmist abstraheerimises (peitmises) ning välismaailmaga suhtlemiseks liideste loomises.

Vahel nõutakse ka järgmist:

* Kompositsioon – olukord, milles klass sisaldab teisi klasse.

Objektorienteeritud programmeerimine
------------------------------------

 *Pikemalt artiklis Objektorienteeritud programmeerimine*
Objektorienteeritud programmeerimine on lähenemine, mis tagab modulaarse ja taaskasutatava programmikoodi. Välja on see arenenud headest disaini tavadest, mis on olnud kasutuses juba programmeerimise tekkeaastatel. Oma olemuselt on objektorienteeritus vaid varasemate võtete, näiteks struktureeritud programmeerimise ja abstraktsete andmetüüpide, loomulik edasiareng. Objekt on ei midagi enamat kui abstraktne andmetüüp ühenduses polümorfismi ja pärimisvõimega.

Andmete ja koodi eristamise asemel ühendab objektorienteeritud süsteem need "objekti" mõiste abil. Objekt koosneb olekust (*en:state* ehk andmed) ja käitumisest (en:*behaviour* ehk kood). Objekt võib olla inspireeritud päris maailmast. Nii näiteks e-pood vajab selliseid objekte nagu *ostukorv*, *klient* ja *toode*. Seejuures ostukorv võib sisaldada näiteks käitumist *lisa* ja *telli*, kliendi objektil aga võib olla võimalus *muuta parooli*. Disaini poolest on objektid hierarhilised. Nii võib e-pood vajada üldisemaid klasse nagu *elektroonikatooted* ja *köögitooted*. Kuid tõenäoliselt läheb vaja ka täpsustatud funktsionaalsustega ja omadustega klasse, näiteks *elektroonikatooted* võiksid jaguneda *CD-mängijaks*, *DVD-mängijaks* jne. Sellised klassid ja alamklassid vastavad matemaatilistele hulkadele ja alamhulkadele.

Spetsiaalsed objektid
---------------------

Objektide puhul on tähtsaks mõisteks tarkvaraline disaini muster. Selline muster pakub taaskasutatavat malli lahendamaks tihti kohtuvaid probleeme. Alljärgnevalt on välja toodud mõned põhilised objekti disaini mustrid. 

* Funktsiooni objekt (*function object*) – ühtainsat meetodit sisaldav objekt, mis käitub sarnaselt funktsiooniga (sarnaselt C/C++ funktsiooni viitega).
* Muutumatu objekt (*immutable object*) – objekt, mille olek (*state*) on fikseeritud loomise protsessis ning on hiljem muutumatu.
* Esimest järku objekt (*first-class object*) – piiranguteta objekt.
* Konteinerobjekt (*container object*) – objekt, mis võib sisaldada teisi objekte.
* Tehasobjekt (*factory object*) – objekt, mille eesmärgiks on luua teisi objekte.
* Metaobjekt (*metaobject*) – objekt, mis võimaldab luua teisi objekte enda põhjal (võrreldav klassiga, mis aga ise ei pruugi objekt olla).
* Prototüüpobjekt (*prototype object*) – spetsialiseeritud metaobjekt, mille põhjal on võimalik luua uusi objekte kopeerimise teel.
* Jumalik objekt (*god object*) – objekt, mis "teab" või teeb liiga palju (näide anti-mustrist).
* Üksik objekt (*singleton object*) – objekt, mis on ainsaks klassi instantsiks terve programmi jooksul.
* Filtriobjekt (*filter object*) – objekt, mis teisendab sisendatud andmevoogu ning tagastab seda. Tihti on sisend- ja väljendvoogudeks märkide vood, kuid nendeks võivad olla ka suvaliste objektide vood. Tegeliku implementatsiooni varjamise ja selle arendajale vajaliku abstraktsiooniga asendamise tõttu kasutatakse seda tihti ümbristes.

Hajusobjektid
-------------

 *Pikemalt artiklis Hajusobjekt*
Objektorienteeritud lähenemine ei kujuta endast vaid programmeerimismudelit. See on samuti kasutatav liidest kirjeldava keelena hajussüsteemide jaoks. Hajusarvutuse mudeli puhul kipuvad objektid olema rohmakamad (*larger grained*), pikemalt kasutatavad ja teenustele orienteeritumad kui programmeerimisobjektid.

Hajusobjektide pakendamiseks kasutatakse enamasti liidest defineerivat keelt (*Interface Definition Language*) ehk IDL-i. IDL varjab kliendi eest kõiki hajusserveri detaile. Sellised detailid on näiteks serveri kasutatav programmeerimiskeel ja operatsioonisüsteem. IDL on samuti tihti hajuskeskkonna osaks, mis pakub objektidele transaktsiooni ja püsivuse teenuseid, säilitades seejuures tänu tsentraliseeritusele nende protsesside ühtsust terve programmi vältel. Kaheks enamlevinud hajusobjektide standardiks on Object Management Group'i CORBA standart ja Microsofti DCOM. 

Hajusarvutuse võimaldamiseks on lisaks hajusobjektidele välja pakutud ka muid tavaobjekti laiendusi:

* *Protokolli objektid* on protokolli virna komponendid, mis sisaldavad võrgu suhtlust, pakkudes seejuures objektorienteeritud liidest.
* *Replitseeritud objektid* on hajusobjektide rühmad ehk *replikad*, mis haldavad hajutatud mitmeosapoolset protokolli, säilitamaks järjepidevust nende olekute vahel ning mis käsitlevad taotlusi koordineeritud moel. Üheks selliseks näiteks on vigasid taluv CORBA objekt.
* *Elavad hajusobjektid* (või lihtsalt *elavad objektid*) on *replitseeritud objektide* üldistuseks, mis võivad sisemiselt kasutada suvalist hajusprotokolli, seejuures tõenäoliselt säilitades vaid vähest järjepidevust nende siseseisundite vahel.

Mõned neist laiendustest, nagu *hajusobjektid* ja *protokollobjektid*, on valdkonnaspetsiifilised mõisted kirjeldamaks tavaobjektide eritüüpe mõnes konkreetses kontekstis (näiteks meetodi kaugväljakutse või protokolli struktuur). Teised aga, näiteks *replitseeritud objektid* ja *elavad objektid*, on tunduvalt ebastandartsemad. Erinevalt tavaobjektidest, mis asetsevad vaid ühes kohas, rakendavad nad objekti mõiste *replikate* grupile. Lisaks võib nende seisund olla ebapidev ning kuuluvus dünaamiliselt muutuda.

Semantiline veeb
----------------

 *Pikemalt artiklis Semantiline veeb*
Oma olemuselt on semantiline veeb hajusobjektide raamistikuks (*framework*). Kaheks põhitehnoloogiaks selle kontekstis on veebi ontoloogia keel (*Web Ontology Language* ehk OWL) ja ressursse kirjeldav raamistik (*Resource Description Framework* ehk RDF). OWL laiendab objekti mudelit toetudes hulgateooriale lisades seeläbi uusi modelleerimisvõimalusi, näiteks mitmekordne pärimine. RDF aga pakub võimalust defineerida põhilisi objekti nimesid, omadusi, atribuute ja suhteid, mis oleksid kättesaadavad interneti teel.

OWL-i objektid pole sarnased IDL-i teel kättesaadavate rohmakate hajusobjektidega. Interneti puhul poleks selline ühe liideste (*interface*) kimbu standartiseerimine sobivaks lähenemiseks. Ning seda eeskätt interneti pideva arengu ja muutumise tõttu. OWL-i objektid kipuvad sarnanema pigem nendega, mis on kasutusel rakenduste (*applications*) arendamisel näiteks keeltes Java ja C++.

Sellele vaatamata pole OWL-i ja tavalised objektorienteeritud programmeerimise objektid siiski täiesti ühesugused. Erinevalt traditsioonilistest objektidest, mis kompileerimise järgselt muutuvad staatilisteks struktuurideks, seejuures pärides tavaliselt vaid ühest allikast, on OWL-i objektid dünaamilised. Selline objekt võib muuta oma struktuuri programmi käigus ning muutuda lisa- või uute klasside instantsiteks.

Teine tähelepanuväärne erinevus on süsteemis puuduva informatsiooni kohtlemine. Tavaliste programmeerimisobjektide ja enamuse andmebaasi süsteemide puhul on kasutusel "suletud maailma eeldus": kui väide pole süsteemile tuttav, loetakse seda vääraks. Semantilise Veebi objektid kasutavad seevastu "avatud maailma eeldust": väidet loetakse vääraks vaid juhul, kui selleks on süsteemis vastav infokild, vastasel juhul loetakse seda teadmatuks, mis ei ole ei tõene ega väär.

Kõige enam sarnanevad OWL-i objektid tehisintellekti freim keeltega, näiteks KL-ONE ja Loom.

Järgnev tabel võrdleb objektorienteeritud keelte (näiteks Java ja C++) ning Semantilise Veebi objekte: 

| OOP objektid | Semantilise ceebi objektid |
| --- | --- |
| Klasse vaadeldakse kui instantsite tüüpe. | Klasse vaadeldakse kui üksikelementide kogumit. |
| Instantsid ei saa muuta tüüpi programmi jooksul. | Klassi liikmed võivad muutuda programmi jooksul. |
| Klasside hulk ja struktuur ei muutu pärast kompilatsiooni. | Klassid võivad olla loodud ja muudetud programmi töö ajal. |
| Kompilaator täidab oma töö programmi konstrueerimise ajal (*build-time*). | Arutlejaid (*reasoners*) kasutatakse klassifitseerimaks ja kontrollimaks järjepidevust nii programmi konstrueerimise kui ka töö (*run-time*) ajal. |
| Klassid hoiavad suure osa oma sisust imperatiivsetes funktsioonides ja meetodites. | Klassid edastavad oma sisu OWL deklaratsioonide abil. Imperatiivne kood puudub. |
| Instantsite anonüümsuse tõttu on programmist väljastpoolt nende poole pöördumine tugevalt tõkestatud. | Kõigil RDF ja OWL ressurssidel on oma unikaalne URI, mille põhjal saab nendega suhelda. |
| Suletud maailm: argumentide ebapiisavusel loetakse väide vääraks. | Avatud maailm: argumentide nappimisel loetakse väide ebamääraseks ehk ei tõeseks ega vääraks. |

Näiteid programmeerimiskeeltest
-------------------------------

### Python

```
class Koduloom:
    def \_\_init\_\_(self, nimi):
        self.nimi = nimi

class Papagoi(Koduloom):
    def \_\_init\_\_(self, nimi):
        super().\_\_init\_\_(nimi)
    def liigu(self):
        print("Ma lendan!")

minu\_papagoi = Papagoi("Kesha")

print("Mu nimi on "+ minu\_papagoi.nimi)
minu\_papagoi.liigu()

```

```
Mu nimi on Kesha
Ma lendan!

```

### JavaScript

```
class Koduloom {
 constructor(nimi) {
 this.nimi = nimi;
 }
}

class Koer extends Koduloom {
 constructor(nimi) {
 super(nimi);
 }

 tee\_häält() {
 console.log("Ma haugun!");
 }
}

minu\_koer = new Koer("Sharik");

console.log("Mind hüütakse "+ minu\_koer.nimi);
minu\_koer.tee\_häält();

```

```
Mind hüütakse Sharik
Ma haugun!

```

### C++

```
#include <string>
#include <iostream>

class Koduloom
{
public:
 std::string nimi;
 Koduloom(std::string nimi\_)
 {
 nimi = nimi\_;
 }
};

class Kass : public Koduloom
{
public:
 Kass(std::string nimi) : Koduloom(nimi) {}
 void hüppa()
 {
 std::cout << "Ma hüppan!" << std::endl;
 }
};

int main()
{
 Kass minu\_kass("Matroskin");

 std::cout << "Mu nimeks "<< minu\_kass.nimi << "!" << std::endl;
 minu\_kass.hüppa();

 return 0;
}

```

```
Mu nimeks Matroskin!
Ma hüppan!

```

Vaata ka
--------

* Objektorienteeritud programmeerimine
* Klassipõhine objektorienteeritud programmeerimine
* Klass (programmeerimine)

Viited
------

1. ↑  Oppel, Andy (2005). *SQL Demystified*. McGraw Hill. Lk 7. ISBN 0-07-226224-9.
2. ↑  
"Object identity". *cmu*. 26. aprill 1995. Vaadatud 2. novembril 2022.
3. ↑  
"Understanding OOP Concepts: Properties and Methods". *Shouts.dev*. Md Obydullah. 12. veebruar 2020. Vaadatud 2. novembril 2022.
4. ↑  
"Object Oriented Programming(OOP) Series: Attributes and Methods". *alemsbaja*. Alemoh Rapheal Baja. 24. aprill 2021. Vaadatud 2. novembril 2022.
5. ↑  Wegner, Peter (detsember 1987). Meyrowitz, Norman (toim). "Dimensions of Object-Based Language". **22** (12): 168–182. DOI:10.1145/38807.38823. `{{cite journal}}`: viitemall journal nõuab parameetrit `|journal=` (juhend)
6. ↑  Barbey, S; M. Kempe; A. Strohmeier (1993). "Object-Oriented Programming with Ada 9X". *Draft Technical Report*. Swiss Federal Institute of Technology in Lausanne Software Engineering Laboratory. Vaadatud 15. detsembril 2013.
7. ↑  "Abstrahheerimine ja kapseldamine (teabe peitmine)". *Eopearhiiv*. Vaadatud 24. oktoobril 2022.
8. ↑  Rogers, Wm. Paul (18. mai 2001). "Encapsulation is not information hiding". *InfoWorld*. Vaadatud 11. veebruaril 2022.
9. ↑  Hagverdiyev, Kanan (29. juuni 2021). "OOP Series — Composition". *Medium*. Vaadatud 12. aprillil 2022.
10. ↑  Jacobsen, Ivar; Magnus Christerson; Patrik Jonsson; Gunnar Overgaard (1992). *Object Oriented Software Engineering*. Addison-Wesley ACM Press. ISBN 0-201-54435-0.
11. ↑  "What is an Object?". *oracle.com*. Oracle Corporation. Vaadatud 13. detsembril 2013.
12. ↑  Martin, Robert C. "Design Principles and Design Patterns" (PDF). Originaali (PDF) arhiivikoopia seisuga 6. september 2015. Vaadatud 28. aprillil 2017.
13. 1 2  Orfali, Robert (1996). *The Essential Client/Server Survival Guide*. New York: Wiley Computer Publishing. Lk 399–403. ISBN 0-471-15325-7.
14. ↑  Ostrowsk, K.; K. Birman; D. Dolev; J. Ahnn (2008). *Programming with Live Distributed Objects*. Paphos, Cyprus. Lk 463–489.
15. ↑  Berners-Lee, Tim; James Hendler; Ora Lassila (17. mai 2001). "The Semantic Web A new form of Web content that is meaningful to computers will unleash a revolution of new possibilities". *Scientific American*. **284**: 34–43. DOI:10.1038/scientificamerican0501-34. Originaali arhiivikoopia seisuga 24. aprill 2013.
16. ↑  Knublauch, Holger; Oberle, Daniel; Tetlow, Phil; Wallace, Evan (9. märts 2006). "A Semantic Web Primer for Object-Oriented Software Developers". W3C. Vaadatud 30. juulil 2008.