Կոդավորման սովորում — Մաս 9ա. ժառանգություն և պոլիմորֆիզմ

ԺԱՌԱՆԳՈՒԹՅՈՒՆ

Հաջորդը, մենք անցնում ենք SoloLearn հավելվածի Ժառանգություն և պոլիմորֆիզմբաժին: Մենք միանշանակ խոսեցինք պոլիմորֆիզմի մասին վաղ շրջանում, այնպես որ ես հուսով եմ, որ դա բավականին լավ կհասկանամ, երբ հասնենք դրան: Նախ, սակայն, մենք կխոսենք ժառանգության մասին: Դա մեկ դասի հիման վրա մեկ այլ դասի վրա սահմանելու ունակությունն է: Ըստ երևույթին, այս…

…հեշտացնում է հավելվածի ստեղծումն ու պահպանումը:

Մմ հմմ.

Այն դասը, որի հատկությունները ժառանգվում են մեկ այլ դասի կողմից, կոչվում է baseդաս: Դասը, որը կատարում է «ժառանգում», կոչվում է ստացվածդաս: Նրանց օրինակը բավականին լավ է նկարագրում.

…հիմնական դաս Կենդանիներ կարող է օգտագործվելԿատու և Շուն դասեր ստանալու համար: ստացված դասը ժառանգում է բազային դասի բոլոր հատկանիշները և կարող է ունենալ իր սեփական լրացուցիչ հատկանիշները:

Սա դեռևս իմաստ ունի, և, անշուշտ, թվում է, թե «արդյունավետությունն» այն է, որ դուք ստիպված չեք լինի նույն բաները նորից ու նորից գրել: Այսպիսով, օգտագործելով նրանց օրինակը, «բազային» Animal դասը կունենա հետևյալ տեսքը.

class Animal {
     public int Legs { get; set; }
     public int Age { get; set; }
}

Այնուհետև մենք կցանկանայինք օգտագործել այդ Կենդանիների դասի առանձնահատկությունները, այնուհետև ունենալ որոշ լրացուցիչառանձնահատկություններ «ստացված» համար։ Շների դաս.

class Dog : Animal {
     public Dog() {
          Legs = 4;
     }
}
public void Bark() {
     Console.Write(“Woof”);
     }
}

Կարևոր է նշել կետակետը և այնուհետև base դասի անունը (: Animal): Բացի այդ, Կենդանիներ դասի բոլոր հանրային անդամները դառնում են Շուն դասի հանրային անդամներ (այդ իսկ պատճառով մենք կարող է մուտք գործել Legs անդամ Dog constructor): Այնուհետև մենք կստեղծենք Dog դասի օրինակ, մուտք կգործենք Animal դասի ժառանգվածանդամներին, ապա նաև կկանչենք : >Dog դասի սեփական անդամը (մասնավորապես, Bark մեթոդը).

static void Main(string[] args) {
     Dog d = new Dog();
     Console.WriteLine(d.Legs);
     d.Bark();
}

Ահա թե ինչ է տեղի ունենում, երբ այս կոդը կատարվում է.

• Նախ, ստեղծվում է Dog դասի նոր օրինակ, որը կոչվում է d:
• Այնուհետև մենք անցնում ենք Dog դասին, որտեղ անմիջապես (և ավտոմատ) գործարկվում է կառուցողի մեթոդը, որը կոչվում է Dog: . Դրա ներսում նշվում է թվացյալ չհայտարարված փոփոխական, որը կոչվում է Legs: Բայց քանի որ Dog դասը ստանում է Animal դասի բոլոր հատկանիշները, հանրայնորեն հասանելի ամբողջ թիվ- հայտարարված է հիմնված փոփոխական, որը կոչվում է Ոտքեր:
• Այնուհետև ստանում է իրեն վերագրված արժեքը, որտեղից այն կանչվել է: Դա Dog դասում էր, որտեղ կառուցող մեթոդում, որը կոչվում է Dog, նշանակված էր Legs փոփոխականը (կամ սահմանել) 4 արժեքը:
• Վերադառնալով Հիմնական մեթոդին, հաջորդ տողում ասվում է, որ տպեք էկրանին, Legs կոչվող փոփոխականի արժեքը Dog-ի օրինակում: > դասը կոչվում է d: Քանի որ սա 4 է, 4 տպվում է էկրանին:
• Վերջապես, Bark կոչվող մեթոդը կոչվում է Dog դասի օրինակում, որը կոչվում էd, որն ասում է, որ տպել «Woof» բառը էկրան.

