Introduktion til overbelastning i Java

Java er et objektorienteret programmeringssprog, og det følger grundlæggende OOP-koncepter. Overbelastning er et af de vigtige koncepter i Java. Overbelastning tillader forskellige metoder, der har samme navn i en klasse, men med forskellige underskrifter. Signatur inkluderer antallet af parametre, datatypen af ​​parametre og sekvensen af ​​parametre, der er videregivet i metoden. I Java kan metoden og konstruktørerne begge overbelastes. Overbelastning af metoder udføres på kompileringstidspunktet, og det er derfor kendt ved kompileringstidspolymorfisme. Overbelastning af metoder i en klasse udføres for at øge læsbarheden af ​​programmer, så programmereren kan skrive en forbedret implementering af en hvilken som helst metode til forskellige scenarier.

Overvej et scenario, hvor programmereren ønsker at finde ud af mængden af ​​forskellige geometriske figurer som terningen, cylinderen og det rektangulære prisme. Da tre af dem har en anden formel til at finde lydstyrken og har et andet antal parametre. Kubens volumen behøver kun en parameter, cylinderen tager to, og rektangulært prisme tager tre parametre. Men hovedformålet er kun at finde mængden af ​​tal. Så vi kan oprette separate volumenmetoder for forskellige figurer, men med samme navn. På denne måde bruges metodeoverbelastning i praktiske scenarier.

Hvordan fungerer overbelastning i Java?

Arbejde med metodeoverbelastning forklares med et eksempel:

Kode:

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:

Forklaring af ovenstående kode: I ovenstående eksempel er vi nødt til at finde lydstyrken på 3 geometriske figurer, så vi har oprettet 3 separate overbelastede metoder med samme navn som 'volumen', men alle metoder har forskellige antal argumenter. Så i hovedmetoden, når en.volumen (10) køres, kaldes metoden til volumen, der har en enkelt parameter, dvs. int-volumen (int-side). Tilsvarende kaldes og behandles forskellige metoder på de andre volumenmetoder på grundlag af antallet af argumenter.

I dette eksempel overbelastes metoder på grundlag af antallet af argumenter, men de kan også overbelastes på grundlag af datatypen af ​​parametre og rækkefølgen af ​​parametre og derfor kun kaldes i henhold til den.

Typer af overbelastning i Java

Der er dybest set 3 måder til metodeoverbelastning i Java:

1. Antal parametre

Java-metoder kan overbelastes med antallet af parametre, der er passeret i metoden. Hvis f.eks. 1-volumenmetoden har 2 parametre, og en anden metode har 3 parametre, kommer den under Overbelastning på grundlag af antallet af parametre.

Kode:

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. Datatype af parametre

Datatypen af ​​parametre, der er videregivet i metoden, betyder meget, og metoder kan derfor betragtes som Overbelastet, hvis 2 eller metoder har samme navn med det samme eller forskellige antal argumenter, men forskellige datatyper parametre i de forskellige metoder.

Kode:

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 af parametre

Metodeoverbelastning kan også udføres ved at ændre sekvensen med parametre for 2 eller flere overbelastede metoder. For eksempel, hvis parametrene for 1 metode er (streng x, char y) og den anden metode er (char x, streng y), men begge har det samme navn, betragtes de ovennævnte 2 metoder som overbelastede af en anden sekvens af parametre.

Kode:

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:

Forklaring af ovenstående kode: I ovenstående eksempel overbelastes begge metoder til 'detaljer' på grundlag af rækkefølge, hvis parametre. Når udsagnet emp.details ('Rajesh', 'A') kaldes, kaldes og behandles metoden med argumenterne i rækkefølgen (String, char), dvs. ugyldige detaljer (String name, char rank).

Regler for overbelastning i Java

Nedenfor er reglerne, der skal huskes ved overbelastning af java:

  • Den første og vigtigste regel for overbelastning af metoden er, at metoder skal have det samme navn i en enkelt klasse.
  • To eller flere metoder i en klasse kan overbelastes på basis af forskellige underskrifter, og signatur inkluderer antallet af parametre, datatyper af parametre, sekvensen af ​​parametre som forklaret ovenfor.
  • Returtypen for en metode er ikke en del af underskriften, så overbelastning aldrig kan udføres på grundlag af returtypen, og hvis det er gjort, skaber dette compile-time-fejlen.

Konklusion

Overbelastning er et af de vigtige koncepter i Java og kan udføres til både metoder og konstruktører. Der er nogle regler for overbelastning, som skal huskes, før de implementeres i programmeringen.

Anbefalede artikler

Dette er en guide til overbelastning i Java. Her diskuterer vi nogle bestemte regler for overbelastning, der skal overvejes, inden vigtige koncepter implementeres i Java, metoder og konstruktører. Du kan også gennemgå vores andre relaterede artikler for at lære mere -

  1. Overbelastning i C ++
  2. Java-implementeringsværktøjer
  3. Arv i Java
  4. Overbelastning i PHP
  5. Polymorfisme i Java
  6. Arv i PHP

Kategori: