Javadoczegt:
de versie van de verborgen methode die wordt aangeroepen is die in de superklasse, en de versie van de overschreven methode die wordt aangeroepen is die in de subklasse.
gaat bij mij geen belletje rinkelen. Elk duidelijk voorbeeld dat de betekenis hiervan laat zien, wordt zeer op prijs gesteld.
Antwoord 1, autoriteit 100%
public class Animal {
public static void foo() {
System.out.println("Animal");
}
}
public class Cat extends Animal {
public static void foo() { // hides Animal.foo()
System.out.println("Cat");
}
}
Hier wordt gezegd dat Cat.foo()Animal.foo()verbergt. Verbergen werkt niet zoals overschrijven, omdat statische methoden niet polymorf zijn. Dus het volgende zal gebeuren:
Animal.foo(); // prints Animal
Cat.foo(); // prints Cat
Animal a = new Animal();
Animal b = new Cat();
Cat c = new Cat();
Animal d = null;
a.foo(); // should not be done. Prints Animal because the declared type of a is Animal
b.foo(); // should not be done. Prints Animal because the declared type of b is Animal
c.foo(); // should not be done. Prints Cat because the declared type of c is Cat
d.foo(); // should not be done. Prints Animal because the declared type of d is Animal
Het aanroepen van statische methoden op instanties in plaats van klassen is een zeer slechte gewoonte en mag nooit worden gedaan.
Vergelijk dit met instantiemethoden, die polymorf zijn en dus worden overschreven. De aangeroepen methode hangt af van het concrete runtime-type van het object:
public class Animal {
public void foo() {
System.out.println("Animal");
}
}
public class Cat extends Animal {
public void foo() { // overrides Animal.foo()
System.out.println("Cat");
}
}
Dan gebeurt het volgende:
Animal a = new Animal();
Animal b = new Cat();
Cat c = new Cat();
Animal d = null;
a.foo(); // prints Animal
b.foo(); // prints Cat
c.foo(); // prints Cat
d.foo(): // throws NullPointerException
Antwoord 2, autoriteit 30%
Allereerst Wat wordt bedoeld met de methode Verbergen?
Methode verbergen betekent dat de subklasse een klassenmethodeheeft gedefinieerd met dezelfde handtekening als een klassenmethode in de superklasse. In dat geval wordt de methode van superklasse verborgen door de subklasse. Het betekent dat: De versie van een methode die wordt uitgevoerd NIETwordt bepaald door het object dat wordt gebruikt om deze aan te roepen. In feite wordt het bepaald door het type referentievariabele dat wordt gebruikt om de methode aan te roepen.
Wat wordt bedoeld met het overschrijven van methoden?
Methode overschrijven betekent dat de subklasse een instantiemethodeheeft gedefinieerd met dezelfde handtekening en hetzelfde retourtype (inclusief het covariante type) als de instantiemethode in de superklasse. In dat geval wordt de methode van de superklasse overschreven (vervangen) door de subklasse. Het betekent dat: De versie van de methode die wordt uitgevoerd zal wordenbepaald door het object dat wordt gebruikt om deze aan te roepen. Het wordt niet bepaald door het type referentievariabele dat wordt gebruikt om de methode aan te roepen.
Waarom kunnen statische methoden niet worden overschreven?
Omdat statische methoden statisch worden opgelost (d.w.z. tijdens het compileren) op basis van de klasse waarop ze worden aangeroepen en niet dynamisch zoals in het geval van instantiemethoden die polymorf worden opgelost op basis van het runtime-type van het object.
Hoe moeten statische methoden worden gebruikt?
Statische methoden moeten op een statische manier worden benaderd. d.w.z. door de naam van de klasse zelf in plaats van een instantie te gebruiken.
Hier is de korte demo voor het overschrijven en verbergen van methoden:
class Super
{
public static void foo(){System.out.println("I am foo in Super");}
public void bar(){System.out.println("I am bar in Super");}
}
class Child extends Super
{
public static void foo(){System.out.println("I am foo in Child");}//Hiding
public void bar(){System.out.println("I am bar in Child");}//Overriding
public static void main(String[] args)
{
Super sup = new Child();//Child object is reference by the variable of type Super
Child child = new Child();//Child object is referenced by the variable of type Child
sup.foo();//It will call the method of Super.
child.foo();//It will call the method of Child.
sup.bar();//It will call the method of Child.
child.bar();//It will call the method of Child again.
}
}
Uitvoer is
I am foo in Super
I am foo in Child
I am bar in Child
I am bar in Child
Het is duidelijk, zoals gespecificeerd, aangezien foode klassenmethode is, dus de versie van foodie wordt aangeroepen, wordt bepaald door het type referentievariabele (dwz Super of Child) waarnaar wordt verwezen het object van Child. Als ernaar wordt verwezen door de variabele Super, wordt foovan Superaangeroepen. En als ernaar wordt verwezen door de variabele Child, wordt foovan Childaangeroepen.
Terwijl,
Aangezien barde instantiemethode is, wordt de aangeroepen versie van baruitsluitend bepaald door het object (d.w.z. Child) dat wordt gebruikt om het aan te roepen. Het maakt niet uit via welke referentievariabele (Superof Child) deze wordt aangeroepen, de methode die wordt aangeroepen is altijd Child.
Antwoord 3, autoriteit 2%
Het overschrijvenvan een methode betekent dat wanneer de methode wordt aangeroepen op een object van de afgeleide klasse, de nieuwe implementatie wordt aangeroepen.
Een methode verbergenbetekent dat een niet-gekwalificeerde aanroep van die naam in het bereik van deze klasse (dwz in de hoofdtekst van een van zijn methoden, of wanneer gekwalificeerd met de naam van deze klasse) roep nu een geheel andere functie aan, vereist een kwalificatie om toegang te krijgen tot de statische methode met dezelfde naam van de bovenliggende klasse.
Meer beschrijving Java-overerving: overschreven of verborgen methoden
Antwoord 4
Als een subklasse een klassemethode definieert met dezelfde handtekening als een klassemethode in de superklasse, verbergt de methode in de subklasse die in de superklasse.
Verborgen methoden bevinden zich in een statische context, geloof ik. Statische methoden worden niet per se overschreven, omdat de oplossing van methodeaanroepen door de compiler wordt gedaan tijdens het compileren zelf. Als u dus een statische methode definieert in de basisklasse met dezelfde handtekening als die aanwezig is in de bovenliggende klasse, verbergt de methode in de subklasse de methode die is overgenomen van de superklasse.
class Foo {
public static void method() {
System.out.println("in Foo");
}
}
class Bar extends Foo {
public static void method() {
System.out.println("in Bar");
}
}
Antwoord 5
U kunt bijvoorbeeld instantiemethoden in een superklasse overschrijven, maar niet statisch.
Hiding is Parent klasse heeft een statische methode genaamd Foo en de subklasse heeft ook een statische methode genaamd Foo.
Een ander scenario is dat de ouder een statische methode heeft met de naam Cat en de subklasse een instantiemethode met de naam Cat heeft. (statisch en instantie met dezelfde handtekening kunnen niet met elkaar vermengd worden).
public class Animal {
public static String getCat() { return "Cat"; }
public boolean isAnimal() { return true; }
}
public class Dog extends Animal {
// Method hiding
public static String getCat() { }
// Not method hiding
@Override
public boolean isAnimal() { return false; }
}
Antwoord 6
class P
{
public static void m1()
{
System.out.println("Parent");
}
}
class C extends P
{
public static void m1()
{
System.out.println("Child");
}
}
class Test{
public static void main(String args[])
{
Parent p=new Parent();//Parent
Child c=new Child(); //Child
Parent p=new Child(); //Parent
}
}
If the both parent and child class method are static the compiler is responsible for method resolution based on reference type
class Parent
{
public void m1()
{
System.out.println("Parent");
}}
class Child extends Parent
{
public void m1()
{
System.out.println("Child")
}
}
class Test
{
public static void main(String args[])
{
Parent p=new Parent(); //Parent
Child c=new Child(); //Child
Parent p=new Child(); //Child
}
}
If both method are not static jvm is responsible for method resolution based on run time object
Antwoord 7
Wanneer Super / Parent Class en Sub / Child Class dezelfde statische methode bevat, inclusief dezelfde parameters en handtekening. De methode in de superklasse zal worden verborgen door de methode in de subklasse. Dit staat bekend als methode die verstopt.
Voorbeeld: 1
class Demo{
public static void staticMethod() {
System.out.println("super class - staticMethod");
}
}
public class Sample extends Demo {
public static void main(String args[] ) {
Sample.staticMethod(); // super class - staticMethod
}
}
Voorbeeld: 2 – Methode verstopt
class Demo{
public static void staticMethod() {
System.out.println("super class - staticMethod");
}
}
public class Sample extends Demo {
public static void staticMethod() {
System.out.println("sub class - staticMethod");
}
public static void main(String args[] ) {
Sample.staticMethod(); // sub class - staticMethod
}
}