Հավելվածը նաև նշում է, որ base դասը կարող է ունենալ բազմաթիվ ստացված դասեր: Այլ կերպ ասած, եթե լիներ Cat անունով դաս, այն կարող էր օգտագործել նաև Animal դասը: Ինձ դուր է գալիս նաև, թե ինչպես են նրանք նկարագրում ժառանգությունը ընդհանուր առմամբ.

…ստացված դասը ընդլայնում է բազային դասի ֆունկցիոնալությունը:

Այնուամենայնիվ, մի բան, որ դուք չեք կարող անել, այն է, որ մեկ դասը ժառանգի բազմաթիվ բազային դասերից: Ըստ երևույթին, այնուամենայնիվ, դա անելու միջոց կա ինտերֆեյս կոչվող բանով, և մենք այդ մասին կիմանանք ավելի ուշ:

ՊԱՇՏՊԱՆՎԱԾ ԱՆԴԱՄՆԵՐ

Մինչ այժմ մենք խոսել ենք միայն հանրային (անդամներին հասանելի ենցանկացած կետից դուրս դասից) ևմասնավոր (անդամները հասանելի են միայն ներսից իրենց դասերից)մուտքի փոփոխիչներ: Պաշտպանված անդամները նման են մասնավոր անդամներին, ընդունեք, որ նրանք կարող են նաև հասանելի լինել ստացված դասերից:

class Person {
     protected int Age { get; set; }
     protected string Name { get; set; }
}
class Student : Person {
     public Student(string nm) {
          Name = nm;
     }
     public void Speak() {
          Console.Write(“Name: “ + Name);
     }
}
class Program {
     static void Main(string[] args) {
          Student s = new Student(“David”);
          s.Speak();
     }
}

Ի դեպ, ես որոշեցի գրել բոլոր կոդը Visual Studio-ում, ապա պարզապես պատճենել/տեղադրել այն այստեղ: Ես իրականում գրում եմ իմ հոդվածները Microsoft OneNote-ում, այնուհետև պատճենում/տեղադրում եմ դրանք Medium (նախքան սրբագրելը): Բայց ես իսկապես ուզում եմ անընդհատ վարժվել Visual Studio-ում կոդավորմանը, այնպես որ դա կլինի իմ գործընթացը:

Ինչևէ, վերևի կոդում Student դասարանը կոչվում է և ունի Person դասը որպես բազային դաս: Հետևաբար, երբ կատարվի, Main մեթոդի շրջանակներում, Student դասի նոր օրինակ է ստեղծվում և կոչվում s: Բացի այդ, երբ ստեղծվում է, այն ուղարկում է Դավիթ տողը: Քանի որ Person դասը հիմնական դասն է (ստացված) Student դասի, երբ հաջորդ տողը. Հիմնական մեթոդը կարծես տպում է Name հատկության արժեքը էկրանին (առաջինը գալիս է Name: տողը), այդ հատկությունը հասանելի է:

Ընդհակառակը, եթե փորձենք ուղղակիորեն մուտք գործել դրան, մենք սխալ կստանանք.

static void Main(string[] args) {
     Student s = new Student(“David”);
     s.Name();
}

Դուք կարող եք նաև կանխել այլ դասերի դասի ժառանգումը (քանի որ այն հիմնական է է)՝ կնքելով այն կնքված հիմնաբառով։ , սրա նման:

sealed class Animal {
     //some code
}
class Dog : Animal {}

DERIVED CLASS CONSTRUCTOR & DESTRUCTOR

