Przeciążanie i zastępowanie

Jaka jest różnica między przeciążaniem a zastępowaniem.

Przeciążenie

Przeciążanie ma miejsce, gdy masz wiele metod w tym samym zakresie, z tą samą nazwą, ale różnymi podpisami.

//Overloading
public class test
{
    public void getStuff(int id)
    {}
    public void getStuff(string name)
    {}
}

Nadrzędny

Przesłanianie to zasada, która umożliwia zmianę funkcjonalności metody w klasie podrzędnej.

//Overriding
public class test
{
        public virtual void getStuff(int id)
        {
            //Get stuff default location
        }
}

public class test2 : test
{
        public override void getStuff(int id)
        {
            //base.getStuff(id);
            //or - Get stuff new location
        }
}

Proste definicje przeciążania i zastępowania

Przeciążanie (polimorfizm czasu kompilacji) :: Funkcje o tej samej nazwie i różnych parametrach

public class A
{
    public void print(int x, int y)
    {
        Console.WriteLine("Parent Method");
    }
}

public class B : A
{
    public void child()
    {
        Console.WriteLine("Child Method");
    }

    public void print(float x, float y)
    {
        Console.WriteLine("Overload child method");
    }
}

Przesłanianie (polimorfizm czasu wykonywania) :: Funkcje w klasie rozszerzonej o takiej samej nazwie i takich samych parametrach jak w klasie bazowej, ale z różnymi zachowaniami.

public class A
{
    public virtual void print()
    {
        Console.WriteLine("Parent Method");
    }
}

public class B : A
{
    public void child()
    {
        Console.WriteLine("Child Method");
    }

    public override void print()
    {
        Console.WriteLine("Overriding child method");
    }
}

Chcę podzielić się przykładem, który miał dla mnie dużo sensu, kiedy się uczyłem:

To tylko przykład, który nie obejmuje metody wirtualnej ani klasy bazowej. Żeby dać wskazówkę dotyczącą głównego pomysłu.

Załóżmy, że istnieje myjnia samochodowa, która ma funkcję „Myj” i akceptuje jako typ Samochód.

Pobiera dane wejściowe samochodu i myje samochód.

public void Wash(Car anyCar){
       //wash the car
}

Przeładujmy funkcję Wash ()

Przeciążenie:

public void Wash(Truck anyTruck){
   //wash the Truck  
}

Funkcja mycia wcześniej tylko myła samochód, ale teraz jest przeciążona, aby umyć również ciężarówkę.

• Jeśli podany obiekt wejściowy to Car, wykona Wash (Car anyCar)
• Jeśli podany obiekt wejściowy to Ciężarówka, wykona Mycie (Ciężarówka anyTruck)

Zastąpmy funkcję Wash ()

Nadrzędny:

public override void Wash(Car anyCar){
   //check if the car has already cleaned
   if(anyCar.Clean){ 
       //wax the car
   }
   else{
       //wash the car
       //dry the car
       //wax the car
   }     
}

Funkcja mycia ma teraz warunek, aby sprawdzić, czy samochód jest już czysty i nie trzeba go ponownie myć.

• Jeśli samochód jest czysty, po prostu go woskuj.

• Jeśli nie jest czysty, najpierw umyj samochód, następnie wysusz go, a następnie woskuj

.

Więc funkcjonalność została zastąpiona przez dodanie nowej funkcjonalności lub zrobienie czegoś zupełnie innego.

• Przeciążenie = wiele podpisów metod, ta sama nazwa metody
• Przesłanianie = ta sama sygnatura metody (deklarowana wirtualna), zaimplementowana w podklasach

Wnikliwy ankieter odpowiedziałby:

Jaka jest różnica między overriding a shadowing?

Jak powiedział Michael:

• Przeciążenie = wiele podpisów metod, ta sama nazwa metody
• Przesłanianie = ta sama sygnatura metody (deklarowana wirtualna), zaimplementowana w podklasach

i

• Shadowing = Jeśli traktowane jako DerivedClass używa metody pochodnej, jeśli jako BaseClass używa metody bazowej.

Posiadanie więcej niż jednej metody / konstruktora o tej samej nazwie, ale różnych parametrach nazywa się przeciążaniem. To jest zdarzenie czasu kompilacji.

Class Addition 
{
   int add(int a, int b) 
   {
     return a+b;
   }
   int add(int a, int b, int c)
   {
     return a+b+c;
   }

   public static main (String[] args) 
   {
     Addition addNum = new Addition();
     System.out.println(addNum.add(1,2));
     System.out.println(addNum.add(1,2,3));
   }
}

O / p:

3
6

