Inleiding tot overbelasting in Java
Java is een objectgeoriënteerde programmeertaal en volgt de basisconcepten van OOP's. Overbelasting is een van de belangrijke concepten in Java. Overbelasting maakt verschillende methoden mogelijk met dezelfde naam in een klasse maar met verschillende handtekeningen. Handtekening omvat het aantal parameters, het gegevenstype van parameters en de reeks parameters die in de methode zijn doorgegeven. In Java, de methode en de constructors, kunnen beide worden overbelast. Overbelasting van methoden wordt gedaan tijdens het compileren en daarom is het bekend tijdens het compileren. Overbelasting van methoden in een klasse wordt gedaan om de leesbaarheid van programma's te vergroten, zodat de programmeur een verbeterde implementatie van elke methode voor verschillende scenario's kan schrijven.
Overweeg een scenario waarin de programmeur het volume van verschillende geometrische figuren zoals de kubus, cilinder en rechthoekig prisma wil weten. Omdat drie van hen een andere formule hebben voor het vinden van het volume en een ander aantal parameters hebben. Het volume van de kubus heeft slechts één parameter nodig, de cilinder heeft twee en het rechthoekige prisma heeft drie parameters nodig. Maar het belangrijkste doel is alleen het volume van de cijfers te vinden. We kunnen dus afzonderlijke volumemethoden maken voor verschillende figuren, maar met dezelfde naam. Op deze manier wordt Method Overloading in praktische scenario's gebruikt.
Hoe werkt overbelasting op Java?
Werking van methode-overbelasting wordt uitgelegd met een voorbeeld:
Code:
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));
) )
Output:
Verklaring van de bovenstaande code: In het bovenstaande voorbeeld moeten we het volume van 3 geometrische figuren vinden, dus we hebben 3 afzonderlijke overbelaste methoden gemaakt met dezelfde naam als 'volume' maar alle methoden hebben een verschillend aantal argumenten. Dus in de hoofdmethode, wanneer one.volume (10) wordt uitgevoerd, wordt de volumemethode met een enkele parameter, dat wil zeggen int volume (int kant) genoemd. Evenzo worden voor de andere volumemethoden op basis van het aantal argumenten verschillende methoden aangeroepen en verwerkt.
In dit voorbeeld worden methoden overbelast op basis van het aantal argumenten, maar ze kunnen ook worden overbelast op basis van het gegevenstype van parameters en opeenvolging van parameters en daarom alleen op basis daarvan worden aangeroepen.
Soorten overbelasting in Java
Er zijn in principe 3 manieren van methode-overbelasting in Java:
1. Aantal parameters
Java-methoden kunnen worden overbelast door het aantal parameters dat in de methode wordt doorgegeven. Als de volumemethode 1 bijvoorbeeld 2 parameters heeft en een andere methode 3 parameters, dan valt deze onder Overbelasting op basis van het aantal parameters.
Code:
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));
)
)
Output:
2. Datatype van parameters
Het gegevenstype van parameters dat in de methode wordt doorgegeven, is erg belangrijk en daarom kunnen methoden als overbelast worden beschouwd als 2 of methoden dezelfde naam hebben met hetzelfde of een ander aantal argumenten, maar verschillende gegevenstypes van parameters in de verschillende methoden.
Code:
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));
)
)
Output:
3. Volgorde van parameters
Methode Overbelasting kan ook worden gedaan door de reeks parameters van 2 of meer overbelaste methoden te wijzigen. Als de parameters van 1 methode bijvoorbeeld (String x, char y) zijn en de andere methode (char x, String y) maar beide dezelfde naam hebben, worden de bovenstaande 2 methoden beschouwd als Overbelast door een andere reeks van parameters.
Code:
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))
)
)
Output:
Verklaring van de bovenstaande code: In het bovenstaande voorbeeld zijn beide methoden voor 'details' overbelast op basis van reeksparameters. Wanneer de instructie emp.details ('Rajesh', 'A') wordt aangeroepen, wordt de methode met de argumenten in de volgorde (String, char), dwz ongeldige details (Stringnaam, char rank), aangeroepen en verwerkt.
Regels voor overbelasting in Java
Hieronder staan de regels die moeten worden onthouden bij het overbelasten van Java:
- De eerste en belangrijkste regel van methode-overbelasting is dat methoden dezelfde naam in een enkele klasse moeten hebben.
- Twee of meer methoden in een klasse kunnen worden overbelast op basis van verschillende handtekeningen en handtekening omvat het aantal parameters, gegevenstypes van parameters, de reeks parameters zoals hierboven uitgelegd.
- Het retourtype van een methode maakt geen deel uit van de handtekening, dus overbelasting kan nooit worden gedaan op basis van het retourtype en als dit wordt gedaan, creëert dit de compilatie-fout.
Conclusie
Overbelasting is een van de belangrijke concepten in Java en kan voor zowel methoden als constructeurs worden uitgevoerd. Er zijn enkele regels voor overbelasting waarmee u rekening moet houden voordat u deze in de programmering implementeert.
Aanbevolen artikelen
Dit is een gids voor overbelasting in Java. Hier bespreken we enkele bepaalde regels voor overbelasting die moeten worden overwogen voordat belangrijke concepten in Java, methoden en constructors worden geïmplementeerd. U kunt ook onze andere gerelateerde artikelen doornemen voor meer informatie -
- Overbelasting in C ++
- Hulpmiddelen voor Java-implementatie
- Overerving in Java
- Overbelasting in PHP
- Polymorfisme op Java
- Overerving in PHP