Überladen und Überschreiben in Java

Lassen Sie uns zunächst untersuchen, was der Name auf den ersten Blick vermuten lässt. „Überlastung“ bedeutet: die ursprüngliche Funktionalität einer Person zusätzlich zu belasten, oder? Mittlerweile bedeutet „Überschreiben“ die Bereitstellung neuer Funktionen zusätzlich zu den ursprünglichen Funktionen anderer.  In diesem Artikel werden wir uns ausführlich mit Überladen und Überschreiben in Java befassen. Ja, die programmgesteuerte Implementierung in Java folgt demselben Ansatz. Schauen wir sie uns einzeln an.

Überladung in Java

Wenn eine Java-Klasse mehrere Methoden mit demselben Namen, aber unterschiedlichen Argumenten hat, nennen wir das Methodenüberladung. Durch die Beibehaltung des Namens erhöhen wir lediglich die Lesbarkeit des Programmcodes. Angenommen, wir müssen eine Additionsoperation für bestimmte Zahlen durchführen. Nehmen wir an, der Name unserer Methode ist „addition()“.  Hier können zwei, drei oder mehr hinzugefügt werden. Abhängig davon, wie viele Zahlen an der zusätzlichen Operation beteiligt sind, können wir daher die Argumente (oder Parameter) der Funktion ändern. Wenn Sie jedoch stattdessen unterschiedliche Methoden für die unterschiedliche Anzahl von Argumenten schreiben würden, wäre es schwierig, sie zu erkennen, da der Name unterschiedlich wäre.  Daher erreichen wir durch Überladung eine bessere Lesbarkeit unseres Codes. Nun stellt sich die Frage: Wie erreichen wir eine Überlastung?

Starten Sie Ihren kostenlosen Softwareentwicklungskurs

Webentwicklung, Programmiersprachen, Softwaretests und andere

Sehen wir uns diese einzeln mit Beispielcodes an.

#1 – Durch Ändern der Anzahl der Parameter

Hier werden wir an einigen Zahlen zusätzliche Operationen durchführen. Erstellen wir dazu eine Klasse namens „AdditionOperation“. Innerhalb dieser Klasse haben wir zwei Methoden mit dem Namen „addition()“. Bei einer dieser Methoden addieren wir zwei Zahlen. Im anderen werden wir drei Zahlen hinzufügen. Dies erreichen wir, indem wir die Anzahl der Parameter in diesen Methoden ändern, aber wir behalten den gleichen Namen. Auf diese Weise überladen wir hier die Methode „addition()“.

Code:

public class AdditionOperation {
static int addition(int num1,int num2){return num1+num2;} //function declarationand definition for addition of two numbers
static int addition(int num1,int num2,int num3){return num1+num2+num3;} //function declarationand definition for addition of three numbers
public static void main(String args[]) {
system.out.printin(addition(35,36)); //method overloading
system.out.printin(addition(35,36,37)); //method overloading, we are calling same methods but for different number of arguments.
}
}

Ausgabe:

#2 – Durch Ändern des Datentyps

Hier führen wir eine Additionsoperation für verschiedene Typen durch, beispielsweise zwischen Integer- und Double-Typen. Erstellen wir dazu eine Klasse namens „AdditionOperation“. Lassen Sie uns innerhalb dieser Klasse zwei Methoden mit dem Namen „addition()“ haben. Bei einer dieser Methoden addieren wir zwei ganze Zahlen. Im anderen werden wir zwei Doubles hinzufügen. Dies erreichen wir, indem wir die Art der Parameter in diesen Methoden ändern, aber wir behalten den gleichen Namen. Auf diese Weise überladen wir hier die Methode „addition()“.

Code:

public class additionOperation {
static int addition(int num1,int num2){return num1+num2;} //function declarationand definition for addition of two numbers
static double addition(double num1,num2){return num1+num2;} //function declarationand definition for addition of three numbers
public static void main(String args[]) {
system.out.printin(addition(35,36)); //method overloading
system.out.printin(addition(35.5,36.6)); //method overloading, we are calling same methods but for different type of arguments.
}
}

