Primordial vs Cacher Java Confus

Plus de l'équitation, fondamentalement, prend en charge la liaison tardive . Par conséquent, la méthode qui sera appelée est décidé au moment de l'exécution.C'est pour les non-méthodes statiques.
Le masquage est pour tous les autres membres (méthodes statiques , les membres de l'instance, les membres statiques). Il est basé sur la liaison anticipée . Plus clairement , la méthode ou le membre d'être appelé ou utilisé est décidé lors de la compilation.

Dans votre exemple, le premier appel , Animal.testClassMethod() est un appel à une static méthode,par conséquent, il est assez sûr que la méthode qui va être appelé.

Dans le deuxième appel,myAnimal.testInstanceMethod(), il appelle une non-méthode statique. C'est ce qu'on appelle polymorphisme de l'exécution. Il n'est pas décidé jusqu'au moment de l'exécution de la méthode qui sera appelée.

Pour plus de précisions, lire cette.

C'est la différence entre les remplacements et la clandestinité,

1. Si à la fois la méthode dans la classe parent et de l'enfant de la classe sont une méthode d'instance, il a appelé les remplacements.
2. Si à la fois la méthode dans la classe parent et de l'enfant de la classe sont à la méthode statique, il a appelé la clandestinité.
3. Une méthode ne peut pas être statique parent et comme une instance de l'enfant. et vice-versa.

Primordial se produit uniquement avec des méthodes d'instance.
Lorsque le type de la variable de référence est l'Animal et l'objet est le Chat puis la méthode d'instance est appelée à partir de Chat (c'est primordial). Pour la même acat objet à la méthode de classe de l'Animal est utilisé.

public static void main(String[] args) {
    Animal acat = new Cat();
    acat.testInstanceMethod();
    acat.testClassMethod();

}

De sortie est:

The instance method in Cat.
Class method in Animal.

Dans cet extrait de code, j'utilise "privé" modificateur d'accès au lieu de "statique" pour vous montrer la différence entre cacher les méthodes et la redéfinition des méthodes.

class Animal {
//Use 'static' or 'private' access modifiers to see how method hiding work.
private void testInstancePrivateMethod(String source) {
System.out.println("\tAnimal: instance Private method calling from "+source);
}
public void testInstanceMethodUsingPrivateMethodInside() {
System.out.println("\tAnimal: instance Public method with using of Private method.");
testInstancePrivateMethod( Animal.class.getSimpleName() );
}
//Use default, 'protected' or 'public' access modifiers to see  how method overriding work.
protected void testInstanceProtectedMethod(String source) {
System.out.println("\tAnimal: instance Protected method calling from "+source);
}
public void testInstanceMethodUsingProtectedMethodInside() {
System.out.println("\tAnimal: instance Public method with using of Protected method.");
testInstanceProtectedMethod( Animal.class.getSimpleName() );
} 
}  
public class Cat extends Animal {
private void testInstancePrivateMethod(String source) {
System.out.println("Cat: instance Private method calling from " + source );
}
public void testInstanceMethodUsingPrivateMethodInside() {
System.out.println("Cat: instance Public method with using of Private method.");
testInstancePrivateMethod( Cat.class.getSimpleName());
System.out.println("Cat: and calling parent after:");
super.testInstanceMethodUsingPrivateMethodInside();
}
protected void testInstanceProtectedMethod(String source) {
System.out.println("Cat: instance Protected method calling from "+ source );
}
public void testInstanceMethodUsingProtectedMethodInside() {
System.out.println("Cat: instance Public method with using of Protected method.");
testInstanceProtectedMethod(Cat.class.getSimpleName());
System.out.println("Cat: and calling parent after:");
super.testInstanceMethodUsingProtectedMethodInside();
}
public static void main(String[] args) {
Cat myCat = new Cat();
System.out.println("----- Method hiding -------");
myCat.testInstanceMethodUsingPrivateMethodInside();
System.out.println("\n----- Method overriding -------");
myCat.testInstanceMethodUsingProtectedMethodInside();
}
}

De sortie:

----- Method hiding -------
Cat: instance Public method with using of Private method.
Cat: instance Private method calling from Cat
Cat: and calling parent after:
Animal: instance Public method with using of Private method.
Animal: instance Private method calling from Animal
----- Method overriding -------
Cat: instance Public method with using of Protected method.
Cat: instance Protected method calling from Cat
Cat: and calling parent after:
Animal: instance Public method with using of Protected method.
Cat: instance Protected method calling from Animal

public class Parent {
public static void show(){
System.out.println("Parent");
}
}
public class Child extends Parent{
public static void show(){
System.out.println("Child");
}
}
public class Main {
public static void main(String[] args) {
Parent parent=new Child();
parent.show(); //it will call parent show method
}
}
//We can call static method by reference ( as shown above) or by using class name (Parent.show())

Outre les exemples énumérés ci-dessus, voici un petit exemple de code pour clarifier la distinction entre la clandestinité et majeur:

public class Parent {
//to be hidden (static)
public static String toBeHidden() {
return "Parent";
}
//to be overridden (non-static)
public String toBeOverridden() {
return "Parent";
}
public void printParent() {
System.out.println("to be hidden: " + toBeHidden());
System.out.println("to be overridden: " + toBeOverridden());
}
}
public class Child extends Parent {
public static String toBeHidden() {
return "Child";
}
public String toBeOverridden() {
return "Child";
}
public void printChild() {
System.out.println("to be hidden: " + toBeHidden());
System.out.println("to be overridden: " + toBeOverridden());
}
}
public class Main {
public static void main(String[] args) {
Child child = new Child();
child.printParent();
child.printChild();
}
}

L'appel de child.printParent() sorties:

pour être caché: Parent

pour être redéfinies: Enfant

L'appel de child.printChild() sorties:

pour être caché: Enfant

pour être redéfinies: Enfant

Que wee pouvez le voir à partir des sorties ci-dessus (surtout les gras sorties), la méthode de masquage se comporte différemment de primordial.

Java permet à la fois cacher et prioritaire que pour les méthodes. La même règle ne s'applique pas à des variables. La redéfinition de variables n'est pas autorisé, de sorte que les variables ne peuvent être cachés (pas de différence entre statique ou variable non statique). L'exemple ci-dessous montre comment la méthode getName() est surchargé et la variable name est caché:

public class Main {
public static void main(String[] args) {
Parent p = new Child();
System.out.println(p.name); //prints Parent (since hiding)
System.out.println(p.getName()); //prints Child (since overriding)
}
}
class Parent {
String name = "Parent";
String getName() {
return name;
}
}
class Child extends Parent {
String name = "Child";
String getName() {
return name;
}
}

Dans la méthode primordial, la méthode de résolution est effectuée par la JVM sur la base de l'exécution de l'objet. Alors que dans la méthode de la clandestinité, de la méthode de résolution est effectuée par le compilateur sur la base de référence.
Ainsi,

Si le code aurait été écrit comme,

public static void main(String[] args) {
Animal myCat = new Cat();        
myCat.testClassMethod();        
}

La Sortie sera comme ci-dessous:

Méthode de la classe des Animaux.