O que é o método escondido em Java? Até a explicação JavaDoc é confusa.
Javadoc diz:
Não me diz nada. Qualquer exemplo claro que mostre o significado disto será altamente apreciado.a versão do método escondido que é invocado é a que está na superclasse, e a versão do método sobreposto que é invocado é a que está na subclasse.
5 answers
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");
}
}
Cat.foo() diz-se que se esconde Animal.foo(). Esconder não funciona como sobrepor, porque os métodos estáticos não são polimórficos. Então o seguinte vai acontecer:
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
Compare isto com métodos de instância, que são polimórficos e são, portanto, sobrepostos. O método chamado depende do tipo concreto de execução do objeto:
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");
}
}
Então o seguinte acontecer:
Animal a = new Animal();
Animal b = new Cat();
Animal c = new Cat();
Animal d = null;
a.foo(); // prints Animal
b.foo(); // prints Cat
c.foo(); // prints Cat
d.foo(): // throws NullPointerException
Em primeiro lugar, o que significa o método de esconder?
Método de ocultação significa que a subclasse definiu um método de classe com a mesma assinatura que um método de classe na superclasse. Nesse caso, o método da superclasse é escondido pela subclasse. Significa que: a versão de um método que é executado não será determinada pelo objecto que é usado para invocá-lo. De facto, será determinado pelo tipo de Referência variável utilizada para invocar o método.
O que é que se entende por ultrapassagem de métodos?
Method purchasing means subclass had defined an instance method with the same signature and return type (including covariant type) as the instance method in superclass. Nesse caso, o método da superclasse é substituído pela subclasse. Significa que: a versão do método que é executado será determinada pelo objecto isso é usado para invocá-lo. Não será determinado pelo tipo de variável de referência utilizada para invocar o método.
Porque é que os métodos estáticos não podem ser sobrepostos?
Porque, métodos estáticos são resolvidas estaticamente (por exemplo, em tempo de compilação) com base na classe, eles são chamados e não dinamicamente como no caso de métodos de instância que são resolvidos polimorficamente com base no tipo de tempo de execução do objeto.
Como os métodos estáticos devem ser acessados?
Os métodos estáticos devem ser acedidos de forma estática. isto é, pelo nome da classe em si ao invés de usar uma instância.
Aqui está a pequena demonstração para substituir e esconder o método:
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.
}
}
A saída é
I am foo in Super
I am foo in Child
I am bar in Child
I am bar in Child
Claramente, como especificado, uma vez que foo é o método da classe, de modo que a versão de foo invocada será determinada pelo tipo de variável de referência (i. e. Super ou criança) que refere o objecto de Child. Se é referenciado por Super variável então foo de Super é chamado. E se é referenciado por Child variável então foo de Child é chamado.
considerando o seguinte:,
Como bar é o método de instância, então a versão de bar invocada é determinada unicamente pelo objeto(I. e Child) que é usado para invocá-lo. Não importa qual variável de referência (Super ou Child) é chamada, o método que vai ser chamado é sempre de Child.
To overwrite a method means that whenever the method is called on an object of the derived class, the new implementation will be called.
Para ocultar um método significa que uma chamada não qualificada para esse nome no escopo da classe (por exemplo, no corpo de qualquer um de seus métodos, ou quando qualificados com o nome da classe será chamada de uma forma completamente diferente função, , exigindo uma qualificação para acessar o método estático com o mesmo nome do pai classe
Mais Descrição herança Java: métodos substituídos ou escondidos
Se uma subclasse define um método de classe com a mesma assinatura que um método de classe na superclasse, o método na subclasse esconde o método na superclasse.
Os métodos ocultos estão num contexto estático, creio eu. Métodos estáticos não são sobrepostos, por si só, porque a resolução de chamadas de método feitas pelo compilador no próprio tempo de compilação. Então, se você definir um método estático na classe base com a mesma assinatura que aquele presente na classe pai, então o o método na subclasse esconde o método herdado da super classe.class Foo {
public static void method() {
System.out.println("in Foo");
}
}
class Bar extends Foo {
public static void method() {
System.out.println("in Bar");
}
}
Por exemplo, você pode sobrepor os métodos de instância numa super classe, mas não estática.
Esconder é Classe-mãe tem um método estático chamado Foo e a sub classe também tem um método estático chamado Foo.
Outro cenário é que o pai tem um método estático chamado Cat e a sub-classe tem um método de instância chamado Cat. (static and instance with the same signature can't intermix).
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; }
}