[Java] Überladen und überschreiben

Fassen Sie Überladungen und Überschreibungen zusammen

Überlast

Definieren Sie mehrere ** verschiedene ** Methoden mit demselben Namen, aber ** Signatur **. → Auch wenn der Name derselbe ist ** Anders als eine Methode **

** * Was ist Unterschrift ** -Methodenname -Argumentlistentyp -Anzahl der Argumente ・ Reihenfolge der Argumente

** [Dinge, die beim Überladen nicht zu beachten sind] ** ・ Differenz im Rückgabewert -Argumentvariablenname ・ Unterschied im Zugriffsmodifikator

Beispiel)

int price(int a, double b){
   return a * b;
}

[Überlastungsmuster]

double price(int a){   //Da es als separate Methode behandelt wird, gibt es kein Problem, selbst wenn der Rückgabewert geändert wird. Überladen, weil die Signaturen unterschiedlich sind
  //wird bearbeitet
}

int price(double a, int b){  //Argumentreihenfolge umgekehrt → Überladung
  //wird bearbeitet
}

[** Es ist auch möglich, eine Methode ** mit final ** zu überladen]

final void price(){
   //wird bearbeitet
}

void prince(int a){  //Die endgültige Methode kann auch überladen werden! Weil es als eine andere Methode behandelt wird.
  //wird bearbeitet
}

[Muster, das keine Überlastung verursacht]

int price(int product, double tax){  //Der Argumentname ist keine Signatur. Überlastet nicht
   //wird bearbeitet
}

überschreiben

Wenn Sie eine übergeordnete Klasse erben und eine untergeordnete Klasse deklarieren, müssen Sie die Mitglieder der übergeordneten Klasse mit der untergeordneten Klasse überschreiben.

** [Bedingungen überschreiben] ** ・ Die Signatur ist dieselbe

• ** Rückgabetyp ** muss ** derselbe Typ ** oder ** Unterklassentyp ** sein wie das Mitglied der übergeordneten Klasse
• Geben Sie den ** Zugriffsmodifikator ** an, der ** mit dem Mitglied der übergeordneten Klasse identisch oder ** lockerer ** ist. -Die Mitglieder der Elternklasse haben kein ** final **

Beispiel)

class Infant{
  protected void talk(){
     System.out.println("Ogyaa");
  }
} 

[Muster, die überschrieben werden können]

class Adult extends Infant {
  public void talk(){   //Lose Zugriffsmodifikatoren als die Talk-Methode der übergeordneten Klasse
    System.out.println("Hallo");
 }
}

[Muster, die nicht überschrieben werden können]

class Adult extends Infant {
  void talk(){   //Strengere Zugriffsmodifikatoren als die übergeordnete Klassengesprächsmethode
    System.out.println("Hallo");
 }
}

class Adult extends Infant {
  void talk(String a){   //Signatur unterscheidet sich von der Sprechmethode der übergeordneten Klasse (wird überladen)
    System.out.println("Hallo" + a);
 }
}