Überladen und Überschreiben

Was ist der Unterschied zwischen Überladen und Überschreiben?

Überlastung

Überladen ist, wenn Sie mehrere Methoden im selben Bereich mit demselben Namen, aber unterschiedlichen Signaturen haben.

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

Überschreiben

Das Überschreiben ist ein Prinzip, mit dem Sie die Funktionalität einer Methode in einer untergeordneten Klasse ändern können.

//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
        }
}

Einfache Definitionen zum Überladen und Überschreiben

Überladen (Compile Time Polymorphism) :: Funktionen mit gleichem Namen und unterschiedlichen Parametern

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");
    }
}

Überschreiben (Laufzeitpolymorphismus) :: Funktionen in der erweiterten Klasse mit demselben Namen und denselben Parametern wie in der Basisklasse, jedoch mit unterschiedlichem Verhalten.

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");
    }
}

Ich möchte ein Beispiel nennen, das mir beim Lernen sehr viel Sinn gemacht hat:

Dies ist nur ein Beispiel, das weder die virtuelle Methode noch die Basisklasse enthält. Nur um einen Hinweis auf die Hauptidee zu geben.

Angenommen, es gibt eine Fahrzeugwaschmaschine mit einer Funktion namens "Waschen", die das Auto als Typ akzeptiert.

Ruft die Autoeingabe ab und wäscht das Auto.

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

Überladen wir die Wash () -Funktion

Überlastung:

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

Die Waschfunktion war vorher nur das Waschen eines Autos, aber jetzt ist es überladen, um auch einen LKW zu waschen.

• Wenn das bereitgestellte Eingabeobjekt ein Auto ist, wird Wash (Car anyCar) ausgeführt.
• Wenn das bereitgestellte Eingabeobjekt ein LKW ist, führt es Wash (Truck anyTruck) aus.

Lassen Sie uns die Wash () - Funktion überschreiben

Überschreiben:

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
   }     
}

Die Waschfunktion muss jetzt prüfen, ob das Auto bereits sauber ist und nicht erneut gewaschen werden muss.

• Wenn das Auto sauber ist, wachsen Sie es einfach.

• Wenn nicht sauber, waschen Sie das Auto zuerst, trocknen Sie es und wachsen Sie es dann

.

Die Funktionalität wurde also überschrieben, indem eine neue Funktionalität hinzugefügt oder etwas völlig anderes getan wurde.

• Überladen = Mehrere Methodensignaturen, gleicher Methodenname
• Überschreiben = Gleiche Methodensignatur (als virtuell deklariert), implementiert in Unterklassen

Ein kluger Interviewer hätte folgendes getan:

Was ist der Unterschied zwischen Überschreiben und Abschatten?

Wie Michael sagte:

• Überladen = Mehrere Methodensignaturen, gleicher Methodenname
• Überschreiben = Gleiche Methodensignatur (als virtuell deklariert), implementiert in Unterklassen

und

• Shadowing = Wenn als DerivedClass behandelt, wird die abgeleitete Methode verwendet, wenn als BaseClass die Basismethode verwendet wird.

Das Vorhandensein von mehr als einer Methode / eines Konstruktors mit demselben Namen, aber unterschiedlichen Parametern wird als Überladung bezeichnet. Dies ist ein Ereignis zur Kompilierungszeit.

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

Das Überschreiben ist ein Laufzeitereignis. Das bedeutet, dass sich die Ausgabe basierend auf Ihrem Code zur Laufzeit ändert.

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);
    }
}

Beachten Sie, dass es in beiden Klassen topSpeed ​​() eine gemeinsame Methode gibt. Da wir einen Ferrari instanziiert haben, erhalten wir ein anderes Ergebnis.

O / p:

Top speed for this car is: 400

In C # gibt es keine Java-ähnliche versteckte Überschreibung ohne Keyword- Überschreibung bei der Überschreibungsmethode! Siehe diese C # -Implementierungen:

Variante 1 ohne Override : Ergebnis ist 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();
    }

Variante 2 mit Schlüsselwort override : Ergebnis ist 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();
    }

Das Schlüsselwort virtual in der Car-Klasse ist für final in Java entgegengesetzt, bedeutet nicht final , Sie können es überschreiben oder implementieren, wenn Car abstrakt war

Shadowing = verwaltet zwei Definitionen in der abgeleiteten Klasse. Um die Basisklassendefinition zu projizieren, werden abgeleitete Klassendefinitionen schattiert (ausgeblendet) und umgekehrt.

Ein weiterer Punkt hinzuzufügen.

Überlastung mehr als einer Methode mit demselben Namen. Gleicher oder unterschiedlicher Rückgabetyp. Unterschiedliche Anzahl von Parametern oder unterschiedliche Art von Parametern. In derselben Klasse oder abgeleiteten Klasse.

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)

Kann in derselben Klasse oder abgeleiteten Klasse möglich sein. Im Allgemeinen bevorzugt in der gleichen Klasse. Zum Beispiel hat Console.WriteLine () 19 überladene Methoden.

Kann Klassenkonstruktoren und Methoden überladen.

Kann als Kompilierungszeitpolymorphismus (statische / frühe Bindung) betrachtet werden.

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

Überschreiben kann nicht in derselben Klasse möglich sein. Kann Klassenmethoden, Eigenschaften, Indexer, Ereignisse überschreiben.

Hat einige Einschränkungen wie Die überschriebene Basismethode muss virtuell, abstrakt oder überschrieben sein. Sie können die neuen, statischen oder virtuellen Modifikatoren nicht zum Ändern einer Überschreibungsmethode verwenden.

Kann als Laufzeitpolymorphismus (dynamische / späte Bindung) betrachtet werden.

Hilft bei der Versionierung von http://msdn.microsoft.com/en-us/library/6fawty39.aspx

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

Hilfreiche Links

http://msdn.microsoft.com/en-us/library/ms173152.aspx Kompilierzeitpolymorphismus vs. Laufzeitpolymorphismus

Überladung ist Teil des statischen Polymorphismus und wird verwendet, um verschiedene Methoden mit demselben Namen, aber unterschiedlichen Signaturen zu implementieren. Das Überschreiben wird verwendet, um die unvollständige Methode abzuschließen. Meiner Meinung nach gibt es keinen Vergleich zwischen diesen beiden Konzepten. Das einzige, was ähnlich ist, ist, dass beide mit demselben Vokabular kommen, das vorbei ist.

Methodenüberladung und Methodenüberschreibung sind zwei völlig unterschiedliche Konzepte. Das Überladen von Methoden hat denselben Methodennamen, jedoch unterschiedliche Signaturen. Durch das Überschreiben von Methoden wird die Standardimplementierung der Basisklassenmethode in der abgeleiteten Klasse geändert. Im Folgenden finden Sie 2 hervorragende Video-Tutorials, in denen diese Konzepte erläutert werden.

Methode überschreibt Vs versteckt

Methodenüberladung

Überladen ist das Konzept, bei dem Sie dieselben Signaturen oder Methoden mit demselben Namen, aber unterschiedlichen Parametern und Überschreibungen haben. Wir haben dieselben Namensmethoden mit unterschiedlichen Parametern, deren Vererbung auch als Überschreiben bezeichnet wird.