javaSE学习-面向对象2-this、super关键字

Posted on | In |

this 关键字

this 关键字，代表当前对象，也就是指向对象本身的指针

this 的用法

区分成员变量和方法变量

1
2
3
4
5
6
7
8
public class Person{
	public String name;
	public int age;
	
	public void setName(String name){
      this.name = name;
    }
}

在 setName 中，方法变量 name 和成员变量name名称相同，为区分两个变量，使用 this 关键字引用成员变量；因为 this 关键字代表 Person 对象，修饰的变量 name（this.name）就是 Person 对象的成员变量 name ，另一个 name 采用方法的就近原则，指的是方法参数name

调用构造方法

1
2
3
4
5
6
7
8
9
10
11
public class Person{
	public String name;
	public int age;
	
	public Person(String name){
      this.name = name;
    }
	public Person(){
	  this("张三");
	}
}

在同一个类中，无参构造方法中使用 this 调用另一个有参构造方法

对类对象的引用

1
2
3
4
5
public class Person{
	public Person psoDemo(){
		return this;
	}
}

此时 return this 代表返回当前对象 Person 类

注意，如果在匿名内部类中使用，this 代表的是所在匿名类的对象，而不是外部调用类的实例

匿名内部类

1
2
3
4
5
6
7
8
9
10
public class ThisClass{
	int i = 1;
	public thisDemo(){
	    Thread thread = new Thread(){//匿名类
	        public void run(){
	            Hello.this.run();//调用外部类的方法
	        }
	    };
	}
}

此时 this 指的是匿名对象，而不是 ThisClass 对象

super 关键字

指向当前对象的父类，用super引用直接父类对象的成员；

super只能调用的是所在类的直接父类，在当前对象最近的父类；不能越过直接的父类调用父类以上的父类中的变量方法

super用法

子类构造方法调用父类的构造方法

super() 方法只能放在子类构造方法的第一行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class Father{
	public Father(){
		System.out.print("This is father");
	}
	public Father(String act){
		System.out.print("father "+ act);
	}
}
public class Son extends Father{
	public Son(){
		super();
		System.out.print("This is son");
	}
	public Son(String act){
		super(act);
		System.out.print("son "+act);
	}
	public static void main(String[] args) { 
       Son son = new Son(); 
       son = new Son("在打游戏..."); 
    } 
}

调用父类自身对象中同名变量、方法

如果子类中有变量或者方法和父类的变量或方法重名，那么可以使用super调用父类的变量或方法

但是访问父类的成员变量和方法时，注意不能访问父类的私有属性的变量方法！！！

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Father{
    public int age = 30;
    private int num; 
    public void say(){
        System.out.print(age);
    }
}
class Son extends Father{
    private int age = 3;
    public void say(){
        System.out.print("father 的age："super.age);  //正确
        System.out.print("father 的num："+super.num); //错误
    }
    public void tell(){
        super.say();
    }
}

以上程序中，Son继承了Father类

Son中有跟父类同名成员变量a，同名方法say()

  • super.a：调用父类a变量，前提是父类的a变量是公有的
  • super.num：是错误的！因为父类中的num是private，所有子类没有权限访问
  • super.say()：调用父类Father的say()方法，而不是子类的say()方法

调用父类的父类中的方法

super不能越过直接的父类调用父类以上的父类中的变量方法，但是如果想要访问父类的父类中的方法，在父类继承父类的父类中的成员方法后可以访问 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class A{
	private int a;
	public int numA = 10;
	public void sumNum(){
		num = num+1;
	}
}

class B extends A{
}

class C extends B{
	public void setNumA(){
		super.super.sumNum();	//错误
		super.sumNum();	//正确
	}
}

this 和 super 比较

  • this 指向当前对象，调用本类的成员变量和方法；super指向父类，调用父类的成员变量和方法
  • this和super语句都要放在构造方法中的第一行
  • 每个子类继承父类之后，在子类的无参构造方法中第一条都会默认隐式调用super()方法调用父类无参构造方法
  • this相当于本身对象的一个指针，用来调用当前对象的成员；而super不是指针，只是一个关键字