«Դաս (ծրագրավորում)»–ի խմբագրումների տարբերություն

[[Օբյեկտ կողմնորոշված ծրագրավորում|Օբյեկտ կողմնորոշված ծրագրավորման]] մեջ '''դասը''' ընդարձակելի ծրագիր-կոդ-կաղապար է [[Օբյեկտ (ծրագրավորում)|օբյեկտներ]] ստեղծելու համար, որը ապահովում է սկզբնական արժեքներ վիճակի համար ([[անդամ փոփոխական]]ներ) և վարքագծի իրագործումներ (անդամ ֆունկցիաներ կամ [[Մեթոդ (ծրագրավորում)|մեթոդներ]]):։{{sfn|Gamma|Helm|Johnson|Vlissides|1995| p=14}}{{sfn|Bruce|2002|loc=2.1 Օբյեկտներ, դասեր և օբյեկտի տիպեր}} Շատ լեզուներում դասի անունը օգտագործվում է որպես անուն դասի համար (ինքն իրենով կաղապար), դասի լռելյայն [[Կառուցիչներ (ծրագրավորում)|կառուցիչների]] անուններ ([[ենթածրագիր]], որը ստեղծում է օբյեկտներ), և որպես օբյեկտների [[տվյալի տիպ|տիպ]], որոնք գեներացվում են դասի [[Նմուշ (ծրագրավորում)|նմուշականացման]] միջոցով:միջոցով։ Այս տարբեր հասկացությունները հեշտությամբ համակցվում են:են։ {{sfn|Bruce|2002|loc=2.1 Objects, classes, and object types}}

Երբ օբյեկտը ստեղծվում է դասի կառուցիչի կողմից, արդյունքում ստեղծված օբյեկտը կոչվում է դասի [[Նմուշ (ծրագրավորում)|նմուշ]], իսկ օբյեկտներին հատուկ անդամ փոփոխականները կոչվում են [[նմուշ փոփոխական]]ներ, որպեսզի հակադրվեն դասի միջով տարածված [[դաս փոփոխական]]ների հետ:հետ։

Որոշ լեզուներում դասերը միայն կոմպիլյացիա-ժամանակ հատկություն են (նոր դասերը չեն կարող հաստատվել գործարկման ժամանակամիջոցին), մինչդեռ այլ լեզուներում դասերը [[առաջին կարգի օբյեկտ]]ներ են և հիմնականում իրենք իրենց օբյեկտներ են (սովորաբար <code>Class</code> տիպի կամ նմանատիպ):։ Այս լեզուներում դասը, որը ստեղծում է դասեր կոչվում է [[մետադաս]]:

Սովորական օգտագործման ժամանակ մարդիկ հաճախ անդրադառնում են օբյեկտի "դասին", բայց նեղ իմաստով օբյեկտներն ունեն ''տիպ''՝ ինտերֆեյս, մասնավորապես անդամ փոփոխականների տիպեր, անդամ ֆունկցիաների (մեթոդների) ստորագրություններ, և հատկությունները բավարարում են այն:այն։ Միաժամանակ դասն ունի իրագործում (մասնավորապես մեթոդների իրագործում) և կարող է ստեղծել տրված տիպով և իրագործմամբ օբյեկտներ:օբյեկտներ։ {{sfn|Gamma|Helm|Johnson|Vlissides|1995| p=17}} Ըստ տիպերի թեորեմի՝ դասը իրագործում է, ''որոշակի'' [[տվյալների կառուցվածք]] և ենթածրագրերի հավաքածու, մինչդեռ տիպը [[Հաղորդագիր (օբյեկտ կողմնորոշված ծրագրավորում)|ինտերֆեյս]] է:է։ Տարբեր (որոշակի) դասեր կարող են ստեղծել նույն (աբստրակտ) տիպի (կախված տիպային համակարգից) օբյեկտներ, օրինակ, <code>Stack</code> տիպը կարող է իրագործվել երկու դասերով՝ <code>SmallStack</code> (արագ է փոքր ստեքերի համար, բայց գնահատում է անհաջող կերպով) և <code>ScalableStack</code> (գնահատում է լավ, բայց բարձր overhead փոքր ստեքերի համար):։ Նմանապես տրված դասը կարող է ունենալ մի քանի տարբեր կառուցիչներ:կառուցիչներ։

Տիպերը սովորաբար ներկայացնում են գոյականներ՝ մարդ, տեղ կամ առարկա, կամ [[Գոյականացում|գոյականացված]] ինչ-որ բան, իսկ դասը ներկայացնում է դրանց իրագործումը:իրագործումը։ Օրինակ՝ <code>Banana</code> տիպի կոդը կարող է ներկայացնել ընդհանուր առմամբ բանանների հատկություններն ու հնարավորությունները, մինչդեռ <code>ABCBanana</code> և <code>XYZBanana</code> դասերը կներկայացնեին բանաններ արտադրելու եղանակները (ասենք՝ բանանի մատակարարներին կամ տվյալի կառուցվածներն ու հնարավորությունները՝ բանանները ներկայացնելու կամ նկարելու համար վիդեոխաղի մեջ):։ <code>ABCBanana</code> դասը կարող էր հետո ստեղծել որոշակի բանաններ և <code>ABCBanana</code> դասի նմուշները կլինեին <code>Banana</code> տիպի օբյեկտներ:օբյեկտներ։ Հաճախ տիպի միայն եզակի իրագործումն է տրված, որի դեպքում դասի անվանումը նույնն է ինչ տիպի անվանումը:անվանումը։

Դասերը բաղկացած են կառուցվածքային և վարքագծային բաղադրիչներից:բաղադրիչներից։{{sfn|Gamma et al.|1995| p=14}} <!-- though there may not be a requirement to include any constituents at all--> Ծրագրավորման լեզուները ներառում են դասեր որպես ծրագրավորման կառուցիչ առաջարկ աջակցություն զանազան դասային հատկությունների համար և այս հատկությունների օգտագործման համար անհրաժեշտ շարահյուսությունը մեծապես փոփոխվում է մեկ ծրագրավորման լեզվից մյուսը: մյուսը։

