java的super和this关键字用法总结

------super关键字------

        
        super用途：在子类中访问超类“被隐藏的成员变量(无论是否静态)和静态方法”以及“被重写的实例方法”。这里的超类必须是“直接超类”，即子类之上最近的超类。
        super的用法：
        ①在子类构造方法中调用超类的构造方法，用“super(ParamList)”的方式调用，ParamList根据超类构造方法而定，可以为空。另外super(ParamList)必须是子类构造方法的第一句。
        ②当超类的成员变量因与子类的成员变量同名而被隐藏时(成员变量隐藏与是否静态无关)，可用"super.memberVariableName"来访问超类的成员变量。
            注意：有些人说当超类的成员变量与子类某方法的局部变量或参数同名时，也属于被隐藏。那么一旦离开该方法隐藏还成立吗，显然这种说法是错误的。隐藏概念只限于成员变量范围，方法体内的局部变量与成员变量同名属于下面的this要讨论的内容。
                         假设有超类parent，其中有成员变量A，子类child，其中有方法method(type A)存在：
                        1)如果子类没有隐藏超类成员变量A，在method(type A)中，无论使用this.A还是super.A都是一样的，都会访问超类成   员变量A;(this.A就是继承下来的，换句话说，对于自然继承下来(没有隐藏/重写)的成员变量甚至是方法，super.memberName=this.membername)
                        2)如果子类有成员变量A隐藏了超类成员变量A，在method(type A)中，super.A=parent.A，this.A=child.A，两者有区别。
        ③当超类的静态方法/实例方法被子类隐藏/重写时，可使用"super.methodName(ParamList)"来访问超类方法。对于静态方法而言，这没什么奇怪，对于实例方法而言，这种用法使得超类被重写的方法在子类中可见。

最后需要注意，super关键字不能在静态方法中使用！

------this关键字------

this的用途：引用对象本身。
当一个对象创建后，Java虚拟机就会给这个对象分配一个引用自身的指针，这个指针的名字就是this。因此，this只能在类中的非静态方法中使用，静态方法和静态的代码块中绝对不能出现this。并且this只和特定的对象关联，而不和类关联，同一个类的不同对象有不同的this。
         this用法：
         ①在构造方法中，用this(ParamList)调用自己的另一个构造方法，this(ParamList)必须放在第一句位置！此用法只限于在构造方法中使用。
         ②某方法的参数或局部变量与某个成员变量同名时，在该方法中要访问该成员变量需要用“this.memberVariableName”的形式。
         ③某方法中需要引用其所属类的当前对象时，直接用this来引用当前对象。
示例代码：

1. import java.lang.reflect.Field;
2. import java.lang.reflect.Modifier;
3. class A {
4. int x;
5. static double y;
6. char z;
7. A(char z) {
8. this.z = z; // this访问成员变量，以区分同名参数
9. }
10. A(double newy, char newz) {
11. double y = newy; // this访问成员变量，以区分同名局部变量
12. char z = newz;
13. this.y = y; // 因y是静态成员变量，最好使用className.staticMemberVarName即A.y访问
14. this.z = z;
15. }
16. A(int a, double b, char c) {
17. this(b, c);// 使用this(paramList)调用另一个构造方法必须放在第一句位置
18. this.x = a;// 此处无法再使用this(x);理由同上
19. }
20. void OutPut() {
21. if (this.equals(this))// this作为对象引用使用，当然此条件永远=true
22. System.out.println("我是类" + GetClassName() + "的方法"
23. + GetInvokeMethodName());
24. }
25. String GetClassName() {
26. return this.getClass().getName();
27. }
28. String GetInvokeMethodName() {
29. String TempName = new Exception().getStackTrace()[1].getMethodName();
30. return TempName;
31. }
32. static void showStaticFieldValue(Object obj) throws Exception { //
33. Field fields[] = obj.getClass().getDeclaredFields();
34. String fieldName, fieldModifier, fieldType;
35. Object val;
36. for (int i = 0; i < fields.length; i++) {
37. Field field = fields[i];
38. if (field.toString().indexOf("static") != -1) {
39. // System.out.println(field.toString());
40. fieldName = field.getName();
41. fieldType = field.getType().getName();
42. fieldModifier = Modifier.toString(field.getModifiers());
43. field.setAccessible(true);
44. val = field.get(obj);
45. System.out.println(fieldModifier + " " + fieldType + " "
46. + fieldName + " = " + val);
47. }
48. }
49. }
50. void getStaticFieldValue() {
51. try {
52. showStaticFieldValue(this);
53. } catch (Exception e) {
54. }
55. }
56. }
57. class B extends A {
58. static double x;// 隐藏超类A的成员变量x
59. int y = (int) this.x + 1;// 隐藏超类A的成员变量y，有人说this必须在方法体中使用，无情的击破其谣言。
60. // 继承了超类A的成员变量z，仍为char z;
61. B(char c) {
62. super(c);/*
63. * super(c)调用超类构造函数的目的在于初始化自然继承的超类成员，若子类完全隐藏了超类的成员变量， 则可以不用super
64. * super(ParamList)访问超类构造函数 疑问： 1.类B隐藏且改变了类A的成员变量，
65. * super(b)是否仅仅改变了B中包含的A对象的值， 而B中的static double x的值仍然为默认值?(待验证)
66. * 2.java的构造方法属于实例方法还是静态方法？
67. */
68. x = super.y + 1.0;// super访问超类被隐藏的成员变量double y，也可以写成A.y
69. y = super.x;// super访问超类被隐藏的成员变量int x
70. }
71. String GetClassName() {// 重写超类A的GetClassName()
72. return "类类类BBB";
73. }
74. String GetInvokeMethodName() {// 重写超类A的GetInvokeMethodName()
75. return "方法名称方法名称方法名称";
76. }
77. void OutPut() { // 重写超类的OutPut实例方法.
78. System.out.println("super调用超类被重写的两个方法输出：类名="
79. + super.GetClassName() + "，方法名=" + super.GetInvokeMethodName());// super调用超类的实例方法
80. System.out.println("用类B的重写方法输出：类名=：" + GetClassName() + ","
81. + "，方法名="+GetInvokeMethodName());// 调用自己的方法
82. }
83. static void showStaticFieldValue(Object obj) throws Exception { // 隐藏超类的静态方法
84. System.out.println("static Field doulbe x=" + x);
85. }
86. void getStaticFieldValue() {
87. try {
88. System.out.println("super调用超类A的方法输出静态成员变量");
89. super.showStaticFieldValue(this); // super调用超类被隐藏的静态方法
90. System.out.println("类B自己的方法输出静态成员变量");
91. showStaticFieldValue(this);// 类B自己的方法
92. } catch (Exception e) {
93. }
94. }
95. }
96. class Example3_15 {
97. public static void main(String[] args) {
98. A myA = new A(8, 6.0, 'k');
99. B myB = new B('哦');
100. myA.getStaticFieldValue();
101. myA.OutPut();
102. System.out.println("====================");
103. myB.getStaticFieldValue();
104. myB.OutPut();
105. }
106. }