Jaka jest różnica między funkcją abstrakcyjną a funkcją wirtualną?

Funkcja abstrakcyjna nie ma implementacji i może być zadeklarowana tylko na klasie abstrakcyjnej. Wymusza to na klasie pochodnej dostarczenie implementacji. Funkcja wirtualna zapewnia domyślną implementację i może istnieć zarówno w klasie abstrakcyjnej, jak i nieabstraktowej. Tak na przykład:

public abstract class myBase
{
    //If you derive from this class you must implement this method. notice we have no method body here either
    public abstract void YouMustImplement();

    //If you derive from this class you can change the behavior but are not required to
    public virtual void YouCanOverride()
    { 
    }
}

public class MyBase
{
   //This will not compile because you cannot have an abstract method in a non-abstract class
    public abstract void YouMustImplement();
}

1. tylko abstract klasy mogą mieć abstract członków.
2. Klasa Nie-abstract, która dziedziczy z abstract klasy musi override jego abstract członków.
3. An abstract member is implicite virtual.
4. członek abstract nie może dostarczyć żadnej implementacji (abstract nazywa się pure virtual w niektórych językach).

Zawsze musisz nadpisać abstrakcyjną funkcję.

Tak więc:

• Funkcje abstrakcyjne - Gdy Dziedzic musi dostarczyć własną implementację
• Virtual - Gdy to Dziedzic decyduje

Funkcja Abstrakcyjna:

1. może być zadeklarowana tylko wewnątrz klasy abstrakcyjnej.
2. zawiera tylko deklaracja metody nie implementacja w klasie abstrakcyjnej.
3. musi być nadpisany w klasie pochodnej.

Funkcja Wirtualna:

1. może być zadeklarowana zarówno wewnątrz klasy abstrakcyjnej, jak i nieabstraktowej.
2. zawiera implementację metody.
Może być przesłonięta.

Metoda abstrakcyjna: Gdy klasa zawiera metodę abstrakcyjną, klasa ta musi być zadeklarowana jako abstrakcyjna. Metoda abstrakcyjna nie ma implementacji i dlatego klasy, które wywodzą się z tej abstrakcyjnej klasy, muszą zapewnić implementację dla tej abstrakcyjnej metody.

Metoda wirtualna: Klasa może mieć metodę wirtualną. Metoda wirtualna ma implementację. Gdy dziedziczysz z klasy, która ma metodę wirtualną, możesz zastąpić metodę wirtualną i zapewnić dodatkowe logiki, lub zastąp logikę własną implementacją.

Kiedy używać co: W niektórych przypadkach wiesz, że niektóre typy powinny mieć określoną metodę, ale nie wiesz, jaką implementację powinna mieć ta metoda.
W takich przypadkach można utworzyć interfejs, który zawiera metodę z tym podpisem. Jeśli jednak masz taki przypadek, ale wiesz, że implementatorzy tego interfejsu będą mieli również inną popularną metodę( dla której możesz już dostarczyć implementację), to może utworzyć klasę abstrakcyjną. Ta abstrakcyjna klasa zawiera następnie metodę abstrakcyjną (która musi być nadpisana) i inną metodę, która zawiera 'wspólną' logikę.

Metoda wirtualna powinna być użyta, jeśli masz klasę, która może być użyta bezpośrednio, ale dla której chcesz, aby Dziedzice mogły zmienić pewne zachowanie, chociaż nie jest to obowiązkowe.

Explanation: with analogies. mam nadzieję, że to ci pomoże.

Context

Pracuję na 21 piętrze budynku. I mam paranoję na punkcie ognia. Od czasu do czasu, gdzieś na świecie, Ogień spala skrobak nieba. Ale na szczęście mamy gdzieś instrukcję, co robić w razie pożaru:

FireEscape()

1. nie zbieraj rzeczy
2. Walk to fire escape
3. Walk out of budynek

Jest to w zasadzie wirtualna metoda o nazwie FireEscape()

Metoda Wirtualna

Ten plan jest całkiem dobry dla 99% okoliczności. To podstawowy plan, który działa. Ale istnieje 1% szansa, że wyjście pożarowe jest zablokowane lub uszkodzone, w którym to przypadku jesteś całkowicie przerąbany i staniesz się tostem, chyba że podejmiesz jakieś drastyczne działania. Za pomocą metod wirtualnych możesz to zrobić: możesz zastąpić podstawowy plan FireEscape () swoim własnym wersja planu:

