面向对象之super关键字

super关键字

首先来了解下this和super的区别
this可以理解为当前对象,谁调用this就代指那个调用者对象,
每次创建一个对象,默认都会创建一个this变量指向同一个堆区空间
super本质是父类存储空间的标识,但是你可以理解为父类对象,
那么同样可以使用super这个关键字来访问父类的成员

访问成员
成员变量

this.成员变量
super.成员变量

成员方法

this.成员方法
super.成员方法

构造方法
this(参数列表)
super(参数列表)

注意:
1.任何一个类的无参或者带参构造方法的第一句都默认省略 super();
2.任何一个类都直接或者间接继承自Object类
3.为什么设计Object类,满足了万事万物皆对象的原则
访问根类Object的无参构造方法的意义何在? - 加载Object类中静态成员和静态代码块
4.创建一个子类对象默认会去调用父类的构造方法,那么有没有在创建子类对象的同时也创建了父类对象呢?
没有创建父类对象,本质就相当于访问了一个普通方法,创建对象开启空间需要new关键字
5.super访问父类带参构造方法的意义? – 帮助子类初始化父类继承下来的成员,简化编程
6.静态环境/静态上下文(static修饰的方法),不能够出现this和super
7.super必须出现在构造方法的第一句
8.this和super不能够共存

举例1代码如下：

public class SuperDemo01 {
	public static void main(String[] args) {
//		Zi zi = new Zi();
//		Zi zi = new Zi("张三", 18, "北京西路");
		Fu fu = new Fu();
		System.out.println(fu.name + "|" + fu.age);
		/*
		 * 我是父类带参构造方法
		 * 我是父类无参构造方法
		 * "王五" 20
		 */
	}
}

class Fu extends Object {
	public String name;
	public int age;
	private double weight;
	
	public Fu() {
		super();
//		this("王五", 20);
		System.out.println("我是父类无参构造方法");
	}
	
	public Fu(String name, int age) {
		System.out.println("我是父类带参构造方法");
		this.name = name;
		this.age = age;
	}
	
	public void fuMethod() {
		
	}
	
	public static void staticMethod() {
	}
}

class Zi extends Fu {
	
	private String address;
	
	public Zi() {
		super();
		System.out.println("我是子类无参构造方法");
	}
	
	public Zi(String name, int age, String address) {
//		super();
//		System.out.println("我是子类带参构造方法");
//		this.name = name;
//		this.age = age;
		super(name, age);
		this.address = address;
	}
	
	public void ziMethod() {
		System.out.println(super.name);
		this.fuMethod();
		super.fuMethod();
	}
	
}

举例2代码如下：

public class SuperDemo02 {
	public static void main(String[] args) {
		Son son = new Son();
		son.show();
	}
}

class Father{
	
	public int num = 10;
	
	public void method() {
		int num = 20;
		System.out.println(num);
	}
}

class Son extends Father{
	
	int num = 30;
	
	public void show() {
		int num = 40;
		// 我想要输出40?
		System.out.println(num);
		// 我想要输出30?
		System.out.println(this.num);
		// 我想要输出20，怎么做?
		this.method();
		super.method();
		// 我想要输出10怎么做？
		System.out.println(super.num);
	}
	
}

举例3代码如下：(此案例有错误，编译错误)

public class SuperDemo03 {
	public static void main(String[] args) {
		Sons s = new Sons();
		System.out.println(s.num);
	}
}

class Fathers{
	
	public int num = 10;
	//下面这个要加上
	//public Fathers() {
		//父类默认也有无参构造方法，但是没有写，下面的有参构造方法覆盖了无参构造方法，所以当子类的super()方法访问父类时，父类只有有参构造方法，所以编译就报错，需加上父类的无参构造方法
	//}
	public Fathers(int num){
		this.num = num;
	}
}

class Sons extends Fathers{
	
	int num = 20;
	//public Son(){
	//super();	//子类的默认无参构造方法,默认有一个super()方法
	//}
}