Introduktion till överbelastning och överskridande i Java
Låt oss först titta på vad namnet antyder vid sin första anblick. ”Överbelastning” betyder: lägga någon extra börda på någons ursprungliga funktionalitet, eller hur? Medan ”Överridande” betyder: att tillhandahålla ny funktionalitet utöver någons ursprungliga funktionalitet. I den här artikeln kommer vi att titta på överbelastning och överskridande i Java i detalj. Ja, även i Java implementeras dessa på samma sätt programmatiskt. Låt oss ta en titt på det en efter en.
Överbelastning i Java
När en java klass har flera metoder med samma namn men med olika argument, kallar vi det Method Overloading. Genom att hålla namnet på samma sätt ökar vi bara programkodens läsbarhet. Anta till exempel att vi måste utföra någon tilläggsoperation på vissa givna nummer. Låt oss säga att namnet på vår metod är "tillägg ()". Här kan tillägg göras mellan två siffror, tre siffror eller mer. Beroende på hur många nummer som kommer att involvera i tilläggsoperationen kan vi därför ändra funktionens argument (eller parametrar). Men istället för detta, om du skulle skriva olika metoder för olika antal argument, kommer det att vara svårt att känna igen eftersom namnet skulle vara annorlunda. Genom överbelastning uppnår vi därför bättre läsbarhet för vår kod. Så nu är frågan hur kommer vi att uppnå överbelastning?
Låt oss titta på de med varandra med exempelkoder.
Metod # 1 - Genom att ändra antalet parametrar
Så här kommer vi att göra tilläggsoperationer på vissa nummer. Låt oss skapa en klass som heter "AdditionOperation" för detta. Inom den klassen, låt oss ha två metoder som heter "tillägg ()". I en av dessa metoder kommer vi att utföra ett tillägg av två siffror. I det andra kommer vi att lägga till tre siffror. Detta kommer vi att uppnå genom att helt enkelt ändra antalet parametrar i dessa metoder, men vi kommer att hålla namnet detsamma. På detta sätt överbelaster vi metoden ”tillägg ()” här.
Koda:
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.
)
)
Produktion:
Metod # 2 - Genom att ändra datatypen
Så här kommer vi att göra tilläggsoperationer för olika typer, till exempel mellan heltalstyp och mellan dubbel typ. Låt oss skapa en klass som heter "AdditionOperation" för detta. Inom den klassen, låt oss ha två metoder som heter "tillägg ()". I en av dessa metoder kommer vi att lägga till två heltal. I det andra kommer vi att utföra tillägget av två dubbla. Detta kommer vi att uppnå genom att helt enkelt ändra typen av parametrar i dessa metoder, men vi kommer att hålla namnet detsamma. På detta sätt överbelaster vi metoden ”tillägg ()” här.
Koda:
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.
)
)
Produktion:
Poäng som ska noteras för överbelastning
- Överbelastning i java är i princip en "kompileringstid-polymmetod överbelastning i C # orphism". Polymorfism i kompileringstid i java kallas också "Static method Dispatch" eller "Early binding". Så vad menar jag med den jargongen?
- Polymorfism, som namnet antyder, är i grunden en förmåga att ta många former (poly: många, morph: form). Så här sammanlänkning eller bindning av överbelastad funktion och objekt görs kompileringstid. Därför kallas det kompileringstid-polymorfism.
- I grund och botten här görs bindning av funktion till objekt tidigt före körningstid (dvs under kompileringstid), och därför benämns den också som "tidig bindning".
- Statisk utsändning är en typ av polymorfism eller metodutsändning som berättar hur java kommer att välja vilken funktionalitet för metoden som ska användas i sammanställningstiden. (Jag menar, om det kommer att utföra tillägg av två siffror eller tre nummer i vårt kodningsexempel). Så namnet är också känt som den statiska metoden Dispatch.
Övergripande i Java
- När en java-underklass eller barnklass har en metod som har samma namn och innehåller samma parametrar eller argument och liknande returtyp som en metod som finns i dess superklass eller förälderklass, kan vi kalla metoden för barnklassen som en åsidosatt metod för metoden i dess överordnade klass.
- Anta till exempel att vi måste utföra visningsfunktioner enligt dess klasstyp. Jag menar, om jag kallar metoden för en överordnad klass, kommer det att visa ett meddelande som är definierat i en överordnad klass. Men när vi kallar metoden för barnklass kommer det att åsidosätta visningsmeddelandet för dess överordnade klass och kommer att visa visningsmeddelandet som definieras i metoden för barnklass. Beroende på vilken skärm vi behöver visa kan vi därför ringa den relaterade klassen (förälder eller barn). Här ändrar vi inte metodens namn, argument och returtyp. Vi ändrar bara metodens funktionalitet i barnklass. Men istället för detta, om vi inte gör övervägande, dvs. vi ger inte den specifika implementeringen av underordnad metod, kommer den att visa samma meddelande som närvarande i en förälderklass medan den kallar metoden.
- När vi skriver kod kommer vi att använda @ åsidosätta kommentarer innan metoden som ska åsidosättas. @Orrride-kommentar säger kompilatorn att metoden är tänkt att åsidosätta en metod som förklarades i en superklass. Även om det inte är obligatoriskt att använda detta, hjälper det att förhindra fel. Om en metod som är antecknad med @Override inte åsidosätter en metod genererar kompilatorn ett fel.
Regler för överskridande av Java-metod
- Metoden måste ha samma namn som i förälderklassen
- Metoden måste ha samma parameter som i moderklassen.
- Det måste finnas en IS-A-relation (arv).
Koda:
//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();
)
)
Produktion:
Begränsningar i metodöverskridande:
- Privata metoder för föräldraklassen kan inte åsidosättas.
- Slutliga metoder kan inte åsidosättas
- Statiska metoder kan inte åsidosättas
Poäng som ska noteras för överträning
- Överbelastning i java är i princip en "polymorfism för körning". Polymorfism i körtid i java kallas också "Dynamic method Dispatch" eller "Late binding". Så vad menas med den jargongen?
- Polymorfism, som namnet antyder, är i grunden en förmåga att ta många former (poly: många, morph: form). Så här kallar man till en överbelastad funktion med objektet körtiden. Därför kallad run time polymorfism.
- I princip här görs bindningen av funktion till objekt sent vilket är efter sammanställning (dvs. under körningstid); följaktligen benämns det också "Sen bindning".
- Dynamisk utsändning är en typ av polymorfism eller metodutsändning som berättar hur java kommer att välja vilken funktionalitet för metoden som ska användas i körtid. Så namnet är också känt som Dynamic method Dispatch.
Slutsats
Detta avslutar vår inlärning av ämnet "Överbelastning och överbestyrning i Java". Skriv koderna som nämns i ovanstående exempel i java-kompilatorn och kontrollera utgången. Inlärning av koder kommer att vara ofullständig om du inte gör praktiskt själv eftersom det kommer att förbättra dina kodfärdigheter. Lycklig kodning !!
Rekommenderade artiklar
Detta är en guide till överbelastning och överskridande i Java. Här diskuterar vi metoder i överbelastning tillsammans med regler och begränsningar för överbestyrning i Java. Du kan också gå igenom våra andra föreslagna artiklar för att lära dig mer -
- Överbryter i JavaScript
- Övergripande i OOP
- Vad är generik i Java?
- Övergripande i PHP
- Python överbelastning
- Arv i PHP
- Komplett guide till arv i Python
- Överbelastning och överbestyrning i C #
- Typer och hanteringsfel i JavaScript
- Exempel och hur generiker fungerar i C #
- Funktion och regler för åsidosättande i Python