super关键字

super关键字

super代表的是“当前对象（this）”的父类型特征。

super的特征

1. super是一个关键字,全部小写。

2. super和this对比着学习。

   this:
   this能出现在实例方法和构造方法中.this的语法是:"this."、"this ()"
   this不能使用在静态方法中。
   **this. ** 大部分情况下是可以省略的。
   this. 什么时候不能省略呢? 在区分局部变量和实例变量的时候不能省略
   public void setName ( string nane) {
   this.name = name ;
   }
   this()只能出现在构造方法第一行，通过当前的构造方法去调用"本类"中其它的构造方法，目的是:代码复用。
   this可以单独使用

   super:
   ​ super能出现在实例方法和构造方法中.this的语法是:"super. "、"super ()"
   ​ super不能使用在静态方法中。
   ​ super. 大部分情况下是可以省略的。
   ​ super. 什么时候不能省略呢? 父类和子类有同名属性时，你想在子类调用父类的那个属性，这个时候“super.”是不可以省略的。
   ​ super()只能出现在构造方法第一行，通过当前的构造方法去调用"父类"中其它的构造方法，目的是:在创建子类对象的时候，先初始化父类型特征。
   super不能单独使用，否则编译会报错！要么"super."要么"super()",由此可以得出，super不是引用，不存内存地址，也不指向任何对象，

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

4. 重要的结论

   当一个构造方法第一行：既没有this()有没有super()，默认会有一个super()，

   表示通过当前子类的构造方法调用父类的无参数构造方法。所以必须保证父类的无参数构造方法是存在的。

5. 注意：

   this()和super()不能共存，他们都是只能出现在构造方法第一行。

public class SuperTest01 {
    public static void main(String[] args) {

        new B();
        /*
            执行结果:
            A类的无参构造执行！！
            B类的无参构造执行！！
         */
    }
}
class A{

    public A(){
        System.out.println("A类的无参构造执行！！");
    }
}

class B extends A{

    /*
        public B(){
            //当一个构造方法第一行：既没有this()有没有super()，默认会有一个super()，用来调用父类中的无参构造
            System.out.println("B类的无参构造执行！！");
    	}
    */
    public B(){
		this(10);//先调用本类中的有参构造，然后在有参构造B()中调用super()。
         System.out.println("B类的无参构造执行！！");
    }
    public B(int i){

    }
}

super(实参)

super(实参)的作用：初始化当前对象的父类型特征。并不是创建新对象。实际上对象只创建了一个。

super关键字代表的是：“当前对象”的那部分父类型特征。

/*
    1.举例，在恰当的时间，使用super（实参列表）
    2.虽然在调用构造方法过程中一连串调用了父类的构造方法，父类的构造方法又继续向下调用它的父类的构造方法，但实际上
      只是创建了一个对象。
 */
public class SuperTest03 {
    public static void main(String[] args) {
        CreditAccount c1=new CreditAccount();
        System.out.println(c1.getAcnno() + " " + c1.getBalance() + " " + c1.getCredit());
        
        
        CreditAccount c2=new CreditAccount("111",1000.0,0.99);
        System.out.println(c2.getAcnno() + " " + c2.getBalance() + " " + c2.getCredit());

    }
}
//普通账户类
class Account {//父类,默认继承Object，Object是所有类的祖宗
    //账号
    private String acnno;
    //余额
    private double balance;
    //无参构造
    public Account(){

    }
    //有参构造
    public Account(String acnno, double balance) {
        this.acnno = acnno;
        this.balance = balance;
    }
    //setter and getter 方法
    public String getAcnno() {
        return acnno;
    }

    public void setAcnno(String acnno) {
        this.acnno = acnno;
    }

    public double getBalance() {
        return balance;
    }

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

class CreditAccount extends Account {//子类继承父类 ，父类中的所有属性、方法（构造方法除外）都传递到了子类中
    //信誉度
    private double credit;
    //无参
    public CreditAccount(){

    }
    //有参
    public CreditAccount(String acnno, double balance, double credit) {
        /*这样写不太好
            this.setAcnno(acnno);
            this.setBalance(balance);
         */
        super(acnno, balance);
        this.credit = credit;
    }

    //setter and getter 方法
    public double getCredit() {
        return credit;
    }

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

}

super继承的内存图

什么时候是"super."不能省略

​ 父类和子类有同名属性时，你想在子类调用父类的那个属性，这个时候“super.”是不可以省略的。
​ 在父和子中有同名的属性,或者说有相同的方法，
​ 如果此时想在子类中访问父中的数据，必须使用"super."加以区分。l
​ super.属性名.【访问父类的属性】
​ super.方法名〈实参)【访问父类的方法】
​ super(实参)【调用父类的构造方法】

public class SuperTest04 {
    public static void main(String[] args) {

        Vip vip=new Vip("张三");
        vip.shopping();
        vip.dosome();
    }
}

class Customer{
    String name;

    public Customer(){

    }

    public Customer(String name) {
        this.name = name;
    }

    public void dosome(){
        System.out.println(this.name+"do smoe");//张三do smoe
    }
}

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.nane:当前对象的父类型特征中的nane属性。
         */
        System.out.println(this.name+"正在购物！");//null正在购物！
        System.out.println(super.name+"正在购物！");//张三正在购物！
        System.out.println(name+"正在购物！");//null正在购物！
    }
}