Java中this和super关键字
程序员文章站
2022-05-13 20:04:09
...
this和super关键字的介绍
- this:存储的“当前对象”的引用;
- this可以访问:本类的成员属性、成员方法、构造方法;
- super:存储的“父类对象”的引用;
- super可以访问:父类的成员属性、成员方法、构造方法;
this关键字的三种用法
- this访问本类成员变量: this.成员变量
public class Student{
String name = "张三";
public void show(){
String name = "李四";
System.out.println("name = " + name);// 李四
System.out.println("name = " + this.name);// 张三
}
}
- this访问本类成员方法: this.成员方法名()
public class Student{
public void show(){
System.out.println("show方法...");
this.eat();
}
public void eat(){
System.out.println("eat方法...");
}
}
- this访问本类构造方法: this()可以在本类的一个构造方法中,调用另一个构造方法
public class Student{
public Student(){
System.out.println("空参构造方法...");
}
public Student(String name) {
this();//当使用this()调用另一个构造方法时,此代码必须是此构造方法的第一句有效代码。
System.out.println("有参构造方法...");
}
}
public class Demo {
public static void main(String[] args) {
Student stu2 = new Student();
}
}
super关键字的三种用法
- super访问父类的成员变量: super.父类成员变量名
class Fu{
int num = 100;
}
class Zi extends Fu{
int num = 10;
public void show(){
int num = 1;
System.out.println("局部变量num:"+num);// 1
System.out.println("Zi 类中的num:"+this.num);// 10
System.out.println("Fu 类中的num:"+super.num);// 100
}
}
- super访问父类的成员方法: super.成员方法名();
class Fu{
public void method1(){
System.out.println("Fu method1...");
}
}
class Zi extends Fu{
public void show(){
// 访问父类的method1方法
super.method1();
}
@Override
public void method1(){
super.method1();// 调用父类的method1方法
System.out.println("Zi method1...");
}
}
- super访问父类的构造方法: super()
public class Fu{
public Fu(){
System.out.println("Fu 类的空参构造方法..");
}
public Fu(String name, int age) {
System.out.println("Fu 类的有参构造方法..");
}
}
public class Zi extends Fu{
public Zi(){
super();// 调用父类的空参构造方法
System.out.println("Zi 类的空参构造方法..");
}
public Zi(String name,int age){
super(name,age);// 调用父类的有参构造方法
System.out.println("Zi 类的有参构造方法..");
}
}
public class Demo {
public static void main(String[] args) {
Zi zi = new Zi();
System.out.println("----------------------");
Zi z2 = new Zi("刘德华", 17);
}
}
小结
this关键字的三种用法:
this可以访问本类的成员变量: this.成员变量 一般用来区分同名的成员变量和局部变量
this可以访问本类的成员访问: this.成员方法名(实参);
this可以访问本类的构造方法:
空参构造: this();
有参构造: this(实参);
注意:
1.只能在本类的构造方法中使用this调用其他构造方法
2.在本类的构造方法中使用this调用其他构造方法,必须放在该构造方法的第一行,否则会报错
3.两个构造方法不能使用this相互调用
super关键字的三种用法:
super可以访问父类的成员变量: super.成员变量 一般用来区分父子类中同名的成员变量
super可以访问父类的成员方法: super.成员方法(实参); 一般用来在子类中访问父类的成员方法
super可以访问父类的构造方法:
空参构造: super();
有参构造: super(实参);
注意:
1.子类的构造方法默认会调用父类的空参构造方法
2.super访问父类的构造方法,可以用来初始化从父类继承过来的属性
3.在子类的构造方法中,使用super调用父类的构造方法,必须放在子类构造方法的第一行
super的注意事项一
- super访问成员变量和成员方法: 优先去父类中找,如果有就直接使用,如果没有就去爷爷类中找,如果有,就用,依次类推...
```java
class Ye{
int num = 10;
public void method(){
System.out.println("Ye method");
}
}
class Fu extends Ye{
int num = 100;
public void method(){
System.out.println("Fu method");
}
}
class Zi extends Fu{
int num = 1000;
public void show(){
System.out.println(super.num);
super.method();
}
}
public class Test {
public static void main(String[] args) {
Zi zi = new Zi();
zi.show();
}
}
super的注意事项二
- 子类的构造方法默认会调用父类的空参构造方法,如果父类中的没有空参构造方法,只定义了有参构造方法,会编译报错
class Fu1{
public Fu1(){
System.out.println("Fu1 空参构造");
}
public Fu1(int num){
System.out.println("Fu1 有参构造");
}
}
class Zi1 extends Fu1{
public Zi1(){
// super();
}
public Zi1(int num){
// super();
}
}
// 问题: super调用父类的构造方法有什么用?
class Person{
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public void show(){
System.out.println(name+","+age);
}
}
class Student extends Person{
public Student(String name,int age){
super(name,age);
}
}
public class Test2 {
public static void main(String[] args) {
/*
super的注意事项二
1.子类的构造方法默认会调用父类的空参构造方法
2.如果父类中的没有空参构造方法,只定义了有参构造方法,会编译报错
问题: super调用父类的构造方法有什么用?
结果: 为了在创建子类对象的时候,初始化从父类继承过来的属性
*/
// 通过调用子类的空参构造方法,创建子类对象
// Zi1 zi = new Zi1();
// 通过调用子类的有参构造方法,创建子类对象
//Zi1 zi = new Zi1(100);
// 创建Student类的对象
Student stu = new Student("张三", 18);
stu.show();
}
}
小结
- super访问成员变量和成员方法: 优先去父类中找,如果有就直接使用,如果没有就去爷爷类中找,如果有,就用,依次类推…
- 子类的构造方法默认会调用父类的空参构造方法,如果父类中的没有空参构造方法,只定义了有参构造方法,会编译报错
- 子类构造方法中使用super调用父类的构造方法,是为了在创建子类对象的时候,初始化从父类继承过来的属性
上一篇: java实现归并排序,快速排序