第十三章 super关键字

1. super基础语法

1.1 super与this的异同点

this:
this能出现在实例方法和构造方法中。
this的语法是：“this.”、“this()”
this不能使用在静态方法中。
this. 大部分情况下是可以省略的。
this.什么时候不能省略呢？ 在区分局部变量和实例变量的时候不能省略。
this()
只能出现在构造方法第一行，通过当前的构造方法去调用“本类”中其它的构造方法，目的是：代码复用。

  1.           super:<br />      super能出现在实例方法和构造方法中。<br />      super的语法是：“super.”、“super()”<br />      super不能使用在静态方法中。<br />      super. 大部分情况下是可以省略的。<br />      super.什么时候不能省略呢？？？（后面会进一步讲解）<br />            super() <br />只能出现在构造方法第一行，通过当前的构造方法去调用“父类”中的构造方法，目的是：创建子类对象的时候，先初始化父类型特征。

1、当一个构造方法第一行： 既没有this()又没有super()的话，默认会有一个super(); 表示通过当前子类的构造方法调用父类的无参数构造方法。所以必须保证父类的无参数构造方法是存在的。 2、this()和super() 不能共存，它们都是只能出现在构造方法第一行。 3、无论是怎样折腾，父类的构造方法是一定会执行的。 4、在java语言中不管是是new什么对象，最后老祖宗的Object类的无参数构造方法一定会执行。（Object类的无参数构造方法是处于“栈顶部”） 5、写代码的时候，一个类的无参数构造方法还是建议大家手动的写出来；如果无参数构造方法丢失的话，可能会影响到“子类对象的构建”。

1.2 super()的使用

  1. public class SuperTest03{
  2.     public static void main(String[] args){
  4.         CreditAccount ca1 = new CreditAccount();
  5.         System.out.println(ca1.getActno() + "," + ca1.getBalance() + "," + ca1.getCredit());
  7.         CreditAccount ca2 = new CreditAccount("1111", 10000.0, 0.999);
  8.         System.out.println(ca2.getActno() + "," + ca2.getBalance() + "," + ca2.getCredit());
  10.     }
  11. }
  13. // 账户
  14. class Account extends Object{
  15.     // 属性
  16.     private String actno;
  17.     private double balance;
  19.     // 构造方法
  20.     public Account(){
  21.         //super();
  22.         //this.actno = null;
  23.         //this.balance = 0.0;
  24.     }
  25.     public Account(String actno, double balance){
  26.         // super();
  27.         this.actno = actno;
  28.         this.balance = balance;
  29.     }
  31.     // setter and getter
  32.     public void setActno(String actno){
  33.         this.actno = actno;
  34.     }
  35.     public String getActno(){
  36.         return actno;
  37.     }
  38.     public void setBalance(double balance){
  39.         this.balance = balance;
  40.     }
  41.     public double getBalance(){
  42.         return balance;
  43.     }
  44. }
  46. // 信用账户
  47. class CreditAccount extends Account{
  49.     // 属性：信誉度（诚信值）
  50.     // 子类特有的一个特征，父类没有。
  51.     private double credit;
  53.     // 构造方法
  54.     // 分析以下程序是否存在编译错误？？？？
  55.     public CreditAccount(String actno, double balance, double credit){
  57.         // 私有的属性，只能在本类中访问。
  58.         /*
  59.         this.actno = actno;
  60.         this.balance = balance;
  61.         */
  63.         // 以上两行代码在恰当的位置，正好可以使用：super(actno, balance);
  64.         // 通过子类的构造方法调用父类的构造方法。
  65.         super(actno, balance);
  66.         this.credit = credit;
  67.     }
  69.     // 提供有参数的构造方法
  70.     public CreditAccount(){
  71.         //super();
  72.         //this.credit = 0.0;
  73.     }
  75.     // setter and getter方法
  76.     public void setCredit(double credit){
  77.         this.credit = credit;
  78.     }
  79.     public double getCredit(){
  80.         return credit;
  81.     }
  83. }

注意：
在构造方法执行过程中一连串调用了父类的构造方法，父类的构造方法又继续向下调用它的父类的构造方法，但是实际上对象只创建了一个。（super关键字代表的就是“当前对象”的那部分父类型特征。）

1.3 super. 什么时候不能省略

“this.”和“super.”大部分情况下都是可以省略的。
this. 什么时候不能省略？

  1. public void setName(String name){
  2.     //当要区分局部变量和实例变量时
  3.     this.name = name;
  4. }
  1.                super. 什么时候不能省略？<br />父中有，子中又有（即**父类与子类有同名变量**），如果想在子中访问“父的特征”，super. 不能省略。

1.4 super.的一些疑问

  1. public class SuperTest06 {
  3.     // 实例方法
  4.     public void doSome(){
  5.         // SuperTest06@2f92e0f4
  6.         System.out.println(this);
  7.         // 输出“引用”的时候，会自动调用引用的toString()方法。
  8.         //System.out.println(this.toString());
  10.         //编译错误: 需要'.'
  11.         //System.out.println(super);
  12.     }
  14.     // this和super不能使用在static静态方法中。
  15.     /*
  16.     public static void doOther(){
  17.         System.out.println(this);
  18.         System.out.println(super.xxx);
  19.     }
  20.     */
  22.     // 静态方法，主方法
  23.     public static void main(String[] args){
  24.         SuperTest06 st = new SuperTest06();
  25.         st.doSome();
  27.         // main方法是静态的
  28.         // 错误的。
  29.         /*
  30.         System.out.println(this);
  31.         System.out.println(super.xxxx);
  32.         */
  33.     }
  34. }

1.5 在父和子中有同名的属性或方法

  1. 如果此时想在子类中访问父中的数据，必须使用“super.”加以区分。<br />    super.属性名            【访问父类的属性】<br />    super.方法名(实参)           【访问父类的方法】<br />    super(实参)                      【调用父类的构造方法】