1. Uruchom do okna
2. Jump out the window
3. spadochron bezpiecznie do dna

Innymi słowy metody wirtualne zapewniają podstawowy plan, który można zastąpić, jeśli trzeba . Podklasy mogą nadpisać metodę wirtualną klasy nadrzędnej, jeśli programista uzna to za stosowne.

Metody abstrakcyjne

Nie wszystkie organizacje są dobrze wywiercone. Niektóre organizacje nie wykonują ćwiczeń przeciwpożarowych. Nie mają Ogólna polityka ucieczki. Każdy jest dla siebie. Kierownictwo jest zainteresowane tylko taką polityką istniejącą.

Innymi słowy, każda osoba jest zmuszona do opracowania własnej metody FireEscape (). Jeden facet wyjdzie schodami przeciwpożarowymi. Inny facet skoczy na spadochronie. Inny facet użyje technologii napędu rakietowego, by odlecieć z budynku. Inny facet się zjawi. Zarządzanie nie obchodzi Jak uciekasz, o ile masz podstawowy plan FireEscape () - jeśli nie możesz mieć pewność, że BHP spadnie na organizację jak tona cegieł. To jest to, co rozumie się przez abstrakcyjną metodę.

Jaka jest różnica między nimi?

Metoda abstrakcyjna: podklasy są forced Aby wdrożyć własną metodę FireEscape. Dzięki wirtualnej metodzie masz podstawowy plan, który czeka na ciebie, ale możesz wybrać , aby wdrożyć swój własny, jeśli nie jest wystarczająco dobry.

To nie było takie trudne, prawda?

Metoda abstrakcyjna jest metodą, która musi być zaimplementowana, aby utworzyć konkretną klasę. Deklaracja jest w klasie abstrakcyjnej (a każda klasa z metodą abstrakcyjną musi być klasą abstrakcyjną) i musi być zaimplementowana w klasie konkretnej.

Metoda wirtualna jest metodą, która może być nadpisana w klasie pochodnej za pomocą nadpisania, zastępując zachowanie w klasie nadrzędnej. Jeśli nie obejdziesz, uzyskasz oryginalne zachowanie. Jeśli to zrobisz, zawsze będziesz miał nowe zachowanie. W przeciwieństwie do metod Nie wirtualnych, które nie mogą być nadpisane, ale mogą ukryć oryginalną metodę. Odbywa się to za pomocą modyfikatora new.

Zobacz następujący przykład:

public class BaseClass
{
    public void SayHello()
    {
        Console.WriteLine("Hello");
    }


    public virtual void SayGoodbye()
    {
        Console.WriteLine("Goodbye");
    }

    public void HelloGoodbye()
    {
        this.SayHello();
        this.SayGoodbye();
    }
}


public class DerivedClass : BaseClass
{
    public new void SayHello()
    {
        Console.WriteLine("Hi There");
    }


    public override void SayGoodbye()
    {
        Console.WriteLine("See you later");
    }
}

Kiedy uruchamiam DerivedClass i dzwonię SayHello lub SayGoodbye, dostaję "cześć" i "do zobaczenia później". Jeśli zadzwonię HelloGoodbye, dostaję "cześć" i "do zobaczenia później". Dzieje się tak dlatego, że SayGoodbye jest wirtualny i może być zastąpiony klasami pochodnymi. SayHello jest tylko ukryty, więc kiedy wywołuję to z mojej klasy bazowej, dostaję swój oryginalny metoda.

Metody abstrakcyjne są w domyśle wirtualne. Definiują zachowanie, które musi być obecne, bardziej jak interfejs.

Metody abstrakcyjne są zawsze wirtualne. Nie mogą mieć realizacji.

To jest główna różnica.

Zasadniczo, użyłbyś metody wirtualnej, jeśli masz 'domyślną' implementację i chcesz zezwolić potomkom na zmianę jej zachowania.

Metodą abstrakcyjną zmuszasz Potomków do dostarczenia implementacji.