Zastępowanie jest zdarzeniem w czasie wykonywania, co oznacza, że ​​na podstawie kodu dane wyjściowe zmieniają się w czasie wykonywania.

class Car
{
    public int topSpeed() 
    {
        return 200;
    }
}
class Ferrari extends Car
{
    public int topSpeed()
    {
        return 400;
    }
    public static void main(String args[])
    {
        Car car = new Ferrari();
        int num= car.topSpeed();
        System.out.println("Top speed for this car is: "+num);
    }
}

Zauważ, że w obu klasach istnieje wspólna metoda topSpeed ​​(). Ponieważ utworzyliśmy instancję Ferrari, otrzymujemy inny wynik.

O / p:

Top speed for this car is: 400

w C # nie ma Java jak ukryte przesłonięcie, bez przesłaniania słowa kluczowego w metodzie przesłaniania! zobacz te implementacje C #:

wariant 1 bez nadpisania : wynik to 200

    class Car {
        public int topSpeed() {
            return 200;
        }
    }

    class Ferrari : Car {
        public int topSpeed(){
                return 400;
        }
    }

    static void Main(string[] args){
        Car car = new Ferrari();
        int num= car.topSpeed();
        Console.WriteLine("Top speed for this car is: "+num);
        Console.ReadLine();
    }

wariant 2 ze słowem kluczowym override : wynik to 400

    class Car {
        public virtual int topSpeed() {
            return 200;
        }
    }

    class Ferrari : Car {
        public override int topSpeed(){
                return 400;
        }
    }

    static void Main(string[] args){
        Car car = new Ferrari();
        int num= car.topSpeed();
        Console.WriteLine("Top speed for this car is: "+num);
        Console.ReadLine();
    }

słowo kluczowe wirtualne w klasie Car jest przeciwne dla finału w Javie, oznacza nie ostateczne , możesz nadpisać lub zaimplementować, jeśli Car był abstrakcyjny

shadowing = zachowuje dwie definicje w klasie pochodnej iw celu zaprojektowania definicji klasy bazowej przesłania (ukrywa) definicję klasy pochodnej i odwrotnie.

Kolejna kwestia do dodania.

Przeciążanie więcej niż jednej metody o tej samej nazwie. Ten sam lub inny typ zwrotu. Różne liczby parametrów lub inny typ parametrów. W tej samej klasie lub klasie pochodnej.

int Add (int num1, int num2) int Add (int num1, int num2, int num3) double Add (int num1, int num2) double Add (double num1, double num2)

Może być możliwe w tej samej klasie lub klasie pochodnej. Generalnie woli w tej samej klasie. Np. Console.WriteLine () ma 19 przeciążonych metod.

Potrafi przeciążać konstruktory klas, metody.

Można uznać za polimorfizm czasu kompilacji (statyczny / wczesne wiązanie).

==================================================== ==================================================== =

Zastępowanie nie może być możliwe w tej samej klasie. Może przesłonić metody klas, właściwości, indeksatory, zdarzenia.

Ma pewne ograniczenia, takie jak Przesłonięta metoda podstawowa musi być wirtualna, abstrakcyjna lub nadpisana. Nie można używać nowych, statycznych ani wirtualnych modyfikatorów do modyfikowania metody zastępowania.

Można rozważyć jako polimorfizm w czasie wykonywania (dynamiczny / późne wiązanie).

Pomaga w wersjonowaniu http://msdn.microsoft.com/en-us/library/6fawty39.aspx

==================================================== ==================================================== =

Przydatne linki

http://msdn.microsoft.com/en-us/library/ms173152.aspx Polimorfizm czasu kompilacji a polimorfizm czasu wykonywania

Przeciążanie jest częścią statycznego polimorfizmu i służy do implementacji innej metody o tej samej nazwie, ale różnych sygnaturach. Przesłanianie służy do zakończenia niepełnej metody. Moim zdaniem nie ma porównania między tymi dwoma pojęciami, jedyne, co jest podobne, to to, że oba mają to samo słownictwo, które się skończyło.

Przeciążanie metod i Nadpisywanie metod to dwie różne koncepcje. Przeciążanie metod ma tę samą nazwę metody, ale różne podpisy. Zastępowanie metody polega na zmianie domyślnej implementacji metody klasy bazowej w klasie pochodnej. Poniżej znajdziesz 2 doskonałe samouczki wideo wyjaśniające te pojęcia.

Metoda przesłaniająca ukrywanie Vs

Przeciążanie metod

Przeciążanie to koncepcja, w której masz te same sygnatury lub metody o tej samej nazwie, ale z różnymi parametrami i nadpisywaniem, mamy metody o tej samej nazwie z różnymi parametrami, które również mają dziedziczenie, czyli nadpisywanie.