Դաս (ծրագրավորում)

Վիքիպեդիայից՝ ազատ հանրագիտարանից
HS Disambig.svg Անվան այլ կիրառումների համար տես՝ Դաս (այլ կիրառումներ)

Օբյեկտ կողմնորոշված ծրագրավորման մեջ դասը ընդարձակելի ծրագիր-կոդ-կաղապար է օբյեկտներ ստեղծելու համար, որը ապահովում է սկզբնական արժեքներ վիճակի համար (անդամ փոփոխականներ) և վարքագծի իրագործումներ (անդամ ֆունկցիաներ կամ մեթոդներ[1][2] Շատ լեզուներում դասի անունը օգտագործվում է որպես անուն դասի համար (ինքն իրենով կաղապար), դասի լռելյայն կառուցիչների անուններ (ենթածրագիր, որը ստեղծում է օբյեկտներ), և որպես օբյեկտների տիպ, որոնք գեներացվում են դասի նմուշականացման միջոցով։ Այս տարբեր հասկացությունները հեշտությամբ համակցվում են։ [3]

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

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

Դաս ընդդեմ տիպ[խմբագրել | խմբագրել կոդը]

Սովորական օգտագործման ժամանակ մարդիկ հաճախ անդրադառնում են օբյեկտի "դասին", բայց նեղ իմաստով օբյեկտներն ունեն տիպ՝ ինտերֆեյս, մասնավորապես անդամ փոփոխականների տիպեր, անդամ ֆունկցիաների (մեթոդների) ստորագրություններ, և հատկությունները բավարարում են այն։ Միաժամանակ դասն ունի իրագործում (մասնավորապես մեթոդների իրագործում) և կարող է ստեղծել տրված տիպով և իրագործմամբ օբյեկտներ։ [4] Ըստ տիպերի թեորեմի՝ դասը իրագործում է, որոշակի տվյալների կառուցվածք և ենթածրագրերի հավաքածու, մինչդեռ տիպը ինտերֆեյս է։ Տարբեր (որոշակի) դասեր կարող են ստեղծել նույն (աբստրակտ) տիպի (կախված տիպային համակարգից) օբյեկտներ, օրինակ, Stack տիպը կարող է իրագործվել երկու դասերով՝ SmallStack (արագ է փոքր ստեքերի համար, բայց գնահատում է անհաջող կերպով) և ScalableStack (գնահատում է լավ, բայց բարձր overhead փոքր ստեքերի համար)։ Նմանապես տրված դասը կարող է ունենալ մի քանի տարբեր կառուցիչներ։

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

Նախագիծ և իրագործում[խմբագրել | խմբագրել կոդը]

Դասերը բաղկացած են կառուցվածքային և վարքագծային բաղադրիչներից։[5] Ծրագրավորման լեզուները ներառում են դասեր որպես ծրագրավորման կառուցիչ առաջարկ աջակցություն զանազան դասային հատկությունների համար և այս հատկությունների օգտագործման համար անհրաժեշտ շարահյուսությունը մեծապես փոփոխվում է մեկ ծրագրավորման լեզվից մյուսը։

Կառուցվածք[խմբագրել | խմբագրել կոդը]

UML նշագրում դասերի համար

Դասը պարունակում է տվյալների դաշտի նկարագրություններ (կամ հատկություններ, դաշտեր, տվյալի անդամներ, կամ ատրիբուտներ)։ Սրանք հիմնականում դաշտի տիպեր և անվանումներ են, որոնք ասոցացվում են վիճակի փոփխականների հետ ծրագրի գործարկման ժամանակամիջոցին։Վիճակի փոփոխականները պատկանում են կամ դասին, կամ դասի հատուկ նմուշներին։ Լեզուների մեծամասնության մեջ դասով սահմանված կառուցվածքը որոշում է իր նմուշների կողմից օգտագործված հիշողության էջադրումը։ Հնարավոր են այլ իրագործումներ, օրինակ՝ Python-ում օբյեկտները օգտագործում են զուգորդական բանալի-արժեք կոնտեյներ։[6]

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

Վարքագիծ[խմբագրել | խմբագրել կոդը]

    1rightarrow.png Հիմնական հոդված՝ Մեթոդ (ծրագրավորում)

Դասի կամ իր նմուշի վարքագիծը սահմանվում է օգտագործելով մեթոդներ: Մեթոդները ենթածրագրեր են օբյեկտների կամ դասերի վրա աշխատելու ունակությամբ։ Այս գործողությունները կարող են փոխել օբյեկտի վիճակը կամ պարզապես դրան հասնելու եղանակներ տրամադրել։ [7] Գոյություն ունեն շատ մեթոդներ, բայց դրանց համար աջակցությունը տարբերվում է մի լեզվից մյուսը։ Մեթոդների որոշ տիպեր ստեղծված են և կոչված ծրագրավորող կոդի կողմից, մինչդեռ այլ հատուկ մեթոդներ, ինչպիսիք են կառուցիչները, փլուզիչները և փոփոխության կառավարիչները, ստեղծված են և կոչված կոմպիլյատոր գեներացված կոդի կողմից։ Լեզուն կարող է նաև թույլ տալ ծրագրավորողին սահմանել և անվանել այդ հատուկ մեթոդները։[8][9] === Դասի ինտերֆեյսի հասկացություն ===

    1rightarrow.png Հիմնական հոդված՝ Ինտերֆեյս (ծրագրավորում)


Յուրաքանչյուր դաս իրագործում (կամ իրականացնում) է ինտերֆեյս՝ տալով կառուցվածք և վարքագիծ։ Կառուցվածքը բաղկացած է տվյալից և վիճակից, իսկ վարքագիծը՝ կոդից, որը հատկորոշում է, թե ինչպես են մեթոդները իրագործվել։ [10] Գոյություն ունի տարբերություն ինտերֆեյսի սահմանման և դրա իրագործման միջև, սակայն այս գիծը աղավաղված է շատ ծրագրավորման լեզուներում, քանի որ դասի դեկլարացիաները և՛ իրագործում են, և՛ սահմանում ինտերֆեյսը։ Չնայած դրան՝ որոշ լեզուներ ապահովում են հատկություններ, որոնք բաժանում են ինտերֆեյսն ու իրագործումը։ Օրինակ՝ աբստրակտ դասը կարող է սահմանել ինտերֆեյսը առանց իրագործում տալու։

Այն լեզուները, որոնք աջակցում են դասի ժառանգմանը, նաև թույլ են տալիս դասերին ժառանգել ինտերֆեյսեր այն դասերից, որոնցից իրենք ծագում են։ Այն լեզուներում, որոնցում աջակցում են մուտքի հատկորոշիչներին, դասի ինտերֆեյսը համարվում է դասի հանրային անդամների հավաքածու՝ ներառելով և՛ մեթոդներ, և՛ ատրիբուտներ (անուղղակի ստացող և տեղակայող մեթոդների միջոցով)։ Ցանկացած մասնավոր անդամ կամ ներքին տվյալների կառուցվածքներ նախատեսված չեն կախված լինելու արտաքին կոդից և այդպիսով ինտերֆեյսի մաս չեն կազմում։

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

Օրինակ[խմբագրել | խմբագրել կոդը]

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

Անդամի հասանելիություն[խմբագրել | խմբագրել կոդը]

Հետևյալը մուտքի հատկորոշիչների ընդհանուր հավաքածուն է։[11]

  • Մասնավոր (անգլ. ՝ "private" կամ class-private) սահմանափակում է մուտքը դեպի դաս։ Միայն այն մեթոդները, որոնք նույն դասի մասն են կարող են գործածել մասնավոր անդամներ։
  • Պաշտպանված (անգլ.՝ "protected" կամ class-protected) թույլ է տալիս դասին և դրա ենթադասերին գործածել անդամը։
  • Հանրային(անգլ.՝ "public") նշանակում է, որ ցանկացած կոդ կարող է գործածել անդամը իր անունով։

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

Մուտքի հատկորոշիչները պարտադիր կերպով չեն կառավարում տեսանելիությունը, այսինքն՝ անգամ մասնավոր անդամները կարող են տեսանելի լինել սպասառու արտաքին կոդին։ Որոշ լեզուներում անհասանելի, բայց տեսանելի անդամը կարող է հղվել աշխատաժամանակին (օրինակ՝ անդամ ֆունկցիայից վերադարձած ցուցիչի կողմից), սակայն սպասառու կոդից անդամի անունը հղելով այն օգտագործելու փորձը կկանխվի տիպի ստոււգիչի կողմից։[12]

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

Որոշ լեզուներ ունեն այլ հասանելիության ծրագիրo.

  • Նմուշ ընդդեմ դասի հասանելիություն. Ruby-ն աջակցում է մասնավոր նմուշ և պաշտպանված նմուշ մուտքի հատկորոշիչներին փոխարեն մասնավոր դասի և պաշտպանված դասի համապատասխանաբար։ Նրանք տարբերվում են նրանով, որ սահմանափակում են մուտքը՝ հիմնվելով նմուշի վրա, փոխանակ նմուշի դասի վրա հիմնվելու։[15]
  • Ընկեր. C++-ը աջակցում է մի մեխանիզմի, որտեղ ֆունկցիան բացահայտորեն հաստատված որպես դասի ընկեր ֆունկցիա կարող է մուտք գործել որպես մասնավոր կամ պաշտպանված թաքցված անդամենր։[16]
  • Ուղի հիմնված.Java-ն աջակցում է դեպի անդամ սահմանափակող Java փաթեթ-ի ներսում, որը տրամաբանական ուղին է ֆայլի։ Դա սովորական կիրառություն է, երբ ընդլայնում են Java ֆրեյմվորկը դասերը նույն ֆրեյմվորկ դասի փաթեթում իրագործելու համար, որպեսզի մուտք գործեն պաշտպանված անդամներ։ * Ուղի հիմնված.Java-ն աջակցում է դեպի անդամ սահմանափակող Java փաթեթ-ի ներսում, որը տրամաբանական ուղին է ֆայլի։ Դա սովորական կիրառություն է, երբ ընդլայնում են Java ֆրեյմվորկը դասերը նույն ֆրեյմվորկ դասի փաթեթում իրագործելու համար, որպեսզի մուտք գործեն պաշտպանված անդամներ։ Աղբյուր ֆայլը կարող է գոյություն ունենալ լիովին տարբեր տեղանքում և կարող է տարածվել այլ .jar ֆայլի վրա՝ մնալով նույն տրամաբանական ուղու վրա մինչդեռ JVM-ը առընչություն ունի։[11]

Միջդասային հարաբերություններ[խմբագրել | խմբագրել կոդը]

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

Կոմպոզիցիոն[խմբագրել | խմբագրել կոդը]

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

@interface Մեքենա։ NSObject

@property NSString *անուն;
@property Շարժիչ *շարժիչ
@property NSArray *tires;

@end

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

Օբյեկտ կողմնորոշված ծրագրավորման մեջ դասը ընդարձակելի ծրագիր-կոդ-կաղապար է օբյեկտներ ստեղծելու համար, որը ապահովում է սկզբնական արժեքներ վիճակի համար (անդամ փոփոխականներ) և վարքագծի իրագործումներ (անդամ ֆունկցիաներ կամ մեթոդներ[1][2] Շատ լեզուներում դասի անունը օգտագործվում է որպես անուն դասի համար (ինքն իրենով կաղապար), դասի լռելյայն կառուցիչների անուններ (ենթածրագիր, որը ստեղծում է օբյեկտներ), և որպես օբյեկտների տիպ, որոնք գեներացվում են դասի նմուշականացման միջոցով։ Այս տարբեր հասկացությունները հեշտությամբ համակցվում են։ [3]

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

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

Աստիճանակարգային[խմբագրել | խմբագրել կոդը]

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

Ոչ բոլոր լեզուներն են աջակցում բազմակի ժառանգմանը։ Օրինակ՝ Java-ն թույլ է տալիս դասին իրագործել բազմակի ինտերֆեյսեր, բայց միայն ժառանգել մի դասից։[20] Եթե բազմակի ժառանգումը թույլատրված է, ապա հիերարխիան ուղղորդված ոչ պարբերաշրջանային գրաֆ (կամ անգլ.՝ DAG կրճատ) է, այլ դեպքում այն ծառ է։ Հիերարխիան ունի դասեր, որպես հանգույցներ և ժառանգման հարաբերություններ՝ որպես կապեր։ Նույն մակարդակում գտնվող դասերի ավելի հավանական է, որ կլինեն ասոցացված, քան տարբեր մակարդակներում։ Այս հիերարխիայի մակարդակները կոչվում են շերտեր կամ աբստրակցիայի մակարդակներ:

Օրինակ՝ (Պարզեցված Objective-C 2.0 կոդ iPhone SDK-ից).

@interface UIResponder : NSObject //...
@interface UIView : UIResponder //...
@interface UIScrollView : UIView //...
@interface UITableView : UIScrollView //...

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

Ենթադասի սահմանումներ[խմբագրել | խմբագրել կոդը]

    1rightarrow.png Հիմնական հոդված՝ Ժառանգում (ծրագրավորում)

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

Հաճախ հանդիպող հայեցակարգային սխալանք է part of հարաբերությունը ենթադասի հետ շփոթելը։ Օրինակ՝ ավտոմեքենան և բեռնատար մեքենան երկուսն էլ փոխադրամիջոցներ են և կլիներ հարմար դրանց մոդելավորել որպես փոխադրամիջոցների դասի ենթադաս։ Սակայն, սխալ կլինի, եթե ավտոմեքենայի բաղադրիչ մասերը մոդելավորենք ինչպես ենթադասերի հարաբերությունները։ Օրինակ՝ ավտոմեքենան կազմված է շարժիչից և մարմնից, բայց ճիշտ չի լինի շարժիչը կամ մարմինը ավտոմեքենայի ենթադաս մոդելավորել։ Օբյեկտ կողմնորոշված նախագծման մեջ այս տեսակի հարաբերութությունները սովորաբար մոդելավորվում են որպես օբյեկտի հատկություններ։ Այս օրինակում Մեքենա դասը կունենար մասեր կոչվող հատկություն։ մասեր-ը կտպվեր, որպեսզի ցույց տար օբյեկտների հավաքածու, ինչպես օրինակ՝ Մարմին, Շարժիչ, Անվադողեր,... նմուշներ։ Օբյեկտ մոդելավորող լեզուները, ինչպիսին է UML-ը, ներառում է "Part of"-ի տարբեր հատկանիշներ և այլ տիպի հարաբերություններ մոդելավորելու համար։ Օբյեկտների բազմության հզորության պես տվյալները, սահմանափակվում են ներմուծող և արտածող արժեքներով։ Այս տեղեկությունը կարող է օգտագործվել մշակող գործիքների կողմից, որպեսզի ստեղծեն հավելյալ կոդ բացի օբյեկտի սովորական տվյալային սահմանումներից։ Այնպիսի բաներ, ինչպիսին սխալանքն է ստուգվում են ստանալու և տեղադրելու մեթոդներում։[21]

Օբյեկտ դասերի համակարգը մոդելավորելիս և իրագործելիս՝ կարևոր հարց է, թե դասը մեկ, թե մեկից ավել վերնադաս ունի։ Իրական աշխարհում իրական բազմությունների հետ հազվադեպ է լինում գտնել բազմություններ, որոնք չեն հատվի մեկից ավելի այլ բազմությունների հետ։ Սակայն, մինչ որոշ համակարգեր, օրինակ՝ Flavors-ը և CLOS-ը, տալիս են հնարավորություն մեկից ավել ծնողին անել այդպես գործարկման ժամանակամիջոցին, առաջանում է բարդություն, որը շատերը օբյեկտ կողմնորոշված խմբից համարում են օբյեկտ դասերը առաջին տեղում օգտագործելու նպատակներին հակադրական։ Հասկանալը, թե որ դասը կլինի պատասխանատու հաղորդագրություն հասցնելու համար, կդառնա բարդ, երբ գործ ունենանք մեկից ավել վերնադասերի հետ։ Եթե օգտագործվի անզգուշորեն, ապա այս հատկությունը կարող է ներդնել նույն համակարգի բարդություն և անորոշություն, բայց դասերը ստեղծված են խույստ տալու դրանք։[22]

Շատ օբյեկտ կողմնորոշված լեզուներ, ինչպես՝ Smalltalk-ը և Java-ն, պահանջում են եզակի ժառանգում գործարկման ժամանակ։ Այս լեզուների համար բազմակի ժառանգումը կարող է լինել օգտակար նախագծման համար, բայց ոչ իրագործման համար։ Բայց և այնպես, սեմանտիկ ցանց աշխատածրագիր օբյեկտները ունեն բազմակի վերնադասեր։ Համացանցի փոփոխականությունը պահանջում է ճկունության այս մակարդակը և տեխնոլոգիական ստանդարտներ, ինչպիսին է Web Ontology Language (OWL)-ը, որը նախատեսված են այն աջակցելու համար։

Նմանատիպ խնդիր է, թե դասային աստիճանակարգը կարող է մոդիֆիկացվել, թե ոչ։ Լեզուները, ինչպիսիք են Flavors-ը, CLOS-ը և Smalltalk-ը, բոլորը աջակցում են այս հատկությանը որպես իրենց մետաօբյեկտ հաղորդակարգեր: Քանի որ դասերը առաջին դասի օբյեկտներ են, հնարավոր է դինամիկ կերպով փոխել նրանց կառուցվածքը՝ ուղարկելով համապատասխան հաղորդագրություն։ Այլ լեզուները, որոնք ավելի կենտրոնանում են ուժեղ տպագրման վրա, օրինակ՝ Java-ն և C++-ը, թույլ չեն տալիս դասային հիերարխիային մոդիֆիկացվել գործարկման ժամանակ։ Սեմանտիկ ցանց օբյեկտները ունեն հնարավորություն գործարկման ժամանակ դասերի փոփոխությունների համար։ Ռացիոնալը նման է բազմաթիվ վերնադասեր թույլատրելու այն հիմնավորմանը, որ Ինտերնետը այնքան դինամիկ է և ճկուն,որ դինամիկ փոփոխությունները դեպի հիերարխիա պահանջվում են այդ փոփոխականությունը կառավարելու համար։[23]

Դասի հասկացության և ժառանգման ուղղանկյունություն[խմբագրել | խմբագրել կոդը]

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

Օբյեկտ կողմնորոշված վերլուծությունների շրջանակներում[խմբագրել | խմբագրել կոդը]

Օբյեկտ կողմնորոշված վերլուծություններում և UML-ում երկու դասերի միջև ասոցացիան ներկայացնում է դասերի կամ նրանց համապատասխան նմուշների աշխատակցում։ Ասոցացիաները ունեն ուղղություններ, օրինակ՝ երկու դասերի միջև երկկողմանի ասոցացիան ենթադրում է, որ երկուսն էլ տեղյակ են իրենց հարաբերությունների մասին։[24] Ասոցացիաները կարող են պիտակավորվել ըստ իրենց անվան կամ նպատակի։ [25]

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

Դասերի դասակարգում[խմբագրել | խմբագրել կոդը]

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

Աբստրակտ և կոնկրետ[խմբագրել | խմբագրել կոդը]

Ժառանգմանը աջակցող լեզուներումաբստրակտ դասը կամ Աբստրակտ հիմնված դասը (անգլ.՝ "abstract base class", կրճատ՝ ABC) մի դաս է, որը չի կարող նմուշավորվել, քանի որ այն կամ նշանակված է որպես աբստրակտ, կամ հատկորոշում է աբստրակտ մեթոդները (կամ թվացյալ մեթոդները)։ Աբստրակտ դասը կարող է ապահովել որոշ մեթոդների իրագործումներ և կարող է մասնավորել թվացյալ մեթոդները ստորագրությունների միջոցով,որոնք իրագործվում են աբստրակտ դասի ուղղակի կամ անուղղակի հետնորդների կողմից։ Մինչ աբստրակտ դասից առաջացած դասը նմուշավորվում է, իր ծնող դասի բոլոր աբստրակտ մեթոդները պետք է իրագործվեն ինչ-որ դասի կողմից ծագման շղթայում։[26]

Շատ օբյեկտ կողմնորոշված ծրագրավորման լեզուներ թույլ են տալիս ծրագրավորողին մասնավորել, թե որ դասերն են համարվում աբստրակտ և որոնց չպետք է թողնել նմուշավորվել։ Օրինակ՝ Java-ում, C#-ում և PHP-ում abstract բառն է օգտագործվում որպես բանալի բառ։.[27][28] C++-ում աբստրակտ դասը դաս է, որն ունի ամենաքիչը մեկ աբստրակտ մեթոդ տրված լեզվի համապատասխան շարահյուսությամբ (մաքուր թվացյալ ֆունկցիա C++-ի լեզվում)։[26]

Միայն թվացյալ մեթոդներից կազմված դասերը կոչվում են Մաքուր աբստրակտ հիմնված դասեր (կամ Pure ABC) C++-ում և նաև հայտնի են որպես ինտերֆեյս:[14] Այլ լեզուներ՝ հատկապես Java-ն և C#-ը, աջակցում են աբստրակտ դասերի մի տարբերակի, որը կոչվում է ինտերֆեյս: Այս լեզուներում բազմակի ժառանգումը չի թույլատրվում, բայց դասը կարող է իրագործել շատ ինտերֆեյսեր։ Այսպիսի դասը կարող է ունենալ միայն աբստրակտ բոլորին հասանելի մեթոդներ։[20][29][30]

Կոնկրետ դասը դաս է, որը կարող է նմուշականացվել, ի տարբերություն աբստրակտ դասերի, որոնք չեն կարող։

Տեղական և ներքին[խմբագրել | խմբագրել կոդը]

Որոշ լեզուներում դասերը կարող են հայտարարվել տեսադաշտում, ոչ թե ընդհանուր տեսադաշտում։Կան այս տեսակի տարբեր դասեր։

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

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

Մետադասեր[խմբագրել | խմբագրել կոդը]

Մետադասերը այն դասերն են, որոնց նմուշները ևս դասեր են։ [34] Մետադասը բացատրում է դասերի հավաքածուի կառուցվածքը և կարող է իրագործել նախագծման ձևանմուշներ կամ նկարագրել որոշակի տեսակի դասեր։Մետադասերը հաճախ օգտագործվում են, որպեսզի նկարագրեն ֆրեյմվորկեր: Որոշ լեզուներում, օրինակ՝ Python-ում, Ruby-ում կամ Smalltalk-ում, դասը նաև օբյեկտ է, այդ պատճառով իսկ յուրաքանչյուր դաս լեզվում կառուցված առանձնահատուկ մետադասի նմուշ է։ [6][35][36]Common Lisp Object System-ը (CLOS) ապահովում է մետաօբյեկտ հաղորդակարգեր (MOPs), դասերն ու մետադասերը իրագործելու համար։[37]

Ոչ ենթադասային[խմբագրել | խմբագրել կոդը]

Խառնուկներ[խմբագրել | խմբագրել կոդը]

Մասնակի[խմբագրել | խմբագրել կոդը]

Չնմուշավորվող[խմբագրել | խմբագրել կոդը]

Անանուն[խմբագրել | խմբագրել կոդը]

Տես նաև[խմբագրել | խմբագրել կոդը]

Ծանոթագրություններ[խմբագրել | խմբագրել կոդը]

  1. 1,0 1,1 Gamma, Helm, էջ` 14
  2. 2,0 2,1 Bruce, 2002, մեկնաբանություն՝ 2.1 Օբյեկտներ, դասեր և օբյեկտի տիպեր
  3. 3,0 3,1 Bruce, 2002, մեկնաբանություն՝ 2.1 Objects, classes, and object types
  4. Gamma, Helm, էջ` 17
  5. Gamma et al., 1995, էջ` 14
  6. 6,0 6,1 «3. Data model»։ The Python Language Reference։ Python Software Foundation։ Վերցված է 2012-04-26 
  7. Booch, 1994, էջ` 86-88
  8. «Classes (I)»։ C++ Language Tutorial։ cplusplus.com։ Վերցված է 2012-04-29 
  9. «Classes (II)»։ C++ Language Tutorial։ cplusplus.com։ Վերցված է 2012-04-29 
  10. Booch, 1994, էջ` 105
  11. 11,0 11,1 «Controlling Access to Members of a Class»։ The Java Tutorials։ Oracle։ Վերցված է 2012-04-19 
  12. «OOP35-CPP. Do not return references to private data»։ CERT C++ Secure Coding Standard։ Carnegie Mellon University։ 2010-05-10։ Վերցված է 2012-05-07 
  13. Ben-Ari Mordechai (2007-01-24)։ «2.2 Identifiers»։ Compile and Runtime Errors in Java։ Վերցված է 2012-05-07 
  14. 14,0 14,1 Wild Fred։ «C++ Interfaces»։ Dr. Dobb's։ UBM Techweb։ Վերցված է 2012-05-02 
  15. Thomas, Hunt։ «Classes, Objects, and Variables»։ Programming Ruby: The Pragmatic Programmer's Guide։ Ruby-Doc.org։ Վերցված է 2012-04-26 
  16. «Friendship and inheritance»։ C++ Language Tutorial։ cplusplus.com։ Վերցված է 2012-04-26 
  17. Booch, 1994, էջ` 180
  18. Booch, 1994, էջ` 128-129
  19. Booch, 1994, էջ` 112
  20. 20,0 20,1 «Interfaces»։ The Java Tutorials։ Oracle։ Վերցված է 2012-05-01 
  21. «UML-to-Java transformation in IBM Rational Software Architect editions and related software»։ ibm.com։ Վերցված է 20 December 2013 
  22. Jacobsen, Ivar; Magnus Christerson; Patrik Jonsson; Gunnar Overgaard (1992). Object Oriented Software Engineering. Addison-Wesley ACM Press. էջեր 43–69. ISBN 0-201-54435-0. 
  23. Knublauch Holger, Oberle Daniel, Tetlow Phil, Wallace Evan (2006-03-09)։ «A Semantic Web Primer for Object-Oriented Software Developers»։ W3C։ Վերցված է 2008-07-30 
  24. 24,0 24,1 Bell Donald։ «UML Basics: The class diagram»։ developer Works։ IBM։ Վերցված է 2012-05-02 
  25. Booch, 1994, էջ` 179
  26. 26,0 26,1 «Polymorphism»։ C++ Language Tutorial։ cplusplus.com։ Վերցված է 2012-05-02 
  27. «Abstract Methods and Classes»։ The Java Tutorials։ Oracle։ Վերցված է 2012-05-02 
  28. «Class Abstraction»։ PHP Manual։ The PHP Group։ Վերցված է 2012-05-02 
  29. «Interfaces (C# Programming Guide)»։ C# Programming Guide։ Microsoft։ Վերցված է 2013-08-15 
  30. «Inheritance (C# Programming Guide)»։ C# Programming Guide։ Microsoft։ Վերցված է 2012-05-02 
  31. «Nested classes (C++ only)»։ XL C/C++ V8.0 for AIX։ IBM։ Վերցված է 2012-05-07 
  32. «Local type names (C++ only)»։ XL C/C++ V8.0 for AIX։ IBM։ Վերցված է 2012-05-07 
  33. «Local classes (C++ only)»։ XL C/C++ V8.0 for AIX։ IBM։ Վերցված է 2012-05-07 
  34. Booch, 1994, էջ` 133-134
  35. | url=http://www.ruby-doc.org/docs/ProgrammingRuby/html/classes.html | title=Classes and Objects | work=Programming Ruby: The Pragmatic Programmer's Guide | last=Thomas | last2=Hunt | publisher=Ruby-Doc.org | accessdate=2012-05-08}}
  36. Booch, 1994, էջ` 134
  37. «MOP: Concepts»։ The Common Lisp Object System MetaObject Protocol։ Association of Lisp Users։ Վերցված է 2012-05-08 

Արտաքին հղումներ[խմբագրել | խմբագրել կոդը]