Uprościłem to, wprowadzając kilka ulepszeń na następujących klasach (z innych odpowiedzi):

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace TestOO
{
    class Program
    {
        static void Main(string[] args)
        {
            BaseClass _base = new BaseClass();
            Console.WriteLine("Calling virtual method directly");
            _base.SayHello();
            Console.WriteLine("Calling single method directly");
            _base.SayGoodbye();

            DerivedClass _derived = new DerivedClass();
            Console.WriteLine("Calling new method from derived class");
            _derived.SayHello();
            Console.WriteLine("Calling overrided method from derived class");
            _derived.SayGoodbye();

            DerivedClass2 _derived2 = new DerivedClass2();
            Console.WriteLine("Calling new method from derived2 class");
            _derived2.SayHello();
            Console.WriteLine("Calling overrided method from derived2 class");
            _derived2.SayGoodbye();
            Console.ReadLine();
        }
    }


    public class BaseClass
    {
        public void SayHello()
        {
            Console.WriteLine("Hello\n");
        }
        public virtual void SayGoodbye()
        {
            Console.WriteLine("Goodbye\n");
        }

        public void HelloGoodbye()
        {
            this.SayHello();
            this.SayGoodbye();
        }
    }


    public abstract class AbstractClass
    {
        public void SayHello()
        {
            Console.WriteLine("Hello\n");
        }


        //public virtual void SayGoodbye()
        //{
        //    Console.WriteLine("Goodbye\n");
        //}
        public abstract void SayGoodbye();
    }


    public class DerivedClass : BaseClass
    {
        public new void SayHello()
        {
            Console.WriteLine("Hi There");
        }

        public override void SayGoodbye()
        {
            Console.WriteLine("See you later");
        }
    }

    public class DerivedClass2 : AbstractClass
    {
        public new void SayHello()
        {
            Console.WriteLine("Hi There");
        }
        // We should use the override keyword with abstract types
        //public new void SayGoodbye()
        //{
        //    Console.WriteLine("See you later2");
        //}
        public override void SayGoodbye()
        {
            Console.WriteLine("See you later");
        }
    }
}

Wiązanie jest procesem mapowania nazwy na jednostkę kodu.

Późne wiązanie oznacza, że używamy nazwy, ale odkładamy mapowanie. Innymi słowy, najpierw tworzymy / wymieniamy nazwę i pozwalamy, aby jakiś późniejszy proces obsługiwał mapowanie kodu do tej nazwy.

Rozważmy teraz:

W porównaniu z ludźmi, maszyny są naprawdę dobre w wyszukiwaniu i sortowaniu.]} [[15]}W Porównaniu do maszyn, ludzie są naprawdę dobrzy w wynalazczości i Innowacje

Innymi słowy, virtual oznacza:

"Drogi runtime , połącz odpowiedni kod z tą nazwą, robiąc to, co robisz najlepiej: szukając "

Natomiast abstract oznacza:

"drogi programiście , proszę powiązać odpowiedni kod z tą nazwą, robiąc to, co robisz najlepiej: wymyślanie "

Ze względu na kompletność, przeciążenie oznacza:

"Drogi kompilatorze , połącz odpowiedni kod z tą nazwą, wykonując to, co robisz najlepiej: sortowanie ".

Zasadniczo używasz metody wirtualnej, gdy chcesz, aby Dziedzice rozszerzyły funkcjonalność, jeśli chcą.

Używasz metod abstrakcyjnych, gdy chcesz, aby Dziedzice zaimplementowały tę funkcjonalność (i w tym przypadku nie mają wyboru)

Widziałem w niektórych miejscach metodę abstrakcyjną zdefiniowaną poniżej. **

"metoda abstrakcyjna musi być zaimplementowana w klasie child"

** Czułem, że tak jest .

Nie jest konieczne implementowanie metody abstrakcyjnej w klasie potomnej, jeśli Klasa potomna jest również abstrakcyjna ..

1) Metoda abstrakcyjna cant być metodą prywatną. 2) Metoda abstrakcyjna nie może być zaimplementowana w tym samym klasa abstrakcyjna.

Nie jest konieczne implementowanie metody wirtualnej w odziedziczonej klasie.

                                 ----------CODE--------------

public abstract class BaseClass
{
    public int MyProperty { get; set; }
    protected abstract void MyAbstractMethod();

