Introduktion till överbelastning i Java
Java är ett objektorienterat programmeringsspråk och följer grundläggande OOP-koncept. Överbelastning är ett av de viktiga koncepten i Java. Överbelastning tillåter olika metoder med samma namn i en klass men med olika signaturer. Signatur inkluderar antalet parametrar, datatypen för parametrar och sekvensen av parametrar som skickats i metoden. I Java kan metoden och konstruktörerna båda överbelastas. Överbelastning av metoder utförs vid sammanställningstid och därför är det känt vid kompileringstid-polymorfism. Överbelastning av metoder i en klass görs för att öka läsbarheten för program så att programmeraren kan skriva en förbättrad implementering av vilken metod som helst för olika scenarier.
Tänk på ett scenario där programmeraren vill ta reda på volymen för olika geometriska figurer som kub, cylinder och rektangulärt prisma. Som tre av dem har en annan formel för att hitta volymen och har ett annat antal parametrar. Kubens volym behöver bara en parameter, cylindern tar två och rektangulärt prisma tar tre parametrar. Men det huvudsakliga syftet är att bara hitta mängden siffror. Så vi kan skapa separata volymmetoder för olika figurer men med samma namn. På detta sätt används metodöverbelastning i praktiska scenarier.
Hur fungerar överbelastning i Java?
Working of Method Overloading förklaras med ett exempel:
Koda:
class Main(
int volume(int side)
(
return side * side * side;
)
int volume(int length, int breadth, int height)
(
return length*breadth*height;
)
double volume(int radius, int height)
( return 3.14 * (radius * radius)* height / 3;
)
public static void main(String() args)
(
Main oe = new Main();
System.out.println("Volume of Cube " +oe.volume(10));
System.out.println("Volume of Rectangular prism " +oe.volume(10, 12, 30));
System.out.println("Volume of Cone "+oe.volume(5, 10));
) )
Produktion:
Förklaring av koden ovan: I exemplet ovan måste vi hitta volymen på 3 geometriska figurer så vi har skapat 3 separata överbelastade metoder med samma namn som 'volym' men alla metoder har olika antal argument. Så i huvudmetoden, när en.volym (10) körs, kallas volymmetoden med en enda parameter, dvs int-volym (int-sida). På liknande sätt kallas och bearbetas olika metoder för andra volymmetoder, baserat på antalet argument.
I det här exemplet är metoder överbelastade på grundval av antalet argument men de kan också överbelastas på grundval av datatypen för parametrar och sekvens av parametrar och därmed endast kallas enligt det.
Typer av överbelastning i Java
Det finns i princip tre sätt att överbelasta metoden i Java:
1. Antal parametrar
Java-metoder kan överbelastas med antalet parametrar som passeras i metoden. Om till exempel volymmetoden har 2 parametrar och en annan metod har 3 parametrar kommer den under överbelastning baserat på antalet parametrar.
Koda:
class Multiplication
(
int mult(int a, int b) // method mult having 2 parameters
(
return a*b;
)
//Method Overloading on number of parameters
int mult(int a, int b, int c) // method mult having 3 parameters
(
return a*b*c;
)
)
class Main
(
public static void main(String() args)
(
Multiplication M = new Multiplication();
System.out.println(M.mult(10, 9));
System.out.println(M.mult(10, 9, 8));
)
)
Produktion:
2. Datatyp av parametrar
Datatypen för parametrar som skickats i metoden betyder mycket och därför kan metoder betraktas som överbelastade om 2 eller metoder har samma namn som har samma eller olika antal argument men olika datatyper av parametrar i de olika metoderna.
Koda:
class Multiplication
(
int mult(int a, int b) // method mult having 2 parameters
(
return a*b;
)
//Method Overloading on datatype of parameters
double mult(double a, double b) // method mult overloaded
(
return a*b;
)
)
class Main
(
public static void main(String() args)
(
Multiplication M = new Multiplication();
System.out.println(M.mult(10, 9));
System.out.println(M.mult(10.5, 9.8));
)
)
Produktion:
3. Sekvens av parametrar
Metodöverbelastning kan också göras genom att ändra sekvensen med parametrar för två eller flera överbelastade metoder. Om till exempel parametrarna för 1 metod är (sträng x, char y) och den andra metoden är (char x, sträng y) men båda har samma namn, anses ovanstående två metoder vara överbelastade av en annan sekvens av parametrar.
Koda:
class Employee
(
void details(String name, char rank) // method details having 2 parameters
(
System.out.println("Employee name is "+name);
System.out.println("Employee ranking is "+rank);
) //Method Overloading on sequence of parameters
void details(char rank, String name) // method details overloaded
(
System.out.println("Employee name is "+name);
System.out.println("Employee ranking is "+rank);
)
)
class Main
(
public static void main(String() args)
( Employee emp = new Employee();
emp.details("Rajesh", 'A'); // calls the first method (details(String, char))
emp.details("Ram", 'B'); // calls the second method (details(char, String))
)
)
Produktion:
Förklaring av koden ovan: I exemplet ovan är båda metoderna för 'detaljer' överbelastade på basis av sekvensen om parametrar. När uttalandet emp.details ('Rajesh', 'A') anropas kallas och behandlas metoden med argumenten i ordningen (String, char), dvs ogiltiga detaljer (String name, char rank).
Regler för överbelastning i Java
Nedan följer reglerna som ska komma ihåg vid Java-överbelastning:
- Den första och främsta regeln för överbelastning av metoder är att Metoder måste ha samma namn i en enda klass.
- Två eller flera metoder i en klass kan överbelastas på basis av olika signaturer och signaturen inkluderar antalet parametrar, datatyper av parametrar, sekvensen av parametrar som förklarats ovan.
- Returtypen för en metod är inte en del av signaturen så att överbelastning aldrig kan göras på grundval av returtyp och om det är gjort skapar detta kompileringstidsfelet.
Slutsats
Överbelastning är ett av de viktiga koncepten i Java och kan göras för både metoder och konstruktörer. Det finns några regler för överbelastning som bör hållas i åtanke innan de implementeras i programmering.
Rekommenderade artiklar
Detta är en guide till överbelastning i Java. Här diskuterar vi vissa regler för överbelastning som bör övervägas innan viktiga koncept implementeras i Java, metoder och konstruktörer. Du kan också gå igenom våra andra relaterade artiklar för att lära dig mer -
- Överbelastning i C ++
- Java-distributionsverktyg
- Arv i Java
- Överbelastning i PHP
- Polymorfism i Java
- Arv i PHP