overriding and hiding methods and variables in Java in Inheritance (i)

We know that in Java, subclasses can inherit the parent class, and if the subclass declares a method that has the same name as the parent class, we all know that if you rewrite it, but in fact it is divided into two cases, that is, methods and variables in the inheritance of the cover and hide problems, these conceptual things seem boring, But in the interview or SCJP certification questions around these are often encountered, so here to discuss

First, let's look at some concepts.

Class variables: Also called static variables, which belong to a class and can be accessed by class names.

Instance variable: an instance of a class, an object that can access an instance variable through an object, but cannot access an instance variable through the class name.

static method: Accessed through the class name.

Instance method: Object access, which cannot be accessed through the class name.

Hidden : Child hides the parent's variables and methods, then child cannot access the parent's hidden variables or methods, but converts B to a to access a hidden variable or method

Overwrite : Child overrides the parent's variable or method, then child cannot access the variable or method that the parent is overridden, and the parent's overridden variable or method is also inaccessible after the child is converted to parent

First look at the rules for overriding and hiding methods and variables in Java when they inherit

1. Instance and static variables of the parent class can be hidden by a variable of the same name in the quilt class

2. Static method of the parent class the quilt class with the same name static method hidden

3. Instance methods of the parent class overridden by an instance variable of the same name in the quilt class

There are a few more things to note.

1. You cannot use a static method of a subclass to hide An instance method that is equally marked in the parent class (that is, the return value name parameter is the same)

2. You cannot overwrite a static method that is equally marked in the parent class with an instance method of the child class

3, the variable will only be hidden will not be overwritten , whether he is an instance variable or a static variable, and the child class static variable can hide the parent class instance variable, the child class's instance variable can hide the parent class static variable

4. The final method (the method with the keyword final) cannot be overwritten.

O (∩_∩) o haha ~ is not a bit around the mouth, okay we look at an example

Create a class of two parent-child class relationships

2. Parent class
4. Class Parent
6. {
8. public static String kind="Javastudy.extendsstudy.parent";
10. public static int age=50;
12. Public String name="Parent";
16. //static method, return package name
18. public static String Getkind ()
20. {
22. System.out.println ("The Getkind () method of the parent has been called");
24. return kind;
26. }
30. //static method, return age
32. public static int getage ()
34. {
36. System.out.println ("The Getage () method of the parent has been called");
38. return age;
40. }
44. //instance method, return name
46. Public String getName ()
48. {
50. System.out.println ("The GetName () method of the parent has been called");
52. return this.name;
54. }
58. }
64. Sub-class
66. Class child extends Parent
68. {
70. public static String kind="Javastudy.extendsstudy.child";
72. public int age=25;
74. Public String name="Child";
78. //Hide Parent class static method
80. public static String Getkind ()
82. {
84. System.out.println ("Child's Getkind () method was called");
86. return kind;
88. }
92. //Get parent class package name
94. public static String Getparentkind ()
96. {
98. return parent.kind;
100. }
104. //Override Parent class instance method
106. Public String getName ()
108. {
110. System.out.println ("Child's GetName () was called");
112. return this.name;
114. }
118. //Get parent class name
120. Public String getparentname ()
122. {
124. return Super.name;
126. }
128. /* 
130. * Error, instance method cannot overwrite static method of parent class
132. public int Getage ()
134. {
136. return this.age;
138. }
140. */
142. }

And then the test.

2. Class Test
4. {
6. public static void Main (string[] args)
8. {
10. Child child=New Child ();
12. System.out.printf ("Subclass name:%s, Age:%d, package name:%s%n", child.name,child.age,child.kind);
14. //output: Subclass Name: Child, Age: 25, Package: Javastudy.extendsstudy.child
18. //Convert child to Parent object
20. Parent Parent=child;
24. System.out.printf ("converted name:%s, Age:%d, package name:%s%n", parent.name,parent.age,parent.kind);
26. //output: Converted Name: Parent, Age: 50, Package: Javastudy.extendsstudy.parent
30. System.out.printf ("subclass access to the parent class is hidden by the instance variable name:%s%n", Child.getparentname ());
32. //Output: Subclass accesses the instance variable that the parent class is hidden name:parent
36. System.out.printf ("subclass access to the parent class is hidden static variable kind:%s", Child.getparentkind ());
38. //Output: Subclass accesses a static variable that is hidden by the parent class Kind:javastudy.extendsstudy.parent
42. Child.getname ();
44. //output: Child's GetName () is called
48. //************** Pay attention to this method, return is the subclass of the GetName
50. Parent.getname ();
52. //output: Child's GetName () is called
56. Child.getkind ();
58. //output: Child's Getkind () method is called
62. Parent.getkind ();
64. //output: The Getkind () method of the parent is called
66. }
68. }

All right, I'll summarize it after we've seen the results.

1. Instance methods with the same name are overwritten , static methods with the same name are hidden , and the GetName instance method of the child class overrides the GetName instance method of the parent, Chind Getkind method Hides the Getkind method of the parent class

2. The difference between hiding and overriding is that when a subclass object is converted to a parent class object, it is able to access the hidden variables and methods of the parent class, and cannot access the method that the parent class is overridden

3. If you need to access an instance variable that the parent class is hidden , plus super, such as accessing the name of the parent class, write Super.name.

4. Subclasses to access the class variables that are hidden by the parent class, you need the name of the parent class plus "." To access. For example: Parent.name

This article is not to teach you to rewrite the parent class variables, but focus on the methods and variables of the hidden and covered, these small knowledge points although in the project is not how to use, but must remember, otherwise many errors will be puzzled, there is scjp the question bank of this kind of problem greatly exists, So I think these small knowledge is still remembered as good.

overriding and hiding methods and variables in Java in Inheritance (i)