Հաջորդը, հավելվածը խոսում է ժառանգության մասին: Սովորաբար, կոնստրուկտորները կանչվում են, երբ դասի օրինակ է ստեղծվում: Այդ բազային դասի շրջանակներում, այնուամենայնիվ, կառուցողները և դեստրուկտորները ՉԵՆ ժառանգվում, ինչպես մյուս անդամները, հետևաբար, ստացված-ի կառուցողները: em> դասերը պետք է ինքնուրույն սահմանվեն:

Այսպես ասած, հիմնական դասի կառուցողը և destructor-ը ավտոմատ կերպով կանչվում են, երբ ստացվում է դասի օրինակը: օրինականացված է, ինչպես հետևյալում.

class Animal {
     public Animal() {
          Console.WriteLine(“Animal created”);
     }
     ~Animal() {
          Console.WriteLine(“Animal deleted”);
          Console.ReadLine();
     }
}
class Dog: Animal {
     public Dog() {
          Console.WriteLine(“Dog created”);
     }
     ~Dog() {
          Console.WriteLine(“Dog deleted”);
          Console.ReadLine();
     }
}
class Program {
     static void Main(string[] args) {
          Dog d = new Dog();
          Console.ReadLine();
     }
}

Գործարկելիս տեղի է ունենում հետևյալը.

• Նախ, Հիմնական մեթոդի շրջանակներում նոր Dog օբյեկտ է ստեղծվում, որը կոչվում է d:
• Մինչ մենք այնուհետև անցնում ենք Dog դասին, քանի որ Animal դասը բազայինդաս է, դրա կոնստրուկտորն ավտոմատ կերպով գործարկվում է և արդյունքում՝ Ստեղծված կենդանին տպվում է էկրանին:
• Այնուհետև (ստացված) Շուն դասում, կոնստրուկտորը էկրանին տպում է Ստեղծված շունը:
• Երբ ծրագիրը աշխատում է, երբ սեղմում եմ Enter ստեղնը, գործարկվում է Dog դասի հաջորդ տողը, destructor, որը տպում է Շունը ջնջվել է էկրանին:
• Դրանից հետո, երբ ես կրկին սեղմում եմ Enter ստեղնը, քանի որ Dog դասի օրինակը, որը կոչվում է d, ջնջվել է, destructor-ը: Animal դասում գործարկվում է, և Animal deleted տպվում է էկրանին:

Դուք նաև կիմանաք, որ ես մի քանի վայրերում ավելացրել եմ Console.ReadLine();: Սա պարզապես դադարեցնում է ծրագրի շարունակությունը, որպեսզի ես կարողանամ իրականում տեսնել, թե ինչ է կատարվում: Ծրագիրը շարունակվում է, երբ սեղմում եմ Enter ստեղնը:

Կարևոր բան, որը նշում է SoloLearn հավելվածը, այն է, որ base դասի կոնստրուկտորը կոչվում է առաջին, որին հաջորդում է կոնստրուկտորը: em> ստացված դասի: Ընդհակառակը, երբ օբյեկտը ոչնչացվում է, ստացված դասի destructor կանչվել է առաջինը, որին հաջորդում է base դասի destructor-ը: Ավելի պարզ դարձնելու համար նրանք այն այսպես են նկարագրում.

ստացված դասին անհրաժեշտ է իր բազային դասը, որպեսզի աշխատի, այդ իսկ պատճառով բազային դասի կոնստրուկտորը կոչվում է < ուժեղ>առաջին։

ՊՈԼԻՄՈՐՖԻԶՄ

Ինչպես նշվեց 2-րդ մասում, ես վերջում դիտեցի մի տեսանյութ YouTube ալիքում, որը կոչվում է Կոդավորման գնացք, Դանիել Շիֆմանի կողմից, որը կոչվում է 4.7. Ներածություն պոլիմորֆիզմին. Կոդ, ու ես սկսեցի հասկանալ. Ասել է թե, պոլիմորֆիզմ բառը նշանակում է բազմաթիվ ձևեր ունենալ: Ինչ վերաբերում է C#-ին, դա սովորաբար տեղի է ունենում այնտեղ, որտեղ կան մի շարք դասեր, որոնք կապված են միմյանց հետ ժառանգության միջոցով ընդհանուր բազային դասից: SoloLearn հավելվածում նշվում է նաև հետևյալը.

