C # - Разлика между абстрактно, виртуално и отмяна

° С#

Днес бих искал да ви покажа разликата между абстрактно, виртуално и преодоляване в C #.

абстрактен

Като добавите абстракт към функция или клас, това означава, че той не е реален и чака да бъде реализиран от извлечения клас. Нека създадем абстрактен клас Animal:

публичен абстрактен клас Животни
{
       публична невалидна кора ()
       {
            Console.WriteLine („Кора на животните“);
       }
 }

Нека се опитаме да създадем екземпляр от клас Animal.

Животно животно = ново животно ();

Нека го стартираме и компилаторът ще ви върне грешка, казвайки, че не можете да създадете екземпляр от абстрактния клас

Абстрактният клас не може да бъде инстанциран

Нека създадем клас, който наследява Animal.

Куче от обществена класа: Животно
{
   публична невалидна кора ()
   {
      Console.WriteLine („Кучешки лай“);
   }
}

Сега ние можем да създадем инстанция на Animal, като създадем обект Dog. Разбира се, можем да създадем и екземпляр от тип Dog with Dog.

Животно животно = ново куче ();
Куче куче = ново куче ();

Обикновено бихте искали да използвате първия ред, защото когато създавате повече и повече класове, които наследяват Animal, всички те все още са тип Animal и могат да бъдат предадени да функционират с параметър на Animal type или колекция с Animal type. Това се нарича Полиморфизъм.

И така, какво се случва с кората на функцията? За променливо животно, тъй като неговият тип е Animal, ще се извика функция на кора, дефинирана в клас Animal. За променливото куче, тъй като неговият тип е Dog, ще се извиква функция на лай, дефинирана в клас Dog.

Ако поставите абстракт за функциите, не можете да внедрите функцията в този клас и трябва да я внедрите в производен клас. Нека променим класа Животни и Кучета в това:

публичен абстрактен клас Животни
{
     публична абстрактна пуста кора ()
     {
          Console.WriteLine („Кора на животните“);
     }
}
Куче от обществена класа: Животно
{
      публична невалидна кора ()
      {
           Console.WriteLine („Кучешки лай“);
      }
}

При стартиране грешките при компилиране са върнати.

Абстрактната функция не може да бъде приложена

Затова нека следваме инструкциите на съставителя. Премахнете прилагането на кора в клас Animal и стартирайте. Какво? Грешка при компилиране се връща !! ??

Замяна

Да. Тук идва втората ключова дума - отмяна. За да внедрите функцията на кора в клас Animal в клас Dog, трябва да добавите замяна на функцията за лай, така че да кажете на компилатора, че прилагате лай в клас Animal, вместо да добавяте друга функция на кора в клас Dog (като това, което направихме по-рано). След модификация, компилация успех и вече можете да видите, че и двата реда са "Кучешки лай".

Виртуален

Нека да поговорим за виртуални. Чрез добавяне на виртуална към функция, вие предоставяте общата логика за функцията, но предоставяте гъвкавост за отмяна на основната функция. Може да кажете, че е почти едно и също нещо, когато не добавяте виртуални към функцията. Не, не е. Сега ви демонстрирам разликата между виртуална и не-виртуална функция. Нека да променим класовете за животни и кучета и основната функция:

Програма за обществени класове
{
    static void Main (string [] args)
    {
        Животно животно = ново куче ();
        Куче куче = ново куче ();
        animal.bark ();
        кучешки лай();
        animal.eat ();
        dog.eat ();
        Console.ReadLine ();
    }
}
обществена класа Животни
{
    публична виртуална невалидна кора ()
    {
        Console.WriteLine („Кора на животните“);
    }
    публично невалидно яде ()
    {
        Console.WriteLine („Animal Eat“);
    }
}
Куче от обществена класа: Животно
{
    публично отменяне на невалидна кора ()
    {
        Console.WriteLine („Кучешки лай“);
    }
    публично невалидно яде ()
    {
        Console.WriteLine („Куче яде“);
    }
}

И резултатът е следният:

Когато отменяте виртуалната функция в базовия клас, двете функции в клас Base и Derived ще бъдат еднакви. Без виртуални и преодоляване ще имате 2 различни функции - Animal.bark и Dog.bark.

Нека да направим още един експеримент. Добавяне на следните 2 реда в Главна функция:

Animal animal2 = ново Животно ();
animal2.bark ();

Сега, когато го стартирате, получавате логиката, дефинирана в клас Animal. Така че нека обобщим тези 3 комбинации от декларация и резултатите:

Животно животно = ново куче (); animal.bark (); // Изход: Кучешки лай
Кучешко куче = ново куче (); dog.bark (); // Изход: Кучешки лай
Animal animal2 = ново Животно (); animal2.bark (); // Изход: Кора на животните

Резюме:

За абстракт, когато използвате в клас, не можете да създадете екземпляр от този клас. Можете да създадете екземпляр на детския клас, който го наследява, или да създадете екземпляр на детския клас с тип основен клас. Когато използвате функцията, не можете да внедрите функцията в базовия клас и трябва да бъде отменен от детски клас.

За виртуални можете да внедрите функцията в базовия клас. След като класът за деца го отмени, ще има само 1 версия на тази функция.

За отмяна, отместването може да се приложи само на замени, виртуално или абстрактно.

Това е за днес. Надявам се, момчета да се насладите на статията и да имате добър ден

Първоначално публикуван на timmydinheing.com на 18 април 2018 г.