    public virtual void MyVirtualMethod()
    {
        var x = 3 + 4;
    }

}
public abstract class myClassA : BaseClass
{
    public int MyProperty { get; set; }
    //not necessary to implement an abstract method if the child class is also abstract.

    protected override void MyAbstractMethod()
    {
        throw new NotImplementedException();
    }
}
public class myClassB : BaseClass
{
    public int MyProperty { get; set; }
    //You must have to implement the abstract method since this class is not an abstract class.

    protected override void MyAbstractMethod()
    {
        throw new NotImplementedException();
    }
}

Metoda Wirtualna :

• wirtualny oznacza, że możemy go obejść.

• Funkcja wirtualna ma implementację. Kiedy dziedziczymy klasę, może zastąpić funkcję wirtualną i zapewnić własną logikę.

• możemy zmienić typ zwracanej funkcji wirtualnej podczas implementacji
  funkcja w klasie dziecka(co można powiedzieć jako pojęcie
  Shadowing).

Abstrakt Metoda

• abstrakcja oznacza, że musimy ją nadpisać.

• Funkcja abstrakcyjna nie ma implementacji i musi być w klasie abstrakcyjnej.

• Może być tylko zadeklarowana. Zmusza to klasę pochodną do zapewnienia jej implementacji.

• Element abstrakcyjny jest w domyśle wirtualny. Abstrakt można nazwać jako czysty wirtualny w niektórych językach.

  public abstract class BaseClass
  { 
      protected abstract void xAbstractMethod();
  
      public virtual void xVirtualMethod()
      {
          var x = 3 + 4;
      }
  } 
  

Funkcja abstrakcyjna nie może mieć ciała i musi być nadpisana przez klasy potomne

Funkcja wirtualna będzie miała ciało i może być nadpisywana przez klasy potomne

Większość powyższych przykładów używa kodu - i są one bardzo dobre. Nie muszę dodawać do tego, co mówią, ale poniżej znajduje się proste wyjaśnienie, które wykorzystuje analogie, a nie kody / terminy techniczne.

Simple Explanation-Wyjaśnienie za pomocą analogii

Metoda Abstrakcyjna

Think George W Bush. Mówi do swoich żołnierzy: "Idź walczyć w Iraku". I to wszystko. Powiedział tylko, że trzeba walczyć. Nie określa Jak dokładnie tak się stanie. Ale nie można po prostu wyjść i "walczyć": co to dokładnie znaczy? walczę z B-52 czy moim derringerem? Te konkretne szczegóły pozostawiamy komuś innemu. Jest to metoda abstrakcyjna.

Metoda Wirtualna

1. Znajdź wroga
Zneutralizować go.
2. napij się później piwa

Problem polega na tym, że jest to bardzo ogólny metoda. To dobra metoda, która działa, ale czasami nie jest wystarczająco konkretna. Dobrą rzeczą dla Petraeusa jest to, że jego rozkazy mają swobodę i zakres - pozwolił innym zmienić jego definicję "walki", zgodnie z ich szczególnymi wymaganiami.

Private Job Bloggs czyta rozkaz Petraeusa i otrzymuje pozwolenie na wdrożenie własnej wersji walki, zgodnie z jego szczególnymi wymaganiami:

1. znaleźć wroga.
Strzel mu w głowę.
2. Idź Strona główna
Napij się piwa.

Nouri al Maliki również otrzymuje te same rozkazy od Petraeusa. On też ma walczyć. Ale on jest politykiem, a nie piechotą. Oczywiście nie może strzelać swoim politykom w głowę. Ponieważ Petraeus dał mu metodę wirtualną, Maliki może zaimplementować własną wersję metody walki, zgodnie z jego szczególnymi okolicznościami:

1. znaleźć wroga.
[21]} niech go aresztują z jakimś BS zmyślone zarzuty.
2. Idź Do Domu
Napij się piwa.

Innymi słowy, wirtualna metoda dostarcza instrukcji boilerplate-ale są to instrukcje ogólne, które mogą być bardziej szczegółowe przez ludzi z heirarchii wojskowej, w zależności od ich szczególnych okoliczności.

Różnica między tymi dwoma

• George Bush nie dowodzi żadnych szczegółów implementacji. To musi być dostarczone przez kogoś innego. To jest abstrakcja metoda.

