Introduction à la surcharge et à la surcharge en Java
Voyons d'abord ce que le nom suggère à première vue. "Surcharge" signifie: mettre un fardeau supplémentaire sur les fonctionnalités originales de quiconque, non? Tandis que, «remplacer» signifie: fournir de nouvelles fonctionnalités en plus des fonctionnalités originales de n'importe qui. Dans cet article, nous examinerons en détail la surcharge et la substitution en Java. Oui, en Java également, ceux-ci sont implémentés de la même manière par programme. Examinons cela un par un.
Surcharge en Java
Lorsqu'une classe java a plusieurs méthodes avec le même nom mais avec des arguments différents, nous l'appelons surcharge de méthode. En gardant le même nom, nous augmentons simplement la lisibilité du code du programme. Par exemple, supposons que nous devons effectuer une opération d'addition sur certains nombres donnés. Disons que le nom de notre méthode est «addition ()». Ici, l'addition peut être effectuée entre deux nombres, trois nombres ou plus. Par conséquent, en fonction du nombre de nombres qui impliqueront une opération supplémentaire, nous pouvons changer les arguments (ou paramètres) de la fonction. Mais, au lieu de cela, si vous écriviez des méthodes différentes pour le nombre différent d'arguments, il sera difficile de le reconnaître car le nom serait différent. Par conséquent, en surchargeant, nous obtenons une meilleure lisibilité de notre code. Alors maintenant, la question est de savoir comment allons-nous atteindre la surcharge?
Regardons ceux-ci un par un avec des exemples de codes.
Méthode n ° 1 - En modifiant le nombre de paramètres
Donc ici, nous allons faire des opérations d'addition sur certains numéros. Pour cela, créons une classe appelée «AdditionOperation». A l'intérieur de cette classe, nous allons avoir deux méthodes nommées «addition ()». Dans l'une de ces méthodes, nous effectuerons l'ajout de deux nombres. Dans l'autre, nous effectuerons l'ajout de trois nombres. Nous y parviendrons en changeant simplement le nombre de paramètres dans ces méthodes, mais nous conserverons le même nom. De cette façon, nous surchargeons ici la méthode «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.
)
)
Production:
Méthode n ° 2 - en modifiant le type de données
Donc ici, nous allons faire des opérations d'addition sur différents types, par exemple entre type entier et entre type double. Pour cela, créons une classe appelée «AdditionOperation». A l'intérieur de cette classe, laissez-nous avoir deux méthodes nommées "addition ()". Dans l'une de ces méthodes, nous effectuerons l'ajout de deux entiers. Dans l'autre, nous effectuerons l'ajout de deux doubles. Nous y parviendrons en changeant simplement le type de paramètres dans ces méthodes, mais nous garderons le même nom. De cette façon, nous surchargeons ici la méthode «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.
)
)
Production:
Points à noter en cas de surcharge
- La surcharge en java est fondamentalement une «surcharge polymMethod au moment de la compilation en orphisme C #». Le polymorphisme au moment de la compilation en Java est également appelé «Envoi de méthode statique» ou «Liaison précoce». Alors qu'est-ce que je veux dire par ce jargon?
- Le polymorphisme, comme son nom l'indique, est essentiellement une capacité à prendre de nombreuses formes (poly: beaucoup, morph: forme). Donc, ici la liaison ou la liaison de la fonction surchargée et l'objet se fait au moment de la compilation. Par conséquent, il est appelé polymorphisme au moment de la compilation.
- Fondamentalement, ici, la liaison de la fonction à l'objet se fait tôt avant l'exécution (c'est-à-dire pendant la compilation), d'où le nom de «liaison précoce».
- La répartition statique est un type de polymorphisme ou de répartition de méthode qui indique comment java sélectionnera quelle fonctionnalité de la méthode sera utilisée lors de la compilation. (Je veux dire, s'il effectuera l'addition de deux ou trois nombres dans notre exemple de codage). Le nom est donc également connu sous le nom de méthode statique Dispatch.
Surcharge en Java
- Lorsqu'une sous-classe java ou une classe enfant a une méthode qui est du même nom et contient les mêmes paramètres ou arguments et un type de retour similaire qu'une méthode qui est présente dans sa superclasse ou classe parent, alors nous pouvons appeler la méthode de la classe enfant comme une méthode redéfinie de la méthode de sa classe parente.
- Par exemple, supposons que nous devons effectuer une opération d'affichage en fonction de son type de classe. Je veux dire, si j'appelle la méthode d'une classe parente, elle affichera un message qui est défini dans une classe parente. Mais, lorsque nous appelons la méthode de la classe enfant, elle remplacera le message d'affichage de sa classe parent et affichera le message d'affichage qui est défini à l'intérieur de la méthode de la classe enfant. Par conséquent, selon l'affichage que nous devons afficher, nous pouvons appeler la classe associée (parent ou enfant). Ici, nous ne changeons pas le nom de la méthode, l'argument et le type de retour. Nous modifions simplement la fonctionnalité de la méthode dans la classe enfant. Mais, au lieu de cela, si nous ne faisons pas de surcharge c'est-à-dire que nous ne donnons pas l'implémentation spécifique de la méthode enfant, alors lors de l'appel de la méthode, elle affichera le même message que celui présent dans une classe parent.
- Lors de l'écriture de code, nous utiliserons l'annotation @ Override avant la méthode à remplacer. L'annotation @Override indique au compilateur que la méthode est censée remplacer une méthode déclarée dans une superclasse. Bien qu'il ne soit pas obligatoire de l'utiliser, cela permet d'éviter les erreurs. Si une méthode annotée avec @Override ne parvient pas à remplacer une méthode, le compilateur génère une erreur.
Règles de substitution de méthode Java
- La méthode doit avoir le même nom que dans la classe parente
- La méthode doit avoir le même paramètre que dans la classe parente.
- Il doit y avoir une relation IS-A (héritage).
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();
)
)
Production:
Limitations de la méthode Remplacement:
- Les méthodes privées de la classe parente ne peuvent pas être remplacées.
- Les méthodes finales ne peuvent pas être remplacées
- Les méthodes statiques ne peuvent pas être remplacées
Points à noter pour la neutralisation
- La surcharge en java est fondamentalement un «polymorphisme d'exécution». Le polymorphisme d'exécution en Java est également appelé «Dynamic method Dispatch» ou «Late binding». Que signifie donc ce jargon?
- Le polymorphisme, comme son nom l'indique, est essentiellement une capacité à prendre de nombreuses formes (poly: beaucoup, morph: forme). Donc, ici l'appel à une fonction surchargée avec l'objet se fait au moment de l'exécution. D'où le polymorphisme d'exécution.
- Fondamentalement, ici, la liaison de la fonction à l'objet est effectuée tardivement, c'est-à-dire après la compilation (c'est-à-dire pendant l'exécution); par conséquent, il est également appelé «liaison tardive».
- La répartition dynamique est un type de polymorphisme ou de répartition de méthode qui indique comment java sélectionnera les fonctionnalités de la méthode à utiliser lors de l'exécution. Le nom est donc également connu sous le nom de Dynamic method Dispatch.
Conclusion
Ceci conclut notre apprentissage du sujet «Surcharge et surcharge en Java». Écrivez les codes mentionnés dans les exemples ci-dessus dans le compilateur java et vérifiez la sortie. L'apprentissage des codes sera incomplet si vous ne pratiquez pas vous-même, car cela améliorera vos compétences en codage. Bon codage !!
Articles recommandés
Ceci est un guide sur la surcharge et la surcharge en Java. Nous discutons ici des méthodes de surcharge ainsi que des règles et limites de la surcharge en Java. Vous pouvez également consulter nos autres articles suggérés pour en savoir plus -
- Remplacement en JavaScript
- Remplacement dans les POO
- Que sont les génériques en Java?
- Surcharger en PHP
- Surcharge Python
- Héritage en PHP
- Guide complet de l'héritage en Python
- Surcharge et remplacement en C #
- Types et gestion des erreurs en JavaScript
- Exemples et fonctionnement des génériques en C #
- Fonction et règles de remplacement en Python