Java's super and this keyword usage summary

------Super keyword------

Super Purpose: Access superclass "hidden member variables (whether static or not) and static methods" and "overridden instance methods" in subclasses. The superclass here must be a "direct superclass", the most recent superclass above the subclass.
How to use Super:
① calls the constructor of the superclass in the subclass construction method, called with "super (Paramlist)", and paramlist can be empty depending on how the superclass is constructed. Also super (paramlist) must be the first sentence of the subclass construction method.
② when a member variable of a superclass is hidden because it has the same name as a member variable of a subclass (the member variable is hidden from static), you can use "super.membervariablename" to access the member variables of the superclass.
Note: Some people say that when a member variable of a superclass has the same name as a local variable or parameter of a method of a subclass, it is also hidden. So once you leave this method of hiding, it is clear that this is wrong. The hidden concept is limited to the range of member variables, and the local variables in the method body belong to the same name as the member variables below this is what to discuss.
Assume that there is a superclass parent, where there is a member variable A, subclass child, where there are method methods (type A) present:
1) If the subclass does not hide the superclass member variable A, in method (Type a), regardless of the use of this. A or super.a are the same, access the superclass member variable A; A is inherited, in other words, a member variable that is inherited by nature (no hidden/rewritten), or even a method, Super.membername=this.membername)
2) If the subclass has member variable A that hides the superclass member variable A, in method (Type a), super. A=parent. A,this. A=child. A, there is a difference between the two.
③ when a static method/instance method of a superclass is hidden/overridden, you can use "Super.methodname (paramlist)" To access the superclass method. For static methods, this is no surprise, and for instance methods, this usage makes the superclass overridden methods visible in subclasses.

Finally, be aware that the Super keyword cannot be used in static methods! ------The This keyword------
Purpose of this: Refers to the object itself.
When an object is created, the Java Virtual machine assigns a pointer to the object that refers to itself, which is the name of this pointer. Therefore, this can only be used in non-static methods in the class, and the static method and the static code block must never appear in this. And this is only associated with a particular object, not with a class, and different objects of the same class have different this.
This usage:
① in the constructor method, use this (paramlist) to call its own other construction method, this (paramlist) must be placed in the first sentence position! This usage is limited to use in construction methods.
② the parameter or local variable of a method has the same name as a member variable, it needs to be "this.membervariablename" in order to access the member variable in the method.
③ A method needs to refer to the current object of its owning class, use this to refer to the current object directly.
Example code:
[Java]View Plaincopy

2. Import Java.lang.reflect.Field;
4. Import Java.lang.reflect.Modifier;
8. Class A {
10. int x;
12. static double y;
14. Char Z;
18. A (char z) {
20. this.z = z; //This accesses the member variable to differentiate the parameter with the same name
22. }
26. A (double newy, char newz) {
28. double y = newy; //This accesses member variables to distinguish local variables with the same name
30. char z = newz;
32. this.y = y; //Because Y is a static member variable, it is best to use Classname.staticmembervarname or a.y to access
34. this.z = z;
36. }
40. A (int A, double b, char c) {
42. This (b, c); //Use this (paramlist) call another constructor method must be placed in the first sentence position
44. this.x = A; This (x) can no longer be used here;
46. }
50. void OutPut () {
52. if (this.equals (this))//This is used as an object reference, of course this condition is always =true
54. System.out.println ("I am Class" + getclassname () + "method"
56. + Getinvokemethodname ());
58. }
62. String GetClassName () {
64. return This.getclass (). GetName ();
66. }
70. String Getinvokemethodname () {
72. String tempname = new Exception (). Getstacktrace () [1].getmethodname ();
74. return tempname;
76. }
80. static void Showstaticfieldvalue (Object obj) throws Exception { //
82. Field fields[] = Obj.getclass (). Getdeclaredfields ();
84. String FieldName, FieldModifier, FieldType;
86. Object Val;
88. For (int i = 0; i < fields.length; i++) {
90. Field field = Fields[i];
92. if (field.tostring (). IndexOf ("static")! =-1) {
94. //System.out.println (field.tostring ());
96. FieldName = Field.getname ();
98. FieldType = Field.gettype (). GetName ();
100. FieldModifier = modifier.tostring (Field.getmodifiers ());
102. Field.setaccessible (true);
104. val = field.get (obj);
106. System.out.println (FieldModifier + " " + FieldType + ""
108. + FieldName + "=" + val);
110. }
112. }
114. }
118. void GetStaticFieldValue () {
120. try {
122. Showstaticfieldvalue (this);
124. } catch (Exception e) {
128. }
130. }
132. }
136. Class B extends A {
138. static double x; To hide the member variable x for Super Class A
140. int y = (int) this.x + 1;   Hide the member variable y of super Class A, some say this must be used in the method body, mercilessly break its rumors.
144. //inherits the member variable Z of Super Class A, still char Z;
148. B (char c) {
150. super (c); /* 
152. * SUPER (C) The purpose of calling the superclass constructor is to initialize the superclass member of the natural inheritance, and if the subclass completely hides the member variable of the superclass, it can be used without super
154. * SUPER (Paramlist) Access Superclass constructor question: 1. Class B hides and changes the member variable of Class A.
156. * SUPER (b) is the value of the A object contained in B changed only, and the value of static double X in B is still the default value? (Pending verification)
158. * 2.java Construction method is an instance method or a static method?
160. */
162. x = Super.y + 1.0; Super Access Super class is hidden member variable double y, can also be written as A.y
164. y = super.x; Super Access Super class hidden member variable int x
166. }
170. String GetClassName () {//rewrite getclassname of superclass A ()
172. return "Class-class BBB";
174. }
178. String Getinvokemethodname () {//rewrite getinvokemethodname of superclass A ()
180. Return "Method Name Method name Method name ";
182. }
186. void Output () { //overrides the output instance method of the superclass.
188. System.out.println ("Super Call Super Class overridden two method output: Class name ="
190. + Super. GetClassName () + ", Method name =" + super. Getinvokemethodname ()); //Super Call instance method of superclass
192. System.out.println ("Output with the overridden method of Class B: class name =:" + getclassname () + ","
194. + ", Method name =" +getinvokemethodname ()); //Call your own method
196. }
200. static void Showstaticfieldvalue (Object obj) throws Exception { //Hide Superclass method
202. System.out.println ("Static Field doulbe x=" + x);
204. }
208. void GetStaticFieldValue () {
210. try {
212. System.out.println ("Super calls the method of super Class A to output static member variable");
214. Super.showstaticfieldvalue (this); //Super Call the static method that the superclass is hidden
216. System.out.println ("Class B's own method outputs static member variables");
218. Showstaticfieldvalue (this); Class B's Own method
220. } catch (Exception e) {
222. }
224. }
226. }
230. Class Example3_15 {
232. public static void Main (string[] args) {
234. A MyA = new A (8, 6.0, ' K ');
236. b MyB = new B (' Oh ');
238. Mya.getstaticfieldvalue ();
240. Mya.output ();
242. System.out.println ("====================");
244. Myb.getstaticfieldvalue ();
246. Myb.output ();
248. }
250. }

Java's super and this keyword usage summary