• Petraeus z drugiej strony podaje szczegóły implementacji, ale zezwolił podwładnym na nadpisanie jego rozkazów ich własną wersją, jeśli uda im się wymyślić coś lepszego.

Mam nadzieję, że to pomoże.

Funkcja abstrakcyjna(metoda):

● metoda abstrakcyjna jest metodą zadeklarowaną za pomocą słowa kluczowego abstract.

● nie ma ciała.

● powinien być zaimplementowany przez klasę pochodną.

● jeśli metoda jest abstrakcyjna, to klasa powinna być abstrakcyjna.

Funkcja wirtualna (metoda):

● metoda wirtualna jest metodą zadeklarowaną za pomocą słowa kluczowego virtual i może być nadpisana przez pochodną metodę klasy za pomocą override słowo kluczowe.

● to od klasy pochodnej zależy, czy ją nadpisać, czy nie.

Odpowiedź została udzielona wiele razy, ale pytanie o to, kiedy użyć każdego z nich, jest decyzją w czasie projektowania. Postrzegałbym to jako dobrą praktykę, aby spróbować połączyć definicje wspólnych metod w różne interfejsy i wyciągnąć je do klas na odpowiednich poziomach abstrakcji. Dumping wspólnego zbioru abstrakcyjnych i wirtualnych definicji metod do klasy sprawia, że klasa jest unistanowalna, gdy najlepiej jest zdefiniować klasę nieabstraktową, która implementuje zestaw zwięzłych interfejsów. Jako zawsze zależy to od tego, co najlepiej pasuje do konkretnych potrzeb aplikacji.

Z ogólnego widoku obiektowego:

Jeśli chodzi o metodę abstrakcyjną: kiedy umieszczasz metodę abstrakcyjną w klasie rodzica, w rzeczywistości mówisz do klas potomnych: Hej zauważ, że masz taki podpis metody. A jeśli chcesz go użyć, powinieneś wdrożyć swój własny!

Jeśli chodzi o funkcję wirtualną: kiedy umieszczasz metodę wirtualną w klasie nadrzędnej, mówisz do klas pochodnych: Hej, jest tu funkcjonalność, która robi coś za Ciebie. Jeśli jest to przydatne dla ciebie po prostu go użyć. Jeśli nie, Nadpisz to i zaimplementuj swój kod, nawet ty możesz użyć mojej implementacji w swoim kodzie !

jest to pewna filozofia o odmienności między tymi dwoma pojęciami w ogólności oo

W C#nie ma nic wywołującego wirtualną klasę.

Dla funkcji

1. abstrakcyjna funkcja ma tylko podpis, Klasa napędu powinna zastąpić funkcjonalnością.
2. funkcja wirtualna przechowuje część funkcji, którą Klasa dysku może zastąpić, lub nie, zgodnie z wymogiem

Możesz zdecydować o swoich wymaganiach.

Metoda abstrakcyjna nie ma implementation.It jest zadeklarowana w klasie macierzystej. Klasa dziecięca jest odpowiedzialna za wdrożenie tej metody.

Wirtualna metoda powinna mieć implementację w klasie macierzystej i ułatwia klasie potomnej dokonanie wyboru, czy użyć tej implementacji klasy macierzystej, czy też mieć dla siebie nową implementację dla tej metody w klasie potomnej.

Funkcja abstrakcyjna jest "tylko" podpisem, bez implementacji. Jest on używany w interfejsie do deklarowania, w jaki sposób klasa może być użyta. Musi być zaimplementowany w jednej z klas pochodnych.

Wirtualna funkcja (w rzeczywistości metoda), jest funkcją, którą deklarujesz, i powinna zostać zaimplementowana w jednej z klas hierarchii dziedziczenia.

Dziedziczone instancje takiej klasy dziedziczą również implementację, chyba że zaimplementujesz ją, w niższej klasie hierarchii.

Dla mojego zrozumienia:

Metody Abstrakcyjne:

Tylko klasa abstrakcyjna może posiadać metody abstrakcyjne. Również klasa pochodna musi zaimplementować metodę i nie ma implementacji w klasie.

Metody Wirtualne:

Klasa może je zadeklarować, a także dostarczyć implementację tego samego. Również klasa pochodna musi zaimplementować metodę, aby ją nadpisać.