Pokud podtřída poskytne specifickou implementaci pro metodu, která je již definována v jeho nadřazené třídě, nazývá se převažující metoda. Metoda přepsání v podtřídě musí mít stejný název parametry a typ návratu jako metoda v nadřazené třídě.
Pravidla pro převahu metody
- Parametry názvu a typ návratu se musí shodovat s nadřazenou metodou.
- Java vybírá, kterou metodu probíhá za běhu na základě skutečného typu objektu, nejen typu referenční proměnné.
- Statické metody nelze přepsat.
- The @Override anotace Chybí chyby jako překlepy v názvech metod.
class Animal { void move(){ System.out.println( 'Animal is moving.'); } void eat(){ System.out.println( 'Animal is eating.'); } } class Dog extends Animal{ @Override void move(){ // move method from Base class is overriden in this // method System.out.println('Dog is running.'); } void bark(){ System.out.println('Dog is barking.'); } } public class Geeks { public static void main(String[] args) { Dog d = new Dog(); d.move(); d.eat(); d.bark(); } }
Výstup
Dog is running. Animal is eating. Dog is barking.
Vysvětlení: Třída zvířat definuje základní funkce jako pohyb() a jíst() . Třída psů zdědí od zvířete a přepsání metoda pohybu () pro zajištění konkrétního chování Pes běží. Obě třídy mají přístup ke svým vlastním metodám. Při vytváření objektu psího objektu Calling Move () provádí metodu přepsání.
Zvláštní případy převažující
1. Volání rodičovské metody pomocí super
The super klíčové slovo může vyvolat metodu rodičovské třídy z metody převažující.
Javaclass Parent{ void show(){ System.out.println('Parent's show()'); } } class Child extends Parent{ @Override void show(){ super.show(); System.out.println('Child's show()'); } } public class Main{ public static void main(String[] args){ Parent obj = new Child(); obj.show(); } }
Výstup
Parent's show() Child's show()
2. Konečné metody nelze přepsat
Pokud nechceme, aby byla metoda přepsána finále . Viz prosím Používání finále s dědictvím .
řazení v seznamu polí v jazyce JavaJava
class Parent{ // Can't be overridden final void show(){ } } class Child extends Parent{ // This would produce error void show() {} }
Výstup :
3. statické metody
- Statické metody nelze přepsat; Definování statické metody v podtřídě se stejným podpisem jako v super třídě skrývá metodu superclass.
- Metody instancí lze přepsat, ale podtřída nemůže přepsat statickou metodu superclass.
- Statická metoda v podtřídě se stejným podpisem jako statická metoda super třídy skrývá původní metodu.
class Parent{ static void staticMethod(){ System.out.println('Parent static method'); } void instanceMethod(){ System.out.println('Parent instance method'); } } class Child extends Parent{ static void staticMethod(){ // Hides Parent's static method System.out.println('Child static method'); } @Override void instanceMethod(){ // Overrides Parent's instance method System.out.println('Child instance method'); } } public class GFG{ public static void main(String[] args){ Parent p = new Child(); // Calls Parent's static method (hiding) p.staticMethod(); // Calls Child's overridden instance method p.instanceMethod(); } }
Výstup
Parent static method Child instance method
4. soukromé metody
- Soukromé metody nelze přepsat, protože nejsou viditelné pro podtřídy.
- Metoda podtřídy se stejným názvem je považována za novou nezávislou metodu nesouvisející s rodičovskou třídou.
class Parent{ private void display(){ System.out.println('Parent private method'); } } class Child extends Parent{ void display(){ // This is a new method not overriding System.out.println('Child method'); } } public class GFG{ public static void main(String[] args){ Child c = new Child(); // Calls Child's method c.display(); } }
Výstup
Child method
5. typy návratnosti kovariantu
- V metodě přepsající typ návratnosti může být podtřídou typu návratu přepsané metody.
- Tato funkce je známá jako typ návratu kovariantu a umožňuje konkrétnější typy návratnosti v podtřídě.
class Parent{ Parent getObject(){ System.out.println('Parent object'); return new Parent(); } } class Child extends Parent{ @Override // Covariant return type Child getObject() { System.out.println('Child object'); return new Child(); } } public class GFG{ public static void main(String[] args){ Parent obj = new Child(); // Calls Child's method obj.getObject(); } }
Výstup
Child object
Zvládnutí výjimky v převahu
- Převažující metoda nemůže házet nové nebo širší kontrolované výjimky než metoda v superclass.
- Může hodit méně nebo užší kontrolované výjimky.
- Může házet všechny nekontrolované výjimky (jako je runtimeexception) bez ohledu na metodu superclass.
import java.io.IOException; class Parent { void display() throws IOException { System.out.println('Parent method'); } } class Child extends Parent { @Override void display() throws IOException { System.out.println('Child method'); } } public class GFG{ public static void main(String[] args){ // Parent reference Child object Parent obj = new Child(); try{ // Calls Child's overridden method obj.display(); } catch (IOException e){ System.out.println('Exception caught: ' + e.getMessage()); } } }
Výstup
Child method
Proč používáme převažující metodu?
- Změnit nebo zlepšit chování existující metody v podtřídě.
- K dosažení polymorfismu runtime - volání metody závisí na skutečném typu objektu.
- Názvy metod opětovného použití logicky snižují redundanci.
Příklad skutečného života: Systém správy zaměstnanců
Pojďme pochopit přepsání analogií v reálném světě.
Představte si systém řízení zaměstnanců organizace. Všichni zaměstnanci sdílejí některá chování, jako je rychlost () a propaguje (), ale logika se liší pro různé role, jako je manažer nebo inženýr. Můžeme vytvořit jedinou řadu zaměstnanců, kde jsou jednotliví zaměstnanci různých typů (prodejní technologie atd.) A volat jejich funkce. To hodně zjednodušuje celkový kód.
Javaabstract class Employee { abstract void raiseSalary(); abstract void promote(); } class Manager extends Employee{ @Override void raiseSalary(){ System.out.println( 'Manager salary raised with incentives.'); } @Override void promote(){ System.out.println( 'Manager promoted to Senior Manager.'); } } class Engineer extends Employee{ @Override void raiseSalary(){ System.out.println( 'Engineer salary raised with bonus.'); } @Override void promote(){ System.out.println( 'Engineer promoted to Senior Engineer.'); } } public class Company{ public static void main(String[] args){ Employee[] employees = { new Manager() new Engineer() }; System.out.println('--- Raising Salaries ---'); for (Employee e : employees){ e.raiseSalary(); } System.out.println('n--- Promotions ---'); for (Employee e : employees) { e.promote(); } } }
Výstup
--- Raising Salaries --- Manager salary raised with incentives. Engineer salary raised with bonus. --- Promotions --- Manager promoted to Senior Manager. Engineer promoted to Senior Engineer.
Vysvětlení: Přestože jsou objekty manažera i inženýra označovány pomocí typu zaměstnance Java volá přepsané metody skutečných objektů za běhu demonstrující dynamickou metodu odeslání (polymorfismus runtime).
Související článek: Přetížení metody a převažování metody