JAVA 2020零基础学习课程个人笔记6——Chapter03.14_Super概述

1、super是一个关键字，全部小写

2、super 和 this 对比学习

this：

• this能出现在实例方法和构造方法中
• this的语法是：“this.”、“this()”
• this不能使用在静态方法中
• this. 大部分情况是可省略的
• this. 不能省略的场景：在区分局部变量和实例变量时

• public void setName(String name){
      this.name = name;
  }

• this() 只能出现在构造方法第一行，通过当前的构造方法去调“本类”中其他的构造方法，目的是：代码复用

super：

• super能出现在实例方法和构造方法中
• super的语法是：“super.”、“super()”
• super也不能使用在静态方法中
• super 大部分情况也是可省略的
• super 不能省略的场景？？？？
• this() 只能出现在构造方法第一行，通过当前的构造方法去调“父类”中其他的构造方法，目的是：创建子类对象时，先初始化父类型特征

3、super()  表示通过子类的构造方法调用父亲的构造方法。模拟现实世界中的这种场景：要想有儿子，需要先有父亲

4、重要结论：当一个构造方法第一行 既没有 this() 又没有 super() 的话，默认会有一个 super()，表示通过当前子类的构造方法调用父类的无参数构造方法，所以必须保证父类的无参数构造方法是存在的。

且：一个类如果没有手动提供任何构造方法，系统会默认提供一个无参数构造方法
      一个类如果手动提供了构造方法，那么无参数构造系统将不再提供。 

为避免重要结论中子类调用父类的无参数构造方法出现不存在的情况，故建议手动地将一个类的无参数构造方法写出来。

5、this() 和 super() 不能共存，他们都必须出现在构造方法第一行

6、无论如何，子类构造方法执行时，必然调用父类的构造方法，即父类构造方法一定会执行。

7、在java语言中不管是new什么对象，最后老祖宗的Object类的无参数构造方法一定会执行（Object类的无参数构造方法是处于“栈顶部”）
    栈顶的特点：最后调用，但是最先执行结束，后进先出原则。

8、建议：写代码时一个类的无参数构造方法建议大家手动写出，若无参数构造方法丢失，可能会影响到“子类对象的创建”

9、注意：在构造方法过程中一连串调用了父类的构造方法，父类的构造方法又继续向下调用它的父类的构造方法，但是实际上对象只创建了一个
1）思考：super(实参) 到底是干啥的？ ——初始化当前对象的父类特征，并非创建新对象，实际上对象只创建了一个。
2）super关键字代表什么？ —— “当前对象”的那部分父类型特征
   eg：我继承了我父亲的一部分特征：眼睛、皮肤等，super代表的是“眼睛、皮肤等”，这些虽然是继承自父亲，但是自己身体的一部分
 

public class SuperTest01{
	public static void main(String[] args){
		//创建子类对象
		new B();
		/*执行结果：
			A类的无参数构造方法！
			B类的无参数构造方法！
		*/
	}
}

class A{
	
	//建议手动地将一个类的无参数构造方法写出来
	public A(){
		System.out.println("A类的无参数构造方法！");
	}
	
	//一个类如果没有手动提供任何构造方法，系统会默认提供一个无参数构造方法
	//一个类如果手动提供了构造方法，那么无参数构造系统将不再提供
	public A(int i){
		System.out.println("A类的有参数构造方法(int)");
	}
}

class B extends A{
	public B(){
		this("xz");
		// 默认有的：super(); 会导致调用A的无参构造时，若A没有无参构造方法就会报错
		// super();
		// 新增改为：super(1005); 则不报错,会调用A中int参数类型沟槽方法
		System.out.println("B类的无参数构造方法！");
	}

	public B(String name){
		System.out.println("B类的有参数构造方法(String)！");
	}
}

/*判断程序执行结果：
	1
	3
	6
	5
	4

	在java语言中不管是new什么对象，最后老祖宗的Object类的无参数构造方法一定会执行（Object类的无参数构造方法是处于“栈顶部”）
	栈顶的特点：最后调用，但是最先执行结束，后进先出原则。

    建议：写代码时一个类的无参数构造方法建议大家手动写出，若无参数构造方法丢失，可能会影响到“子类对象的创建”
*/

public class SuperTest02{
	public static void main(String[] args){
		new C();
	}
}

/*
class Object{
	public Object(){
	}
}
*/

class A{
	public A(){
		super();
		System.out.println("1");
	}
}

class B extends A{
	public B(){
		// super();
		System.out.println("2");
	}
	public B(String name){
		// super();
		System.out.println("3");

	}
}

class C extends B{
	public C(){
		this("zhangsan");
		System.out.println("4");
	}
	public C(String name){
		this(name, 20);
		System.out.println("5");
	}
	public C(String name, int age){
		super(name);
		System.out.println("6");
	}
}

/*
	1、举个例子：在恰当的时间使用super(实际参数列表)
    2、注意：在构造方法过程中一连串调用了父类的构造方法，父类的构造方法又继续向下调用它的父类的构造方法，但是实际上对象只创建了一个
    3、思考：super(实参) 到底是干啥的？ ——初始化当前对象的父类特征，并非创建新对象，实际上对象只创建了一个。
    4、super关键字代表什么？ —— “当前对象”的那部分父类型特征
    eg：我继承了我父亲的一部分特征：眼睛、皮肤等，super代表的是“眼睛、皮肤等”，这些虽然是继承自父亲，但是自己身体的一部分
*/
// 测试程序
public class SuperTest03
{
    public static void main(String[] main){
        CreditAccount ca1 = new CreditAccount();
        System.out.println(ca1.getActno() + "," + ca1.getBalance() + "," + ca1.getCredit());
        CreditAccount ca2 = new CreditAccount("111", 100000.0, 0.99);
        System.out.println(ca2.getActno() + "," + ca2.getBalance() + "," + ca2.getCredit());
    }
}

// 账户
class Account {
    private String actno;	//账号
    private double balance; //余额

    public Account() {
        // 无参构造方法默认给属性赋值：actno = null; balance = 0.0;
    }

    public Account(String actno, double balance) {
        this.actno = actno;
        this.balance = balance;
    }

    public String getActno() {
        return actno;
    }

    public void setActno(String actno) {
        this.actno = actno;
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }
}

// 信用账户
class CreditAccount extends Account {
    // private String actno;
    // private double balance;
    private double credit;	// 信誉度/诚信值，子类特有的一个特征，父类没有

    public CreditAccount(String actno, double balance, double credit) {
    	// 私有的属性只能在本类中访问，子类不可访问
        // this.actno = actno;
    	// this.balance = balance;
        // 以上两行代码在恰当的位置，正好可以使用：super(actno, balance);  通过子类构造方法调用父类构造方法
        // super(); //调用父类无参构造方法，给前两个属性（actno、balance）赋默认值
        super(actno, balance);
    	this.credit = credit;
    }

    // 提供有参数的构造方法
    public CreditAccount() {

    }

    public double getCredit() {
        return credit;
    }

    public void setCredit(double credit) {
        this.credit = credit;
    }
}

SuperTest03 内存图描述super（）：