Դասը պարունակում է [[Տվյալ (ծրագրավորում)|տվյալների]] դաշտի նկարագրություններ (կամ ''հատկություններ'', ''դաշտեր'', ''տվյալի անդամներ'', կամ ''ատրիբուտներ''):։ Սրանք հիմնականում դաշտի տիպեր և անվանումներ են, որոնք ասոցացվում են վիճակի փոփխականների հետ ծրագրի գործարկման ժամանակամիջոցին:Վիճակիժամանակամիջոցին։Վիճակի փոփոխականները պատկանում են կամ դասին, կամ դասի հատուկ նմուշներին:նմուշներին։ Լեզուների մեծամասնության մեջ դասով սահմանված կառուցվածքը որոշում է իր նմուշների կողմից օգտագործված հիշողության էջադրումը:էջադրումը։ Հնարավոր են այլ իրագործումներ, օրինակ՝ [[Python (ծրագրավորում)|Python]]-ում օբյեկտները օգտագործում են զուգորդական բանալի-արժեք կոնտեյներ:կոնտեյներ։ <ref name="pythondata model">{{cite web|url=https://docs.python.org/reference/datamodel.html|title=3. Data model|work=The Python Language Reference|publisher=Python Software Foundation|accessdate=2012-04-26}}</ref>

Որոշ ծրագրավորման լեզուներ աջակցում են [[դասի անփոփոխ մեծություն|անփոփոխ մեծություն]]ների հատկորոշմանը որպես դասի սահմանման մաս և and հարկադրում են դրանց տիպային համակարգի միջոցով:միջոցով։ Վիճակի [[Ներպարունակում (ծրագրավորում)|ներպարունակում]]ը անհրաժեշտ է դասի անփոփոխ մեծություններին հարկադրելու ունակության համար:համար։

Դասի կամ իր նմուշի վարքագիծը սահմանվում է օգտագործելով [[Մեթոդ (computer programming)|մեթոդներ]]: Մեթոդները [[ենթածրագիր|ենթածրագրեր]] են օբյեկտների կամ դասերի վրա աշխատելու ունակությամբ:ունակությամբ։ Այս գործողությունները կարող են փոխել օբյեկտի վիճակը կամ պարզապես դրան հասնելու եղանակներ տրամադրել:տրամադրել։ {{sfn|Booch|1994| p=86-88}} <!-- (Note: Some languages allow direct access to instance variables ([[C++]])). --> Գոյություն ունեն շատ մեթոդներ, բայց դրանց համար աջակցությունը տարբերվում է մի լեզվից մյուսը:մյուսը։ Մեթոդների որոշ տիպեր ստեղծված են և կոչված ծրագրավորող կոդի կողմից, մինչդեռ այլ հատուկ մեթոդներ, ինչպիսիք են կառուցիչները, փլուզիչները և փոփոխության կառավարիչները, ստեղծված են և կոչված կոմպիլյատոր գեներացված կոդի կողմից:կողմից։ Լեզուն կարող է նաև թույլ տալ ծրագրավորողին սահմանել և անվանել այդ հատուկ մեթոդները:մեթոդները։ <ref>{{cite web|url=http://www.cplusplus.com/doc/tutorial/classes/|title=Classes (I)|work=C++ Language Tutorial|publisher=cplusplus.com|accessdate=2012-04-29}}</ref><ref>{{cite web|url=http://www.cplusplus.com/doc/tutorial/classes2/|title=Classes (II)|work=C++ Language Tutorial|publisher=cplusplus.com|accessdate=2012-04-29}}</ref> === Դասի ինտերֆեյսի հասկացություն ===

Յուրաքանչյուր դաս ''իրագործում'' (կամ ''իրականացնում'') է ինտերֆեյս՝ տալով [[#Structure|կառուցվածք]] և վարքագիծ:վարքագիծ։ Կառուցվածքը բաղկացած է տվյալից և վիճակից, իսկ վարքագիծը՝ կոդից, որը հատկորոշում է, թե ինչպես են մեթոդները իրագործվել:իրագործվել։ {{sfn|Booch|1994|p=105}} Գոյություն ունի տարբերություն ինտերֆեյսի սահմանման և դրա իրագործման միջև, սակայն այս գիծը աղավաղված է շատ ծրագրավորման լեզուներում, քանի որ դասի դեկլարացիաները և՛ իրագործում են, և՛ սահմանում ինտերֆեյսը:ինտերֆեյսը։ Չնայած դրան՝ որոշ լեզուներ ապահովում են հատկություններ, որոնք բաժանում են ինտերֆեյսն ու իրագործումը:իրագործումը։ Օրինակ՝ [[#Աբստրակտ_և_կոնկրետ|աբստրակտ դասը]] կարող է սահմանել ինտերֆեյսը առանց իրագործում տալու:տալու։

Այն լեզուները, որոնք աջակցում են դասի ժառանգմանը, նաև թույլ են տալիս դասերին ժառանգել ինտերֆեյսեր այն դասերից, որոնցից իրենք ծագում են:են։ Այն լեզուներում, որոնցում աջակցում են [[#տեղեկության քողարկում և ներպարունակում|մուտքի հատկորոշիչներին]], դասի ինտերֆեյսը համարվում է դասի հանրային անդամների հավաքածու՝ ներառելով և՛ մեթոդներ, և՛ ատրիբուտներ (անուղղակի [[Փոփոխիչ մեթոդ|ստացող և տեղակայող մեթոդների]] միջոցով):։ Ցանկացած մասնավոր անդամ կամ ներքին տվյալների կառուցվածքներ նախատեսված չեն կախված լինելու արտաքին <!--client--> կոդից և այդպիսով ինտերֆեյսի մաս չեն կազմում: կազմում։

Օբյեկտ կողմնորոշված ծրագրավորման մեթոդաբանությունը թելադրում է, որ ցանակացած դասի ինտերֆեյսի գործողությունները իրարից անկախ են:են։ Դա բերում է շերտավորված նախագծի, որում ինտերֆեյսի սպասառուները օգտագործում են ինտերֆեյսում հաստատված մեթոդներ:մեթոդներ։ Ինտերֆեյսը չի դնում որևէ պահանջ սպասառուների առջև որոշակի հրամանով մեկ ինտերֆեյսի գործողություններ կանչելու համար:համար։ Այս մոտեցումն ունի առավելություն, որով սպասառու կոդը կարող է ենթադրել, որ ինտերֆեյսի գործողությունները հասանելի են օգտագործմանը ցանկացած ժամանակ, երբ սպասառուն դեպի օբյեկտ մուտք ունի:ունի։

Քո հեռուստացույցի դիմացի կոճակները ինտերֆեյս են քո և հեռուստացուցի պլաստիկ պատյանի մյուս կողմում գտնվող էլեկտրալարերի միջև:միջև։ Դու սեղմում ես "power" կոճակը հեռուստացույցը միացնելու կամ անջատելու համար:համար։ Այս օրինակում տվյալ հեռուստաացւյցը նմուշ է, յուրաքանչյուր մեթոդ ներկայացված է կոճակով, և բոլոր կոճակները միասին կազմում են ինտերֆեյս (Հեռուստացույցների այլ հավաքածուներ, որոնք քո հեռուստացույցի նույն մոդելի են, կունենան նույն ինտերֆեյսը):։ Սովորականում ինտերֆեյսը կապակցված մեթոդների խմբի հատկորոշում է առանց մեթոդների որևէ ասոցացված իրագործման:իրագործման։

Հեռուստացույցի հավաքածուն ունի նաև բազմաքանակ ''ատրիբուտներ'', ինչպիսիք են չափը և գույնը, որին աջակցում է, որոնք էլ միասին կազմում են դրա կառուցվածքը:կառուցվածքը։ Դասը ներկայացնում է հեռուստացույցի ամբողջական նկարագրություն՝ ներառելով դրա ատրիբուտները (կառուցվածք) և կոճակները (ինտերֆեյս):։

Արտադրված հեռուստացույցների ողջ քանակի ստացումը կարող է լինել հեռուստացույցի դասի ''ստատիկ մեթոդ'': Այս մեթոդը պարզորեն ասոցացված է դասի հետ, սակայն դուրս է դասի յուրաքանչյուր անհատական նմուշի տիրույթից:տիրույթից։ Մեկ այլ օրինակ կարող է լինել ստատիկ մեթոդը, որը գտնում է որոշակի նմուշ հեռուստացույցի բոլոր օբյեկտների հավաքածուից:հավաքածուից։

Հետևյալը [[մուտքի հատկորոշիչների]] ընդհանուր հավաքածուն է:է։<ref name="JavaAccessControl">{{cite web| url=http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html|title=Controlling Access to Members of a Class|work=The Java Tutorials|publisher=Oracle|accessdate=2012-04-19}}</ref>

* ''Մասնավոր'' (անգլ. ՝ "private" կամ ''class-private'') սահմանափակում է մուտքը դեպի դաս:դաս։ Միայն այն մեթոդները, որոնք նույն դասի մասն են կարող են գործածել մասնավոր անդամներ:անդամներ։

* ''Պաշտպանված'' (անգլ.՝ "protected" կամ ''class-protected'') թույլ է տալիս դասին և դրա ենթադասերին գործածել անդամը:անդամը։

* ''Հանրային''(անգլ.՝ "public") նշանակում է, որ ցանկացած կոդ կարող է գործածել անդամը իր անունով:անունով։

Չնայած շատ օբյեկտ կողմնորոշված լեզուներ պահում են վերը նշված մուտքի հատկորոշիչները, դրանց իմաստաբանությունները կարող են տարբեր լինել:լինել։

Օբյեկտ կողմնորոշված նախագծումը օգտագործում է մուտքի հատկորոշիչները համատեղ են հանրային մեթոդաբանական իրագործումների ստույգ նախագծման հետ, որպեսզի ուժեղացնեն դասի անփոփոխական-հարկադրումները օբյետկի վիճակում:վիճակում։ Մուտքի հատկորոշիչների սովորական կիրառությունն է դասի ներքին տվյալների բաժանումը իր ինտերֆեյսից:Ներքինինտերֆեյսից։Ներքին կառուցվածքը ստեղծված է մասնավորի համար, մինչդեռ հանրային [[մուտքի մեթոդ]]ները կարող են օգտագործվել մասնավոր տվյալի ստուգման կամ փոփոխման համար:համար։

Մուտքի հատկորոշիչները պարտադիր կերպով չեն կառավարում ''տեսանելիությունը'', այսինքն՝ անգամ մասնավոր անդամները կարող են տեսանելի լինել սպասառու արտաքին կոդին:կոդին։ Որոշ լեզուներում անհասանելի, բայց տեսանելի անդամը կարող է հղվել աշխատաժամանակին (օրինակ՝ անդամ ֆունկցիայից վերադարձած ցուցիչի կողմից), սակայն սպասառու կոդից անդամի անունը հղելով այն օգտագործելու փորձը կկանխվի տիպի ստոււգիչի կողմից:կողմից։ <ref>{{cite web|url=https://www.securecoding.cert.org/confluence/display/cplusplus/OOP35-CPP.+Do+not+return+references+to+private+data|title=OOP35-CPP. Do not return references to private data|work=CERT C++ Secure Coding Standard|publisher=Carnegie Mellon University|date=2010-05-10|accessdate=2012-05-07}}</ref>

Տարբեր օբյեկտ կողմնորոշված ծրագրավորման լեզուներ կիրառում են անդամի հասանելիությունն ու տեսանելիությունը տարբեր աստիճանի, և կախված լեզվի [[տիպի համակարգ]]ից և կոմպիլյացիայի գործելակերպից, կիրառվում է կամ [[կոմպիլյացիայի ժամանակ]], կամ [[Գործարկման ժամանակ]]: Օրինակ՝ [[Ջավա (ծրագրավորոման լեզու)|Java]] լեզուն չի թույլատրում սպասառոը կոդին, որը մուտք է գործում դասի մասնավոր տվյալից կոմպիլյացիա անելու:անելու։

<ref>{{cite web|url=http://introcs.cs.princeton.edu/java/11cheatsheet/errors.pdf|title=2.2 Identifiers|work=Compile and Runtime Errors in Java|first=Mordechai|last=Ben-Ari|date=2007-01-24|accessdate=2012-05-07}}</ref> <!-- whereas in languages like [[Objective-C]] or [[Perl]] client code is not restricted.--> [[C++]] լեզվում, մասնավոր մեթոդները տեսանելի են, բայց ոչ հասանելի ինտերֆեյսում, այնուամենայնիվ, դրանք կարող են պատրաստաված լինել անտեսանելի բացահայտորեն հաստատելով ողջ աբստրակտ դասերը, որոնք ցույց են տալիս ինտերֆեյսի դասերը:դասերը։ <ref name="cppinterface">{{cite web|url=http://www.drdobbs.com/cpp/184410630|title=C++ Interfaces|last=Wild|first=Fred|work=Dr. Dobb's|publisher=UBM Techweb|accessdate=2012-05-02}}</ref>

* ''Նմուշ ընդդեմ դասի հասանելիություն''. [[Ruby (ծրագրավորման լեզու)|Ruby]]-ն աջակցում է ''մասնավոր նմուշ'' և ''պաշտպանված նմուշ'' մուտքի հատկորոշիչներին փոխարեն մասնավոր դասի և պաշտպանված դասի համապատասխանաբար:համապատասխանաբար։ Նրանք տարբերվում են նրանով, որ սահմանափակում են մուտքը՝ հիմնվելով նմուշի վրա, փոխանակ նմուշի դասի վրա հիմնվելու:հիմնվելու։<ref>{{cite web

* ''Ընկեր''. C++-ը աջակցում է մի մեխանիզմի, որտեղ ֆունկցիան բացահայտորեն հաստատված որպես դասի [[ընկեր ֆունկցիա]] կարող է մուտք գործել որպես մասնավոր կամ պաշտպանված թաքցված անդամենր:անդամենր։ <ref>{{cite web|url=http://www.cplusplus.com/doc/tutorial/inheritance/

* ''Ուղի հիմնված''.Java-ն աջակցում է դեպի անդամ սահմանափակող [[Java փաթեթ]]-ի ներսում, որը տրամաբանական ուղին է ֆայլի:ֆայլի։ Դա սովորական կիրառություն է, երբ ընդլայնում են Java ֆրեյմվորկը դասերը նույն ֆրեյմվորկ դասի փաթեթում իրագործելու համար, որպեսզի մուտք գործեն պաշտպանված անդամներ:անդամներ։ * ''Ուղի հիմնված''.Java-ն աջակցում է դեպի անդամ սահմանափակող [[Java փաթեթ]]-ի ներսում, որը տրամաբանական ուղին է ֆայլի:ֆայլի։ Դա սովորական կիրառություն է, երբ ընդլայնում են Java ֆրեյմվորկը դասերը նույն ֆրեյմվորկ դասի փաթեթում իրագործելու համար, որպեսզի մուտք գործեն պաշտպանված անդամներ:անդամներ։ Աղբյուր ֆայլը կարող է գոյություն ունենալ լիովին տարբեր տեղանքում և կարող է տարածվել այլ .jar ֆայլի վրա՝ մնալով նույն տրամաբանական ուղու վրա մինչդեռ JVM-ը առընչություն ունի:ունի։<ref name=JavaAccessControl />

Ի հավելում ինքնավար դասերի նախագծին, ծրագրավորման լեզուները կարող են աշակցել դասի ավելի առաջադեմ նախագծի՝ հիմնված դասերի միջև հարաբերությունների վրա:Միջդասայինվրա։Միջդասային հարաբերության նախագծի հնարավորությունները լինում են ''կոմպոզիցիոն'' և ''աստիճանակարգային'':

Դասերը կարող են կառուցվել այլ դասերից և այդպիսով հիմնել կոմպոզիցիոն հարաբերություն ներփակող դասի և դրա զետեղված դասերի միջև:միջև։ Դասերի միջև կոմպոզիցիոն հարաբերությունը նաև հայտնի է ինչպես ''[[has-a]]'' հարաբերություն:հարաբերություն։ {{sfn|Booch|1994| p=180}} Օրինակ՝ "Մեքենա" դասը կարող է բաղկացած լինել և պարունակել "Շարժիչ" դասը:դասը։ Այդ պատճառով, մեքենան ''has a'' հարաբերության մեջ է շարժիչի հետ:հետ։ Կոմպոզիցիայի հատկանիշներից մեկն է վերահսկողությունը, որը բաղադրիչ նմուշների ներդիրն է իրենց կրող նմուշների կողմից:կողմից։ Եթե ներդիր օբյեկտը կրում է բաղադրիչ նմուշներ արժեքով, ապա բաղադրիչները և դրանց ներդիր օբյեկտը ունեն նույն [[Օբյեկտի կյանքի տևողություն|կյանքի տևողություն]]: Եթե բաղադրիչները բաղկացած են մեջբերումով, դրանք կարող են չունենալ նույն կյանքի տևողությունը:տևողությունը։{{sfn|Booch|1994| p=128-129}} Օրինակ՝ Objective-C 2.0-ում.

Այս <code>Car</code> դասը ''ունի'' <code>NSString</code> (տառաշարային օբյեկտ), <code>Engine</code> և <code>NSArray</code> (զանգված օբյեկտ) նմուշներ:նմուշներ։

[[Օբյեկտ կողմնորոշված ծրագրավորում|Օբյեկտ կողմնորոշված ծրագրավորման]] մեջ '''դասը''' ընդարձակելի ծրագիր-կոդ-կաղապար է [[Օբյեկտ (ծրագրավորում)|օբյեկտներ]] ստեղծելու համար, որը ապահովում է սկզբնական արժեքներ վիճակի համար ([[անդամ փոփոխական]]ներ) և վարքագծի իրագործումներ (անդամ ֆունկցիաներ կամ [[Մեթոդ (ծրագրավորում)|մեթոդներ]]):։{{sfn|Gamma|Helm|Johnson|Vlissides|1995| p=14}}{{sfn|Bruce|2002|loc=2.1 Օբյեկտներ, դասեր և օբյեկտի տիպեր}} Շատ լեզուներում դասի անունը օգտագործվում է որպես անուն դասի համար (ինքն իրենով կաղապար), դասի լռելյայն [[Կառուցիչներ (ծրագրավորում)|կառուցիչների]] անուններ ([[ենթածրագիր]], որը ստեղծում է օբյեկտներ), և որպես օբյեկտների [[տվյալի տիպ|տիպ]], որոնք գեներացվում են դասի [[Նմուշ (ծրագրավորում)|նմուշականացման]] միջոցով:միջոցով։ Այս տարբեր հասկացությունները հեշտությամբ համակցվում են:են։ {{sfn|Bruce|2002|loc=2.1 Objects, classes, and object types}}

Երբ օբյեկտը ստեղծվում է դասի կառուցիչի կողմից, արդյունքում ստեղծված օբյեկտը կոչվում է դասի [[Նմուշ (ծրագրավորում)|նմուշ]], իսկ օբյեկտներին հատուկ անդամ փոփոխականները կոչվում են [[նմուշ փոփոխական]]ներ, որպեսզի հակադրվեն դասի միջով տարածված [[դաս փոփոխական]]ների հետ:հետ։

Որոշ լեզուներում դասերը միայն կոմպիլյացիա-ժամանակ հատկություն են (նոր դասերը չեն կարող հաստատվել գործարկման ժամանակամիջոցին), մինչդեռ այլ լեզուներում դասերը [[առաջին կարգի օբյեկտ]]ներ են և հիմնականում իրենք իրենց օբյեկտներ են (սովորաբար <code>Class</code> տիպի կամ նմանատիպ):։ Այս լեզուներում դասը, որը ստեղծում է դասեր կոչվում է [[մետադաս]]:

Դասերը կարող են ''առաջանալ'' մեկ կամ մի քանի գոյություն ունեցող դասերից՝ հիմք դնելով աստիճանակարգային հարաբերություններ մեկից առաջացած դասերի (''հիմքային դասեր'', ''ծնող դասեր'' կամ ''վերնադասեր'') և առաջացած դասեր (''երեխա դաս'' կամ ''ենթադաս''):։ Մեկից առաջացած և առաջացած դասերի միջև հարաբերությունը սովորաբար հայտնի է որպես '''[[is-a]]''' հարաբերություն:հարաբերություն։ {{sfn|Booch|1994| p=112}} Օրինակ՝ 'Կոճակ' դասը կարող է առաջանալ 'կառավարում' դասից:դասից։ Ավելին՝ Կոճակը Կառավարում է ('''is a''' հարաբերություն):։ Ծնող դասերի կառուցվածքային և վարքագծային անդամները ''ժառանգվում'' են երեխա դասի կողմից: կողմից։ Առաջացած դասերը կարող են սահմանել հավելյալ կառուցվածքային անդամներ (տվյալային դաշտեր) և վարքագծային անդամներ (մեթոդներ) որպես հավելում նրանց, որոնք իրենք ''ժառանգել'' են և այդպիսով իրենց վերնադասերի ''մասնագիտացումներն'' են:են։ Առաջացած դասերը նաև կարող են [[վերաիմաստավորման մեթոդ |վերաիմաստավորել]] ժառանգված մեթոդները, եթե լեզուն թույլ է տալիս:տալիս։

Ոչ բոլոր լեզուներն են աջակցում բազմակի ժառանգմանը:ժառանգմանը։ Օրինակ՝ Java-ն թույլ է տալիս դասին իրագործել բազմակի ինտերֆեյսեր, բայց միայն ժառանգել մի դասից:դասից։ <ref name="javainterface">{{cite web| url=http://docs.oracle.com/javase/tutorial/java/IandI/createinterface.html|title=Interfaces|work=The Java Tutorials|publisher=Oracle|accessdate=2012-05-01}}</ref> Եթե բազմակի ժառանգումը թույլատրված է, ապա հիերարխիան [[ուղղորդված ոչ պարբերաշրջանային գրաֆ]] (կամ անգլ.՝ DAG կրճատ) է, այլ դեպքում այն [[ծառ (գրաֆների տեսություն)|ծառ]] է:է։ Հիերարխիան ունի դասեր, որպես հանգույցներ և ժառանգման հարաբերություններ՝ որպես կապեր:կապեր։ Նույն մակարդակում գտնվող դասերի ավելի հավանական է, որ կլինեն [[ասոցացիա (օբյեկտ կողմնորոշված ծրագրավորում)|ասոցացված]], քան տարբեր մակարդակներում:մակարդակներում։ Այս հիերարխիայի մակարդակները կոչվում են [[Շերտ (ծրագրավորում)|շերտեր]] կամ [[աբստրակցիայի մակարդակ]]ներ:

Տվյալ օրինակում՝ «A UITableView '''is a''' UIScrollView '''is a''' UIView '''is a''' UIResponder '''is an''' NSObject»:

Գաղափարապես վերնադասը իր ենթադասի [[վերնաբազմությունն]]: Օրինակ՝ սովորական դասի հիերարխիան կներառի <code>GraphicObject</code>-ը որպես <code>Rectangle</code>-ի և <code>Elipse</code>-ի վերնադաս, մինչդեռ <code>Square</code>-ը կլինի <code>Rectangle</code>-ի ենթադաս:ենթադաս։ Այս բոլորը [[Ենթաբազմություն|ենթաբազմության հարաբերություններ]] են բազմությունների տեսության մեջ ինչպես օրինակ այն փաստը, որ բոլոր քառակուսիները ուղղանկյուններ են, բայց ոչ բոլոր ուղղանկյուններն են քառակուսիներ:քառակուսիներ։

Հաճախ հանդիպող հայեցակարգային սխալանք է ''part of'' հարաբերությունը ենթադասի հետ շփոթելը:շփոթելը։ Օրինակ՝ ավտոմեքենան և բեռնատար մեքենան երկուսն էլ փոխադրամիջոցներ են և կլիներ հարմար դրանց մոդելավորել որպես փոխադրամիջոցների դասի ենթադաս:ենթադաս։ Սակայն, սխալ կլինի, եթե ավտոմեքենայի բաղադրիչ մասերը մոդելավորենք ինչպես ենթադասերի հարաբերությունները:հարաբերությունները։ Օրինակ՝ ավտոմեքենան կազմված է շարժիչից և մարմնից, բայց ճիշտ չի լինի շարժիչը կամ մարմինը ավտոմեքենայի ենթադաս մոդելավորել:մոդելավորել։

Օբյեկտ կողմնորոշված նախագծման մեջ այս տեսակի հարաբերութությունները սովորաբար մոդելավորվում են որպես օբյեկտի հատկություններ:հատկություններ։ Այս օրինակում Մեքենա դասը կունենար <code>մասեր</code> կոչվող հատկություն:հատկություն։ <code>մասեր</code>-ը կտպվեր, որպեսզի ցույց տար օբյեկտների հավաքածու, ինչպես օրինակ՝ <code>Մարմին, Շարժիչ, Անվադողեր,...</code> նմուշներ:նմուշներ։

Օբյեկտ մոդելավորող լեզուները, ինչպիսին է UML-ը, ներառում է "Part of"-ի տարբեր հատկանիշներ և այլ տիպի հարաբերություններ մոդելավորելու համար: համար։ Օբյեկտների բազմության հզորության պես տվյալները, սահմանափակվում են ներմուծող և արտածող արժեքներով:արժեքներով։ Այս տեղեկությունը կարող է օգտագործվել մշակող գործիքների կողմից, որպեսզի ստեղծեն հավելյալ կոդ բացի օբյեկտի սովորական տվյալային սահմանումներից:սահմանումներից։ Այնպիսի բաներ, ինչպիսին սխալանքն է ստուգվում են ստանալու և տեղադրելու մեթոդներում:մեթոդներում։ <ref>{{cite web|title=UML-to-Java transformation in IBM Rational Software Architect editions and related software|url=http://www.ibm.com/developerworks/rational/library/08/1202_berfeld/|work=ibm.com|accessdate=20 December 2013}}</ref>

Օբյեկտ դասերի համակարգը մոդելավորելիս և իրագործելիս՝ կարևոր հարց է, թե դասը մեկ, թե մեկից ավել վերնադաս ունի:ունի։ Իրական աշխարհում իրական բազմությունների հետ հազվադեպ է լինում գտնել բազմություններ, որոնք չեն հատվի մեկից ավելի այլ բազմությունների հետ:հետ։ Սակայն, մինչ որոշ համակարգեր, օրինակ՝ Flavors-ը և CLOS-ը, տալիս են հնարավորություն մեկից ավել ծնողին անել այդպես գործարկման ժամանակամիջոցին, առաջանում է բարդություն, որը շատերը օբյեկտ կողմնորոշված խմբից համարում են օբյեկտ դասերը առաջին տեղում օգտագործելու նպատակներին հակադրական:հակադրական։ Հասկանալը, թե որ դասը կլինի պատասխանատու հաղորդագրություն հասցնելու համար, կդառնա բարդ, երբ գործ ունենանք մեկից ավել վերնադասերի հետ:հետ։ Եթե օգտագործվի անզգուշորեն, ապա այս հատկությունը կարող է ներդնել նույն համակարգի բարդություն և անորոշություն, բայց դասերը ստեղծված են խույստ տալու դրանք:դրանք։<ref>{{cite book|last=Jacobsen|first=Ivar|title=Object Oriented Software Engineering|year=1992|publisher=Addison-Wesley ACM Press|isbn=0-201-54435-0|pages=43–69|author2=Magnus Christerson |author3=Patrik Jonsson |author4=Gunnar Overgaard }}</ref>

Շատ օբյեկտ կողմնորոշված լեզուներ, ինչպես՝ Smalltalk-ը և Java-ն, պահանջում են եզակի ժառանգում գործարկման ժամանակ:ժամանակ։ Այս լեզուների համար բազմակի ժառանգումը կարող է լինել օգտակար նախագծման համար, բայց ոչ իրագործման համար:համար։

Բայց և այնպես, [[սեմանտիկ ցանց]] աշխատածրագիր օբյեկտները ունեն բազմակի վերնադասեր:վերնադասեր։ Համացանցի փոփոխականությունը պահանջում է ճկունության այս մակարդակը և տեխնոլոգիական ստանդարտներ, ինչպիսին է [[Web Ontology Language|Web Ontology Language (OWL)]]-ը, որը նախատեսված են այն աջակցելու համար:համար։

Նմանատիպ խնդիր է, թե դասային աստիճանակարգը կարող է մոդիֆիկացվել, թե ոչ:ոչ։ Լեզուները, ինչպիսիք են Flavors-ը, CLOS-ը և Smalltalk-ը, բոլորը աջակցում են այս հատկությանը որպես իրենց [[մետաօբյեկտ հաղորդակարգ]]եր: Քանի որ դասերը առաջին դասի օբյեկտներ են, հնարավոր է դինամիկ կերպով փոխել նրանց կառուցվածքը՝ ուղղարկելով համապատասխան հաղորդագրություն:հաղորդագրություն։ Այլ լեզուները, որոնք ավելի կենտրոնանում են ուժեղ տպագրման վրա, օրինակ՝ Java-ն և C++-ը, թույլ չեն տալիս դասային հիերարխիային մոդիֆիկացվել գործարկման ժամանակ:ժամանակ։ Սեմանտիկ ցանց օբյեկտները ունեն հնարավորություն գործարկման ժամանակ դասերի փոփոխությունների համար:համար։ Ռացիոնալը նման է բազմաթիվ վերնադասեր թույլատրելու այն հիմնավորմանը, որ Ինտերնետը այնքան դինամիկ է և ճկուն,որ դինամիկ փոփոխությունները դեպի հիերարխիա պահանջվում են այդ փոփոխականությունը կառավարելու համար:համար։<ref>{{cite web|url=http://www.w3.org/2001/sw/BestPractices/SE/ODSD/|title=A Semantic Web Primer for Object-Oriented Software Developers|last1=Knublauch|first1=Holger|last2=Oberle|first2=Daniel|last3=Tetlow|first3=Phil|last4=Wallace|first4=Evan|publisher=[[W3C]]|date=2006-03-09|accessdate=2008-07-30}}</ref>

Չնայած այն ենթադրությանը, որ դաս հիմնված լեզուները սովորաբար ենթադրվում է, թե աջակցում են ժառանգմանը՝ ժառանգումը դասերի գաղափարի էական բաղադրիչը չէ:չէ։ Որոշ լեզուներ, հաճախ հղված որպես "[[օբյեկտ հիմնված լեզուներ]]", դեռ չեն աջակցում ժառանգմանը:ժառանգմանը։ Օբյեկտ հիմնված լեզուների օրինակները ներառում են [[Visual Basic]]-ի վաղ տարբերակները:տարբերակները։ Դրա պատճառն այն է, որ օբյեկտ հիմնված լեզուներում հնարավոր է օգտագործել ու ընդարձակել տվյալների կառուցվածքները և դրանց կցել մեթոդներ գործարկման ժամանակ:ժամանակ։ Սա բացառում է [[կոմպիլյատոր]]ին և [[ինտերպրետատոր]]ին ունակ լինել ստուգելու տիպի աղբյուր կոդում հատկորոշված, քանի որ տիպը կառուցված է դինամիկ կերպով և չի սահմանված ստատիկորեն:ստատիկորեն։ Այս լեզուների մեծամասնությունը թույլատրում է ''նմուշի վարքագիծ'' և բարդ ''օպերատիվ պոլիմորֆիզմ'':

[[Օբյեկտ կողմնորոշված վերլուծություններ]]ում և [[Unified Modelling Language|UML]]-ում երկու դասերի միջև '''ասոցացիան''' ներկայացնում է դասերի կամ նրանց համապատասխան նմուշների աշխատակցում:աշխատակցում։ Ասոցացիաները ունեն ուղղություններ, օրինակ՝ երկու դասերի միջև երկկողմանի ասոցացիան ենթադրում է, որ երկուսն էլ տեղյակ են իրենց հարաբերությունների մասին:մասին։<ref name="ibmuml">{{cite web| url=http://www.ibm.com/developerworks/rational/library/content/RationalEdge/sep04/bell/|title=UML Basics: The class diagram|last=Bell|first=Donald|work=developer Works|publisher=IBM|accessdate=2012-05-02}}</ref> Ասոցացիաները կարող են պիտակավորվել ըստ իրենց անվան կամ նպատակի:նպատակի։ {{sfn|Booch|1994| p=179}}

Ասոցացիայի դերը ասոցացիայի տրված վերջն է և բացատրում է համապատասխան դասի դերը:դերը։ Օրինակ՝ "բաժանորդի" դերը բացատորում է "Մարդ" դասի նմուշների եղանակը, որով մասնակցում են "բաժանորդագրում է" ասոցացիան "Ամսագիր" դասի հետ:հետ։ "Ամսագիրը" նաև ունի "բաժանորդագրված ամսագիր" դերը նույն ասոցացիայի մեջ:մեջ։ Ասոցացիայի դերի բաղադրյալությունը բացատրում է, թե ինչպես շատ նմուշներ համապատասխանում են ասոցացիայի այլ դասի նմուշներից յուրաքանչյուրին:յուրաքանչյուրին։ Տարածված բաղադրյալություններ են "0..1", "1..1", "1..*" և "0..*", որտեղ "*" հատկորոշում է նմուշների ցանկացած թիվ:թիվ։ <ref name=ibmuml />

Գոյություն ունեն դասերի տարբեր կատեգորիաներ, որոնցից որոշ մասը մասամբ է համընկնում:համընկնում։

Ժառանգմանը աջակցող լեզուներում'''աբստրակտ դասը''' կամ ''Աբստրակտ հիմնված դասը'' (անգլ.՝ "abstract base class", կրճատ՝ ABC) մի դաս է, որը չի կարող նմուշավորվել, քանի որ այն կամ նշանակված է որպես աբստրակտ, կամ հատկորոշում է [[աբստրակտ մեթոդ]]ները (կամ ''թվացյալ մեթոդները''):։ Աբստրակտ դասը կարող է ապահովել որոշ մեթոդների իրագործումներ և կարող է մասնավորել թվացյալ մեթոդները [[Տիպի ստորագրություն|ստորագրությունների]] միջոցով,որոնք իրագործվում են աբստրակտ դասի ուղղակի կամ անուղղակի հետնորդների կողմից:կողմից։ Մինչ աբստրակտ դասից առաջացած դասը նմուշավորվում է, իր ծնող դասի բոլոր աբստրակտ մեթոդները պետք է իրագործվեն ինչ-որ դասի կողմից ծագման շղթայում:շղթայում։ <ref name="cpppoly">{{cite web|url=http://www.cplusplus.com/doc/tutorial/polymorphism/

Շատ օբյեկտ կողմնորոշված ծրագրավորման լեզուներ թույլ են տալիս ծրագրավորողին մասնավորել, թե որ դասերն են համարվում աբստրակտ և որոնց չպետք է թողնել նմուշավորվել:նմուշավորվել։ Օրինակ՝ [[Ջավա|Java]]-ում, [[C Sharp|C#]]-ում և [[PHP]]-ում ''abstract'' բառն է օգտագործվում որպես բանալի բառ:բառ։.<ref>{{cite web| url=http://docs.oracle.com/javase/tutorial/java/IandI/abstract.html|title=Abstract Methods and Classes|work=The Java Tutorials|publisher=Oracle|accessdate=2012-05-02}}</ref><ref>{{cite web|url=http://php.net/manual/en/language.oop5.abstract.php|title=Class Abstraction|work=PHP Manual|publisher=The PHP Group|accessdate=2012-05-02}}</ref> [[C++]]-ում աբստրակտ դասը դաս է, որն ունի ամենաքիչը մեկ աբստրակտ մեթոդ տրված լեզվի համապատասխան շարահյուսությամբ (մաքուր թվացյալ ֆունկցիա C++-ի լեզվում):։<ref name=cpppoly />

Միայն թվացյալ մեթոդներից կազմված դասերը կոչվում են Մաքուր աբստրակտ հիմնված դասեր (կամ ''Pure ABC'') C++-ում և նաև հայտնի են որպես ''ինտերֆեյս'':<ref name=cppinterface /> Այլ լեզուներ՝ հատկապես Java-ն և C#-ը, աջակցում են աբստրակտ դասերի մի տարբերակի, որը կոչվում է [[Ինտերֆեյս (Java)|ինտերֆեյս]]: Այս լեզուներում [[բազմակի ժառանգում]]ը չի թույլատրվում, բայց դասը կարող է իրագործել շատ ինտերֆեյսեր:ինտերֆեյսեր։ Այսպիսի դասը կարող է ունենալ միայն աբստրակտ բոլորին հասանելի մեթոդներ:մեթոդներ։ <ref name=javainterface /><ref>{{cite web

'''Կոնկրետ դասը''' դաս է, որը կարող է [[Նմուշականացում (ծրագրավորում)|նմուշականացվել]], ի տարբերություն աբստրակտ դասերի, որոնք չեն կարող:կարող։ <!-- (In "Advanced C++ Programming Styles and Idioms", James Coplien defines "concrete class" as a class that has implicitly generated or explicitly defined special member functions that enable a class object to behave as do built-in types. These "concrete classes", then, adhere to the "Orthodox Canonical Form". Many developers who first learned the term as such, way back then, still primarily use it that way). -->

Որոշ լեզուներում դասերը կարող են հայտարարվել [[Տեսադաշտ (ծրագրավորում)|տեսադաշտում]], ոչ թե ընդհանուր տեսադաշտում:Կանտեսադաշտում։Կան այս տեսակի տարբեր դասեր:դասեր։

'''[[Ներքին դաս]]ը''' այլ դասի շուրջ սահմանված դաս է:է։ Ներքին դասի և այն պարունակող դասի միջև հարաբերությունները կարող են մեկնաբանվել որպես դասի ասոցացիայի մեկ այլ տեսակ:տեսակ։ Ներքին դասը սովորաբար ոչ ասոցացված է ներփակող դասի նմուշների հետ, ոչ էլ նմուշականացված է դրա հետ:հետ։ Կախված լեզվից՝ ներփակող դասից դուրս դասին հղելը կարող է հնարավոր լինել կամ չլինել:չլինել։ Նախկինի հետ առնչվող գաղափար է ''ներքին տիպերը'', նաև հայտնի է որպես ''տվյալի ներքին տիպ'', որը ներքին դասեր գաղափարի ընդհանրացումն է:է։ [[C++]]-ը լեզվի օրինակ է, որը աջակցում է և՛ ներքին դասերին, և՛ ներքին տիպերին (''[[typedef]]'' հայտարարությունների միջոցով):։<ref>{{cite web

Մեկ այլ տեսակ է '''տեղական դասը''', որը սահմանված է ֆունկցիայի գործողության շուրջ:շուրջ։ Սա սահմանափակում է դասի անվան հղումները դեպի տեսադաշտի շուրջ, որտեղ դասը հայտարարված է:է։ Կախված լեզվի իմաստային կանոններից՝ այնտեղ կարող է լինել հավելյալ սահմանափակումներ տեղական դասերի վրա համեմատած ոչ տեղականներին:տեղականներին։ Ընդհանուր սահմանափակումներից մեկը տեղական դասի մեթոդներին թույլ չտալն է, որպեսզի մուտք գործեն ներփակող ֆունկցիայի տեղական փոփոխականներ:փոփոխականներ։ Օրինակ՝ C++-ում տեղական դասը կարող է հղել ստատիկ փոփոխականներին, որոնք հայտարարված են իրենց ներփակող ֆունկցիայի շուրջ, բայց չեն կարող մուտք գործել ֆունկցիայի ավտոմատ փոփոխականներ:փոփոխականներ։<ref>{{cite web

'''Մետադասերը''' այն դասերն են, որոնց նմուշները ևս դասեր են:են։ {{sfn|Booch|1994|p=133-134}} Մետադասը բացատրում է դասերի հավաքածուի կառուցվածքը և կարող է իրագործել [[նախագծման ձևանմուշներ]] կամ նկարագրել որոշակի տեսակի դասեր:Մետադասերըդասեր։Մետադասերը հաճախ օգտագործվում են, որպեսզի նկարագրեն [[ֆրեյմվորկ]]եր:

Որոշ լեզուներում, օրինակ՝ [[Python]]-ում, [[Ruby]]-ում կամ [[Smalltalk]]-ում, դասը նաև օբյեկտ է, այդ պատճառով իսկ յուրաքանչյուր դաս լեզվում կառուցված առանձնահատուկ մետադասի նմուշ է:է։

| accessdate=2012-05-08}}</ref>{{sfn|Booch|1994|p=134}}[[Common Lisp Object System]]-ը (CLOS) ապահովում է [[Մետաօբյեկտ|մետաօբյեկտ հաղորդակարգեր]] (MOPs), դասերն ու մետադասերը իրագործելու համար:համար։<ref>{{cite web