super

14.1.  super 基本概念

• super是一个关键字，全部小写。
• super和this对比着学习。

1. 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.什么时候不能省略呢？ ？？？？？？？

• super() 只能出现在构造方法第一行，通过当前的构造方法去调用“父类”中的构造方法，目的是：创建子类对象的时候，先初始化父类型特征。

• super()：表示通过子类的构造方法调用父类的无参构造方法。

• 模拟现实世界中的这种场景：要想有儿子，需要先有父亲。
• 重要的结论：

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

• 注意：this()和super() 不能共存，它们都是只能出现在构造方法第一行。
• 无论是怎样折腾，父类的构造方法是一定会执行的。（百分百的。）

2.super注意事项：

• super能出现在实例方法和构造方法中。
• super的语法是：“super.”、“super()”
• super不能使用在静态方法中。
• super. 大部分情况下是可以省略的。
• super.什么时候不能省略呢？
  父类和子类中有同名属性，或者说有同样的方法，想在子类中访问父类的，super. 不能省略。
• super() 只能出现在构造方法第一行，通过当前的构造方法去调用“父类”中的构造方法，目的是：
  创建子类对象的时候，先初始化父类型特征。
• super的使用：
  super.属性名                         【 访问父类的属性】
  super.方法名(实参)               【访问父类的非私有方法】
  super(实参)                           【调用父类的构造方法】

3. 判断程序的输出结果:

public class SuperTest02{

public static void main(String[] args){

new C();

}

}

/*

class Object{

public Object(){

}

}

*/

class A extends Object{

public A(){

System.out.println("1"); //1

}

}

class B extends A{

public B(){

System.out.println("2"); //2

}

public B(String name){

super();

System.out.println("3"); // 3

}

}

class C extends B{

public C(){ // 这个是最先调用的。但是最后结束。

this("zhangsan");

System.out.println("4");//4

}

public C(String name){

this(name, 20);

System.out.println("5");//5

}

public C(String name, int age){

super(name);

System.out.println("6");//6

}

}

//结果： 1 3 6 5 4

程序分析：

在java语言中不管是是new什么对象，最后老祖宗的Object类的无参数构造方法一定会执

行。（Object类的无参数构造方法是处于“栈顶部”）**

栈顶的特点：最后调用，但是最先执行结束。后进先出原则。

大家要注意：

以后写代码的时候，一个类的无参数构造方法还是建议大家手动的写出来。如果无参数构造方法丢失的话，可能会影响到“子类对象的构建”

14.2.  super(实际参数列表)

1. 注意：在构造方法执行过程中一连串调用了父类的构造方法，父类的构造方法又继续向下调用它的
   父类的构造方法，但是实际上对象只创建了一个。

2. 思考：“super(实参)”到底是干啥的？
   super(实参)的作用是：初始化当前对象的父类型特征。

并不是创建新对象。实际上对象只创建了1个。

3. super关键字代表什么呀？
super关键字代表的就是“当前对象”的那部分父类型特征。

4. 测试程序

public class SuperTest03{

   public static void main(String[] args){

       CreditAccount ca1 = new CreditAccount();

       System.out.println(ca1.getActno() + "," + ca1.getBalance() +","+ca1.getCredit());

       CreditAccount ca2 = new CreditAccount("1111", 10000.0, 0.999);

       System.out.println(ca2.getActno() + "," + ca2.getBalance() +","+ca2.getCredit());

   }

}

}

// 账户

class Account extends Object{

// 属性

private String actno;

private double balance;

// 构造方法

public Account(){

//super();

//this.actno = null;

//this.balance = 0.0;

}

public Account(String actno, double balance){

// super();

this.actno = actno;

this.balance = balance;

}

// setter and getter

public void setActno(String actno){

this.actno = actno;

}

public String getActno(){

return actno;

}

public void setBalance(double balance){

this.balance = balance;

}

public double getBalance(){

return balance;

}

}

// 信用账户

class CreditAccount extends Account{

// 属性：信誉度（诚信值）

// 子类特有的一个特征，父类没有。

private double credit;

// 构造方法

// 分析以下程序是否存在编译错误？？？？

public CreditAccount(String actno, double balance, double credit){

// 私有的属性，只能在本类中访问。

/*

this.actno = actno;

this.balance = balance;

*/

// 以上两行代码在恰当的位置，正好可以使用：super(actno, balance);

// 通过子类的构造方法调用父类的构造方法。

super(actno, balance);

this.credit = credit;

}

// 提供有参数的构造方法

public CreditAccount(){

//super();

//this.credit = 0.0;

}

// setter and getter方法

public void setCredit(double credit){

this.credit = credit;

}

public double getCredit(){

return credit;

}

}

