Java关键字this、super使用

柔光的暖阳◎ 2022-07-14 02:29 177阅读 0赞

# 一、this #

Java关键字this只能用于方法方法体内。当一个对象创建后，Java虚拟机（JVM）就会给这个对象分配一个引用自身的指针，这个指针的名字就是this。因此，this只能在类中的非静态方法中使用，静态方法和静态的代码块中绝对不能出现this。并且this只和特定的对象关联，而不和类关联，同一个类的不同对象有不同的this。下面给出一个使用this的综合实例，以便说明问题：

package com.deppon.tps.module.Test;
    public class TestThis {
    	 private int number;
    	 private String username;
    	 private String password;
    	 private int x = 100;
    	 public TestThis(int n) {
    		 number = n;  // 这个还可以写为: this.number=n;
    	 }
    	 public TestThis(int i, String username, String password) {
    	     // 成员变量和参数同名,成员变量被屏蔽,用"this.成员变量"的方式访问成员变量.
    		 this.username = username;
    		 this.password = password;
    	 }
    	 // 默认不带参数的构造方法
    	 public TestThis() {
    		 this(0, "未知", "空"); // 通过this调用另一个构造方法
    	 }
    	 public TestThis(String name) {
    		 this(1, name, "空"); // 通过this调用另一个构造方法
    	 }
    	 private void outinfo(TestThis t) {
    		 System.out.println("-----------");
    		 System.out.println(t.number);
    		 System.out.println(t.username);
    		 System.out.println(t.password);
    		 f(); // 这个可以写为: this.f();
    	 }
    	 private void f() {
    	  // 局部变量与成员变量同名,成员变量被屏蔽,用"this.成员变量"的方式访问成员变量.
    		 int x;
    		 x = this.x++;
    		 System.out.println(x);
    		 System.out.println(this.x);
    	 }
    	 //返回当前实例的引用
    	 private TestThis getSelf() {
    		 return this; 
    	 }
    	 public static void main(String args[]) {
    		 TestThis t1 = new TestThis();
    		 TestThis t2 = new TestThis("游客");
    		 t1.outinfo(t1);
    		 t2.outinfo(t2);
    	 }
    }

**通过以上例子总结如下：**

1、通过this调用另一个构造方法，用发是this(参数列表)，这个仅仅在类的构造方法中，别的地方不能这么用。  
 2、函数参数或者函数中的局部变量和成员变量同名的情况下，成员变量被屏蔽，此时要访问成员变量则需要用“this.成员变量名”的方式来引用成员变量。当然，在没有同名的情况下，可以直接用成员变量的名字，而不用this，用了也不为错。  
 3、在函数中，需要引用该函所属类的当前对象时候，直接用this。

# 二、super #

super关键和this作用类似，是被屏蔽的成员变量或者成员方法或变为可见，或者说用来引用被屏蔽的成员变量和成员成员方法。  
不过 super是用在子类中 ，目的是访问直接父类中被屏蔽的成员，注意是直接父类（就是类之上最近的超类） 。下面是一个综合运用super的例子，有两个类：一个Father类，一个Father类的子类Son，通过这两个类完全演示了super的用法，一下是代码：

package com.deppon.tps.module.Test;
    class Father {
    	 public String v="Father";
    	 public String x="输出了Father类的public成员变量x!!!";
    	 
    	 public Father() {
    		 System.out.println("Father构造方法被调用!");
    	 }
    	 public Father(String v){
    		 this.v="Father类的带参数构造方法!运行了.";
    	 }
    	 public void outinfo(){
    		 System.out.println("Father的outinfo方法被调用");
    	 } 
    }
    class Son extends Father{
    	 public String v="Son";
    	 public Son() {
    		 super();      //调用超类的构造方法,只能放到第一行.
    		 System.out.println("Son无参数构造方法被调用!");
    		 //super();      //错误的,必须放到构造方法体的最前面.
    	 } 
    	 
    	 public Son(String str){
    		 super(str);
    		 System.out.println("Son带参数构造方法被调用!");
    	 }
    	 //覆盖了超类成员方法outinfo()
    	 public void outinfo(){ 
    		 System.out.println("Son的outinfo()方法被调用");
    	 } 
    	 void test(){
    		 String v="哈哈哈哈!";   //局部变量v覆盖了成员变量v和超类变量v
    		 System.out.println("------1-----");
    		 System.out.println(v);   //输出局部变量v
    		 System.out.println(this.v);  //输出(子类)成员变量v
    		 System.out.println(super.v); //输出超类成员变量v 
    		  
    		 System.out.println("------2-----");
    		 System.out.println(x);   //输出超类成员变量v,子类继承而来
    		 System.out.println(super.x); //输出超类成员变量v
    		  
    		 System.out.println("------3-----");
    		 outinfo();   //调用子类的outinfo()方法
    		 this.outinfo();  //调用子类的outinfo()方法
    		 super.outinfo(); //调用父类的outinfo()方法
    	} 
    }
    public class TestSuper {
    	public static void main(String[] args) {
    		new Son().test();
    	}
    }

**通过以上例子总结如下：**  
1、在子类构造方法中要调用父类的构造方法，用“super(参数列表)”的方式调用，参数不是必须的。同时还要注意的一点是：“super(参数列表)”这条语句只能用在子类构造方法体中的第一行。  
2、当子类方法中的局部变量或者子类的成员变量与父类成员变量同名时，也就是子类局部变量覆盖父类成员变量时，用“super.成员变量名”来引用父类成员变量。当然，如果父类的成员变量没有被覆盖，也可以用“super.成员变量名”来引用父类成员变量，不过这是不必要的。  
3、当子类的成员方法覆盖了父类的成员方法时，也就是子类和父类有完全相同的方法定义（但方法体可以不同），此时，用“super.方法名(参数列表)”的方式访问父类的方法。