Պոլիմորֆիզմ նշանակում է, որ զանգը անդամիմեթոդին կհանգեցնի այլ իրականացման՝ կախված տեսակից օբյեկտի, որը կանչում է մեթոդը: Պարզապես, պոլիմորֆիզմը նշանակում է, որ մեկ մեթոդ կարող է ունենալ մի շարք տարբեր իրականացումներ:

Թեև պոլիմորֆիզմի մասը առնչվում է ստացված և հիմնական դասերին, դրանից ավելին կա, ինչպես նաև տեսեք հավելվածի այս բաժնում: Նրանց բերած օրինակը մի ծրագիր է, որը թույլ է տալիս օգտվողին նկարել տարբեր ձևեր: Ակնհայտ է, որ յուրաքանչյուր ձև գծված է տարբեր կերպ, և մենք չգիտենք, թե որ ձևը կընտրի օգտվողը: Պոլիմորֆիզմը թույլ կտա մեզ կանչել Draw մեթոդը կիրառելի ստացված դասում, գերակայելով նույն մեթոդը բազայում-ում: > դաս. Այս մեթոդները պետք է հայտարարվեն՝ օգտագործելով վիրտուալ հիմնաբառը (base դասի շրջանակներում): Այսպիսով, մենք կարող ենք ունենալ base դաս, որն ունի հետևյալ տեսքը.

class Shape {
     public virtual void Draw() {
          Console.Write(“Base Draw”);
     }
 }

Այդ վիրտուալ հիմնաբառը թույլ է տալիս, որ Draw մեթոդը (base դասում) չեղարկվի a -ում: ածանցյալդաս. Հավելվածում նշվում է նաև.

Վիրտուալմեթոդները թույլ են տալիս միատեսակ աշխատել հարակից օբյեկտների խմբերի հետ:

Ես լիովին չգիտեմ, թե դա ինչ է նշանակում, բայց հուսով եմ, որ մենք պարզելու ենք: Մենք կարող ենք ունենալ հետևյալ ստացված դասերը, որոնք ունեն վերևում գտնվող Shape դասը, որպես իրենց հիմնական դաս.

class Shape {
     public virtual void Draw() {
          Console.Write(“Base Draw”);
     }
}
class Circle : Shape {
     public override void Draw() {
          //draw a circle…
          Console.WriteLine(“Circle Draw”);
     }
}
class Rectangle : Shape {
     public override void Draw() {
          // draw rectangle…
          Console.WriteLine(“Rect Draw”);
     }
}

Դա շրջանցել հիմնաբառն է, որը թույլ է տալիս ստացված դասերին սահմանել այդ Draw մեթոդի իրենց տարբերակները: Այժմ մենք կարող ենք ստեղծել առանձին Shape օբյեկտներ յուրաքանչյուր ստացված դասից, այնուհետև զանգահարել նրանց Draw մեթոդները, այսպես.

static void Main(string[] args) {
     Shape c = new Circle();
     c.Draw();
     //Outputs “Circle Draw”
     Shape r = new Rectangle();
     r.Draw();
     //Outputs “Rect Draw”
}

Վերևի կոդի հետ կապված բանը, որն ինձ սկզբում շփոթեցրեց, այն էր, որ օրինակելի տողերն ասում են հետևյալը…

Shape c = new Circle();
…instead of what we’ve seen before…
Circle c = new Circle();

Եթե ​​մենք ցանկանում էինք ստեղծել նոր Circle օբյեկտ, ինչու չկանչենք Circle դասը, որը բխում է Shape (base<): /em>) դաս? Նախորդ հոդվածում ես հղում արեցի Tom McCurdy-ի կողմից ստեղծված տեսանյութին, որը կապված է SoloLearn հավելվածի մեկնաբանություններից: Նա ստեղծել է մեկ այլ տեսահոլովակ, որը կոչվում է C#: Polymorphism — virtual/override: 7 րոպեի սահմաններում նա ցույց է տալիս վերը նշված երկու տողերի միջև եղած տարբերությունները: Նա բացատրում է դրա տարբերությունը…

Shape c = new Circle();

Circle c = new Circle();