• 以上代码的内存图

5. 以上代码的super原理内存图：

14.3.  super和this的关系

1. super表示的是当前对象的父类型特征。（super是this指向的那个对象中的一块空间。）
2. 参考代码如下：

public class SuperTest04{

public static void main(String[] args){

Vip v = new Vip("张三");

v.shopping();

}

}

class Customer{

String name;

public Customer(){}

public Customer(String name){

super();

this.name = name;

}

}

class Vip extends Customer{

public Vip(){}

public Vip(String name){

super(name);

}

// super和this都不能出现在静态方法中。

public void shopping(){

// this表示当前对象。

System.out.println(this.name + "正在购物!");

// super表示的是当前对象的父类型特征。（super是this指向的那个对象中的一块空

间。）

System.out.println(super.name + "正在购物!");

System.out.println(name + "正在购物!");

}

}

14.4.  super.不能省略的情况

1. “this.”和“super.”大部分情况下都是可以省略的。

2. this. 什么时候不能省略？
   public void setName(String name){
   this.name = name;
   }

3. super. 什么时候不能省略？
   父中有，子中又有，如果想在子中访问“父的特征”，super. 不能省略。

4. java中允许在子类中出现和父类一样的同名变量/同名属性。

5. java是怎么来区分子类和父类的同名属性的？
   this.name：当前对象的name属性
   super.name：当前对象的父类型特征中的name属性。

6. 源码如下

public class SuperTest05{

public static void main(String[] args){

Vip v = new Vip("张三");

v.shopping();

}

}

class Customer {

String name;

public Customer(){}

public Customer(String name){

super();

this.name = name;

}

public void doSome(){

System.out.println(this.name + " do some!");

System.out.println(name + " do some!");

//错误: 找不到符号

//System.out.println(super.name + " do some!");

}

}

class Vip extends Customer{

// 假设子类也有一个同名属性

// java中允许在子类中出现和父类一样的同名变量/同名属性。

String name; // 实例变量

public Vip(){

}

public Vip(String name){

super(name);

// this.name = null;

}

public void shopping(){

/*

java是怎么来区分子类和父类的同名属性的？

this.name：当前对象的name属性

super.name：当前对象的父类型特征中的name属性。

*/

System.out.println(this.name + "正在购物!"); // null 正在购物

System.out.println(super.name + "正在购物!"); // 张三正在购物

System.out.println(name + "正在购物!"); //null 正在购物

}

}

• 程序内存图


14.5.  super 基本概念(二)

• 通过已下测试得出的结论：

• super 不是引用，super也不保存内存地址，super也不指向任何对象。

• super 只是代表当前对象内部的那一块父类型的特征。

• 关键字super的作用：

• 用来访问父类被隐藏的非私有成员变量
• 用来调用父类中被重写的方法
• 用来调用父类的构造函数

public class SuperTest06 {

// 实例方法

public void doSome(){

// SuperTest06@2f92e0f4

System.out.println(this);

// 输出“引用”的时候，会自动调用引用的toString()方法。

//System.out.println(this.toString());

//编译错误: 需要'

.

'

//System.out.println(super);

}

// this和super不能使用在static静态方法中。

/*

public static void doOther(){

System.out.println(this);

System.out.println(super.xxx);

}

*/

// 静态方法，主方法

public static void main(String[] args){

SuperTest06 st = new SuperTest06();

st.doSome();

// main方法是静态的

// 错误的。

/*

System.out.println(this);

System.out.println(super.xxxx);

*/

}

}

• 在父和子中有同名的属性，或者说有相同的方法，如果此时想在子类中访问父中的数据，必须使用
  “super.”加以区分。
• super.属性名                      【访问父类的属性】
  super.方法名(实参)              【访问父类的方法】
  super(实参)                         【调用父类的构造方法】
• 参考代码如下：

public class SuperTest07{

public static void main(String[] args){

   /*

   Cat move!

   Cat move!

   Animal move!

   */

   Cat c = new Cat();

   c.yiDong();

}

}

class Animal{

public void move(){

System.out.println("Animal move!");

}

}

class Cat extends Animal{

// 对move进行重写。

public void move(){

System.out.println("Cat move!");

}

// 单独编写一个子类特有的方法。

public void yiDong(){

this.move();

move();

// super. 不仅可以访问属性，也可以访问方法。

super.move();

}

}