Inleiding tot overbelasting en opheffing in Java
Laten we eerst eens kijken wat de naam op het eerste gezicht suggereert. "Overbelasting" betekent: wat extra belasting op iemands oorspronkelijke functionaliteit, toch? Terwijl "opheffen" betekent: nieuwe functionaliteit bieden naast de oorspronkelijke functionaliteit van iemand. In dit artikel zullen we de overbelasting en opheffing in Java in detail bekijken. Ja, ook in Java worden deze programmatisch op dezelfde manier geïmplementeerd. Laten we daar een voor een naar kijken.
Overbelasting in Java
Wanneer een Java-klasse meerdere methoden heeft met dezelfde naam maar met verschillende argumenten, noemen we dit Method Overloading. Door de naam hetzelfde te houden, vergroten we alleen de leesbaarheid van programmacode. Stel bijvoorbeeld dat we een optelbewerking op sommige gegeven nummers moeten uitvoeren. Laten we zeggen dat de naam van onze methode "additie ()" is. Hier kan optelling worden gedaan tussen twee nummers, drie nummers of meer. Daarom kunnen we, afhankelijk van het aantal getallen dat naast de bewerking wordt gebruikt, de argumenten (of parameters) van de functie wijzigen. Maar in plaats daarvan, als u verschillende methoden voor het verschillende aantal argumenten zou schrijven, zal het moeilijk te herkennen zijn omdat de naam anders zou zijn. Daarom bereiken we door overbelasting onze leesbaarheid van onze code. Dus nu is de vraag hoe zullen we overbelasting bereiken?
Laten we die een voor een bekijken met voorbeeldcodes.
Methode # 1 - Door het aantal parameters te wijzigen
Dus hier zullen we op sommige nummers een extra bewerking uitvoeren. Laten we hiervoor een klasse maken met de naam "AdditionOperation". Laten we binnen die klasse twee methoden genaamd 'addition ()' hebben. In een van die methoden voeren we een toevoeging van twee getallen uit. In de andere zullen we de toevoeging van drie nummers uitvoeren. Dit zullen we bereiken door eenvoudig het aantal parameters in die methoden te veranderen, maar we zullen de naam hetzelfde houden. Op deze manier overbelasten we de methode "additie ()" hier.
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.
)
)
Output:
Methode # 2 - Door het gegevenstype te wijzigen
Dus hier zullen we optelling op verschillende typen uitvoeren, bijvoorbeeld tussen het type geheel getal en tussen het dubbele type. Laten we hiervoor een klasse maken met de naam "AdditionOperation". Laten we binnen die klasse twee methoden genaamd 'addition ()' hebben. In een van die methoden zullen we de toevoeging van twee gehele getallen uitvoeren. In de andere zullen we de toevoeging van twee dubbele uitvoeren. Dit zullen we bereiken door eenvoudig het type parameters in die methoden te veranderen, maar we zullen de naam hetzelfde houden. Op deze manier overbelasten we de methode "additie ()" hier.
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.
)
)
Output:
Aandachtspunten voor overbelasting
- Overbelasting in Java is eigenlijk een "compile-time polymMethod Overloading in C # orphism". Compile-time polymorfisme in Java wordt ook wel "Statische methode verzending" of "Vroege binding" genoemd. Dus wat bedoel ik met dat jargon?
- Polymorfisme is, zoals de naam al doet vermoeden, in feite een vermogen om vele vormen aan te nemen (poly: veel, morph: vorm). Dus, hier wordt het koppelen of binden van de overbelaste functie en het object gedaan, compileer tijd. Daarom wordt het compile-time polymorfisme genoemd.
- In principe wordt de binding van de functie aan het object gedaan vóór de uitvoeringstijd (dat wil zeggen tijdens de compilatie), daarom wordt het ook "Vroege binding" genoemd.
- Statische verzending is een type polymorfisme of methode verzending die vertelt hoe Java zal selecteren welke functionaliteit van de methode zal worden gebruikt tijdens het compileren. (Ik bedoel, of het in ons codevoorbeeld twee getallen of drie getallen toevoegt). Dus de naam is ook bekend als de statische methode Dispatch.
Overschrijven in Java
- Wanneer een Java-subklasse of onderliggende klasse een methode heeft die dezelfde naam heeft en dezelfde parameters of argumenten en hetzelfde retourtype bevat als een methode die aanwezig is in de superklasse of de bovenliggende klasse, kunnen we de methode van de onderliggende klasse noemen als een overschreven methode van de methode van de bovenliggende klasse.
- Stel bijvoorbeeld dat we een weergavebewerking moeten uitvoeren op basis van het klasse-type. Ik bedoel, als ik de methode van een bovenliggende klasse aanroep, wordt er een bericht weergegeven dat is gedefinieerd in een bovenliggende klasse. Wanneer we echter de methode van de onderliggende klasse aanroepen, wordt het weergavebericht van de bovenliggende klasse overschreven en wordt het weergavebericht weergegeven dat is gedefinieerd in de methode van de onderliggende klasse. Daarom kunnen we, afhankelijk van welk display we moeten tonen, de gerelateerde klasse (ouder of kind) aanroepen. Hier veranderen we de methode naam, het argument en het retour type niet. We veranderen alleen de functionaliteit van de methode in de kinderklasse. Maar in plaats van dit, als we niet opheffen, dat wil zeggen dat we niet de specifieke implementatie van child-methode geven, zal het, terwijl we de methode aanroepen, hetzelfde bericht weergeven als aanwezig in een bovenliggende klasse.
- Tijdens het schrijven van code gebruiken we @ Negeer annotatie voordat de methode wordt genegeerd. @Override annotatie vertelt de compiler dat de methode een methode moet overschrijven die in een superklasse is gedeclareerd. Hoewel het niet verplicht is om dit te gebruiken, helpt het om fouten te voorkomen. Als een methode die is geannoteerd met @Override een methode niet kan overschrijven, genereert de compiler een fout.
Regels voor het overschrijven van de Java-methode
- De methode moet dezelfde naam hebben als in de bovenliggende klasse
- De methode moet dezelfde parameter hebben als in de bovenliggende klasse.
- Er moet een IS-A-relatie zijn (overerving).
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:
Beperkingen in de methode Negeren:
- Privémethoden van de bovenliggende klasse kunnen niet worden opgeheven.
- Definitieve methoden kunnen niet worden opgeheven
- Statische methoden kunnen niet worden opgeheven
Aandachtspunten voor het negeren
- Overbelasting in Java is eigenlijk een "Run time polymorphism". Runtime polymorfisme in Java wordt ook wel "dynamische methode verzending" of "late binding" genoemd. Dus wat wordt bedoeld met dat jargon?
- Polymorfisme is, zoals de naam al doet vermoeden, in feite een vermogen om vele vormen aan te nemen (poly: veel, morph: vorm). Dus hier wordt de aanroep van een overbelaste functie met het object gedaan. Daarom runtime polymorfisme genoemd.
- In principe wordt de binding van functie aan object laat gedaan, wat na compilatie is (dwz tijdens runtime); vandaar wordt het ook wel "Late binding" genoemd.
- Dynamische verzending is een type polymorfisme of methode verzending die vertelt hoe Java zal selecteren welke functionaliteit van de methode in runtime zal worden gebruikt. Dus de naam is ook bekend als dynamische methode verzending.
Conclusie
Hiermee is onze kennis van het onderwerp "Overbelasting en opheffen in Java" afgesloten. Schrijf de codes die in de bovenstaande voorbeelden worden genoemd in de Java-compiler en controleer de uitvoer. Het leren van codes zal onvolledig zijn als je het niet zelf doet, omdat dit je codeervaardigheden zal verbeteren. Veel plezier met coderen !!
Aanbevolen artikelen
Dit is een gids voor overbelasting en opheffing in Java. Hier bespreken we methoden in Overbelasting samen met regels en beperkingen van Overriding in Java. U kunt ook onze andere voorgestelde artikelen doornemen voor meer informatie -
- Overschrijven in JavaScript
- Overschrijven in OOP's
- Wat zijn generieken op Java?
- Overschrijven in PHP
- Python overbelast
- Overerving in PHP
- Volledige gids voor erfenis in Python
- Overbelasting en opheffen in C #
- Typen en verwerkingsfouten in JavaScript
- Voorbeelden en hoe generieken werken in C #
- Functie en regels voor het negeren in Python