十六、Java基础之super

一、super可以用在成员方法中，不能用在静态方法中；

/*
this是一个引用
1.super不是引用类型，super中存储的不是内存地址，super指向的不是父类型对象
2.super代表的是当前子类型对象中的父类型特征
3.什么时候使用super？
    1.子类和父类中都有某个特征，例如：子类和父类中都有name属性
       如果在子类中访问父类中的name属性，需要使用super
4.super可以用在什么地方？
    第一：super可以用在成员方法中，不能用在静态方法中；
    第二：super可以用在构造方法中（this重在构造方法中为：this()）
 */

例子1：Employee   Manager   Test

//员工
public class Employee {

    String name="小明";

    //成员方法
    public void work(){
        System.out.println("员工在工作！");
    }


}

public class Manager extends Employee {
    //子类将父类中的work方法重写的
    String name="小白";
    public void work(){
        System.out.println("经理在工作！");
    }
    public void m1(){
        this.work();//经理在工作
        work();//经理在工作
        super.work();//员工在工作

        System.out.println(this.name);//小白
        System.out.println(name);//小白
        System.out.println(super.name);//小明
    }
    //this和super相同，Error:(30, 28) java: 无法从静态上下文中引用非静态 变量 super
//    public static void m2(){
//        System.out.println(super.name);
//    }
}

//测试
public class Test01 {

    public static void main(String[] args){
        Manager m=new Manager();
        m.m1();

    }
}

二、super可以用在构造方法中（this在构造方法中为：this()//构造方法不能被继承

//子类继承父类，会将父类中所有的方法继承过来，包括私有的，没办法直接访问私有的，但是可以通过get和set间接访问
/*
1.super关键字在构造方法中：
    语法：super(实参)-----this(实参)

    作用：通过子类中的构造方法去调用父类的构造方法

    语法规则：
            一个构造方法第一行执行如果没有this(...);也没有显示区调用super(...);
            系统会默认调用super()
    注意：super(...)的调用只能放在构造方法的第一个语句
         super()和this(...)不能共存
         super(...)调用了父类中的构造方法，但是并不会创建父类对象赋值
         java语言中只要是创建java对象，那么object中的无参数构造方法一定会执行，
    
 */
例子2： Account    debitAcciunt   Test

Account

public class Account {

    //Field
    private String actno;
    private double balance;

    //Constructor
    public Account(){
        System.out.println("account中的无参数构造方法执行！");
    }

    public Account(String actno,double balance){
        this.actno=actno;
        this.balance=balance;
    }
    //setter和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;
    }
}

debitAcciunt

public class debitAccount extends Account{

    //Field
    //独特属性
    private double debit;

    //Constructor
    public debitAccount(){
        //super();//调用的父类的无参数构造方法
        super("001",1000);
    }
    public debitAccount(String actno,double balance,double debit){
        //通过子类的构造方法去调用父类的构造方法，作于是：给当前子类对象中的父类型特征赋值
        super(actno,balance);
        this.debit=debit;
    }

    //setter getter

    public void setDebit(double debit){
        this.debit=debit;
    }
    public double getDebit() {
        return debit;
    }
}

Test

public class Test{

    public static void main(String[] args){

        debitAccount d=new debitAccount();
    }
}

三、单例模式的缺点

单例模式的缺点：
                1.构造方法私有化
                2.单例模式的类型无法被继承
                3.单例模式的类型没有子类，无法被继承

//编译不会通过
public class Test02 {
    //Constructor
    private Test02(){}
}

class A extends Test02{

}

//编译可通过
public class Test02 {
    //Constructor
    public Test02(){}
}

class A extends Test02{

}

public class Account {

    //Field
private String actno;
    private double balance;

    //Constructor
public Account(){
        System.out.println("account中的无参数构造方法执行！");
    }

    public Account(String actno,double balance){
        this.actno=actno;
        this.balance=balance;
    }
    //setter和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;
    }
}