Ausgabe:

Wichtige Punkte bei Überlastung

• Overloading in java is basically a “compile-time polym Method Overloading in C#orphism”. Compile-time polymorphism in java is also called “Static method Dispatch” or “Early binding”. So what do I mean by that jargon?
• As the name suggests, polymorphism is basically an ability to take many forms (poly: many, morph: form). The linking or binding of the overridden function and the object occurs at compile time. Compile-time polymorphism earns its name because function binding to an object occurs early, specifically during compile time, rather than at runtime. It is also called “Early binding” to emphasize this early binding process.
• Static dispatch is a type of polymorphism or method dispatch that tells how java will select which functionality of the method will be used in compile time. (I mean, whether it will add two or three numbers in our coding example).  The name is also known as the Static method Dispatch.

Overriding in Java

• When a java subclass or child class has a method that is of the same name and contains the same parameters or arguments and a similar return type as a method that is present in its superclass or parent class, then we can call the method of the child class as an overridden method of the method of its parent class.
• For example, suppose we need to perform some display operation according to its class type. If I call the method of a parent class, it will display a message defined in a parent class. But, calling the child class method will override the display message of its parent class and display the message defined within the child class method. Hence depending on which display we need to show, we can call the related class (parent or child). We are not changing the method name, argument, and return type here. We are just changing the functionality of the method in the child class. But, instead of this, if we do not do overriding, i. e. we don’t give the specific implementation of the child method, then while calling the method, it will display the same message as present in a parent class.
• When writing code, use the @Override annotation before overriding a method. This annotation informs the compiler that the method must override a declaration in a superclass. Although using this is not mandatory, it helps prevent errors. If a method annotated with @Override fails to override a method, the compiler generates an error.

Rules for Java Method Overriding

1. The method must have the same name as in the parent class
2. The method must have the same parameter as in the parent class.
3. There must be an IS-A relationship (inheritance).

Code:

//Parent or Super class
class Parent {
public void display() {
system.out.printin("Hello, I am from parent class");
}
}
//Child or sub class
class Sub extends Parent {
//Below method overrides the Parent display() method
// @override
public void display() {
system.out.printin("Hello, I am from child class");
}
}
//Driver class
public class Overriding {
public static void main?(String args[])
{
Parent superObject = new Parent ();
superObject.display(); // Super class method is called
Parent subObject = new Sub();
subObject.display(); //Child class method is called by a parent type reference: this is functionality of method overriding
Sub subObject2 = new Sub(); //Child class method is called by a child type reference
subObject2.display();
}
}

Output:

Limitations in method Overriding:

1. The child class cannot override the private methods of the parent class.
2. You cannot override final methods.
3. One cannot override static methods.

Points to be Noted for Overriding

• Overriding in Java represents “run-time polymorphism,” also known as “dynamic method dispatch” or “late binding.” These terms refer to the ability of the Java runtime system to determine the appropriate method implementation to execute based on the actual type of the object at runtime.
• As the name suggests, polymorphism is basically an ability to take many forms (poly: many, morph: form). So, a call to an overridden function with the object is done during the run time. Hence called run time polymorphism.
• Late binding, or “dynamic binding,” occurs after compilation during runtime, as it binds functions to objects.
• Dynamic dispatch is a type of polymorphism or method dispatch that tells how java will select which method functionality will be used in run time. The name is also known as Dynamic method Dispatch.

Conclusion

This concludes our learning of the topic “Overloading and Overriding in Java”. Write the codes mentioned above in the java compiler and check the output. Learning codes will be incomplete if you do not do hands-on by yourself, enhancing your coding skills.  Happy coding!!

Das obige ist der detaillierte Inhalt vonÜberladen und Überschreiben in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!