Hide Variables
In a class, if the name of a variable is the same as the name of a variable of the parent class, even if their type is different, then in the subclass, the same name variable of the parent class cannot be accessed directly by the variable name.
However, a variable with the same name as the parent class can be accessed by super. In general, hidden variables are not recommended, which makes the code difficult to read
overriding and Hiding methods
Object instance Methods
In an object instance method, if a subclass has a method whose signature (the method name, the number and type of parameters of the method), and the return value are the same as the parent class, the method that overrides the parent class.
Subclass overrides the ability to allow a class to inherit the behavior of the parent class, modifying some behavior as needed. The overridden method, which corresponds to the parent class, has the same name, the same parameter type and number, and the same return type. Another overriding method can return a subclass of the return type of the method of the parent class. This is called the covariant return type.
When overriding a method, you will use the annotation @override to tell the compiler how you want to overwrite the parent class. However, if the method does not exist in the parent class, the compiler will make an error.
class Method
If a subclass declares a class method with the same signature as the parent class, the subclass hides the method of the parent class.
The difference between hiding and covering is of great significance. The invocation version of the overridden method is the method of the subclass. Hides the invocation version of a method, depending on whether it is called by the parent class or by the quilt class.
Here is an example of the difference between an object instance method and a class method, and the first class is animal
public class Animal {public static void Testclassmethod () { System.out.println ("the Class" + "method in Animal.") ); } public void Testinstancemethod () { System.out.println ("the instance" + "method in Animal.");} }
The second class is cat, which is a subclass of animal:
public class Cat extends Animal {public static void Testclassmethod () { System.out.println ("The class method" + " In Cat. "); public void Testinstancemethod () { System.out.println ("The instance method" + "in Cat."); } public static void Main (string[] args) { cat mycat = new Cat (); Animal myanimal = mycat; Animal.testclassmethod (); Myanimal.testinstancemethod (); }}
The Cat class covers the instance method of animal and hides its class methods. The resulting output is as follows:
The class method in Animal.the instance method in Cat.
As previously mentioned, because the hidden method is called through the parent class, the calling version of the Hidden method is the parent class. The invocation version of the overridden method is a subclass method.
modifier
The overridden access modifier can allow widening, but does not allow narrowing. For example, a protected object method can be modified in a subclass to public, but not private. Otherwise, the code will fail at compile time.
method Overlay and Hide Summary
The following table summarizes the various scenarios in which a subclass declares a method that is the same as the signature of a parent class
|
Superclass Instance method |
Superclass Static method |
Subclass Instance Method |
Overrides |
Generates a compile-time error |
Subclass Static Method |
Generates a compile-time error |
Hides
|
overwriting and hiding of Java variables and methods (translated from Java tutorials)