java继承

先看如下代码：

package com.company;

public class init_java {
    public static  void  main(String[] args){
        Employee man=new Manager("tom",22,23000,20000);
        Manager man1=new Manager("tom",22,23000,20000);
        System.out.println(man.getSalary());
//        System.out.println(man.giveMon());
        System.out.println(man1.giveMon());
    }


}


class Employee{
    private int  age;
    private String name;
    private  double salary;
    private String alaname;
    public Employee(String aname,int aage,double asalary){
        this("evil");
        this.age=aage;
        this.salary=asalary;
        this.name=aname;
    }
    public Employee(String aname){
        this.alaname=aname;
    }
    public String getName(){
        System.out.println(this.name);
        return this.name;
    }
    public double getSalary(){
        return this.salary;
    };
    public String getAlaname(){
        return this.alaname;
    }
}


class Manager extends Employee{
    private double mon;
    public Manager(String aname,int aage,double asalary,double mon){
        super(aname,aage,asalary);
        this.mon=mon;
    }
    public double giveMon(){
        double salary= super.getSalary();
        salary+=this.mon;
        return salary;
    }
}

 结果输出：

继承：

语法：   class  A extends  B{}   A继承B。java中只能单继承，和python不一样，python可以多继承。

java的多态：

A继承B，B属于超类、父类 A是子类和孩子类，关系是一对一对说，比如说超类和子类而不是超类和孩子类。

子类A的对象类型是超类B的类型一样，也就是说子类A的对象类型既是超类B的类型也A类型，也就是说子类A的对象继承超类的B的方法和属性。

但是超类B的对象却不是子类B的类型，也就是说超类B的对象不能调用子类A的方法。

他们之间关系是"is a"，就是说A是B的对象。

构造器执行顺序：

    如果子类A没有显示执行超类B的构造器的话，会自动执行超类B的没有带参数的构造器，如果超类B没有不带参数的构造器话，执行的时候会报错。

package com.company;

public class init_java {
    public static  void  main(String[] args){
//        Employee man=new Manager("tom",22,23000,20000);
        Manager man1=new Manager(20000);
//        System.out.println(man.getSalary());
//        System.out.println(man.giveMon());
        System.out.println(man1.giveMon());
    }


}

class Manager extends Employee{
    private double mon;
    public Manager(double mon){
//        super(aname,aage,asalary);
        this.mon=mon;
    }
    public double giveMon(){
        double salary= super.getSalary();
        salary+=this.mon;
        return salary;
    }
}

class Employee{
    private int  age;
    private String name;
    private  double salary;
    private String alaname;
    public Employee(String aname,int aage,double asalary){
        this("evil");
        this.age=aage;
        this.salary=asalary;
        this.name=aname;
    }
    public Employee(String aname){
        this.alaname=aname;
    }
    public String getName(){
        System.out.println(this.name);
        return this.name;
    }
    public double getSalary(){
        return this.salary;
    };
    public String getAlaname(){
        return this.alaname;
    }
}

 直接抛出来，没有找到合适的构造器。

我们修改超类的构造器，变成无参数的构造器。或者去掉构造器。

package com.company;

public class init_java {
    public static  void  main(String[] args){
//        Employee man=new Manager("tom",22,23000,20000);
        Manager man1=new Manager(20000);
//        System.out.println(man.getSalary());
//        System.out.println(man.giveMon());
//        System.out.println(man1.giveMon());
    }


}

class Manager extends Employee{
    private double mon;
    public Manager(double mon){
//        super(aname,aage,asalary);
        this.mon=mon;
    }
//    public double giveMon(){
//        double salary= super.getSalary();
//        salary+=this.mon;
//        return salary;
//    }
}

class Employee{
//    private int  age=22;
//    private String name="tom";
//    private  double salary=20000;
//    private String alaname="evil";
    public Employee(){
        System.out.println("ok");
    }
//    public Employee(String aname){
//        this.alaname=aname;
//    }
//    public String getName(){
//        System.out.println(this.name);
//        return this.name;
//    }
//    public double getSalary(){
//        return this.salary;
//    };
//    public String getAlaname(){
//        return this.alaname;
//    }

}

 输出结果：

显示调用：super(参数1,参数2.......)表示调用超类中的相应的参数类型的构造器。这句必须放在子类的构造器的第一句，才能生效！！

同里想调用超类的方法用super.method形式！

子类覆盖父类的方法：

方法的签名：

方法的名字和方法的参数列表叫做方法的签名。子类将相同的方法签名将覆盖超类的相应的方法。但是为了保持数据类型的兼容性，需要声明返回类型为子类的类型。

 注意：

      如上Manager 继承了Employee，Manager 对象也是Employee对象，如果将Manager 对象声明为employee对象的时候，Manager 对象无法调用自己的方法。

package com.company;

public class init_java {
    public static  void  main(String[] args){
        Employee man=new Manager("tom",20000,22,"evil",3000);
        double mon=man.giveMon();
        System.out.println(mon);
    }


}

class Manager extends Employee{
    private double mon;
    public Manager(String aname,double asalary,int age,String alaname,double mon){
        super(aname,asalary,age,alaname);
        this.mon=mon;
    }
    public double giveMon(){
        double salary=super.getSalary();
        salary+=this.mon;
        return salary;
    }
}

class Employee{
    private int  age=22;
    private String name="tom";
    private  double salary=20000;
    private String alaname="evil";
    public Employee(String aname,double asalary,int age,String alaname){
        this.age=age;
        this.name=aname;
        this.salary=asalary;
        this.alaname=alaname;
    }
    public Employee(String aname){
        this.alaname=aname;
    }
    public String getName(){
        System.out.println(this.name);
        return this.name;
    }
    public double getSalary(){
        return this.salary;
    };
    public String getAlaname(){
        return this.alaname;
    }

}

 直接抛出错误：

虽然你使用的Manager的构造器构造对象，但是你声明的对象的为employee类型，而不是Manager类型。所以在执行方法，jvm会找employee的方法表，找giveMon方法。显然没有。

所以改成Manager类型就可以执行。

多态属性：

如上面代码的Manager man=new Manager("tom",20000,22,"evil",3000);中的man对象变量，虽然声明为Manger类型对象，但是我们的在调用的方法的时候，不仅可以调用他本身类Manager的方法，也可以调用超类的方法，而无需声明

对象变量man为超类的类型。这种形式叫做多态属性，通过继承，子类对象在调用方法的时候，会根据自身的方法表和超类的方法表，由调用方法的签名（名字和参数列表），通过自身和超类的方法表来动态确认自己的调用的方法。

我们叫做动态绑定。

 子类在调用方法的执行过程如下：

执行方法x.f(param)的时候，分以下步骤执行：

1、编译器查看对象的声明类型和对象。

2、编译器查看调用方法的参数类型。

3、如果是被private、static、final方法或者构造器，编译器可以准确知道调用的是哪个方法。

4、当执行方法的时候，并且采用动态绑定方法的时候，会根据方法的实际类型，所对应的合适的方法。从子类到超类一次查找。

查找的过程需要查看多个类，java是怎么解决这个开销呢？在实际中，每个类中对有本类型的方法表（method table），每次查找的时候，通过查找方法表，来提高效率和减少开销。

 多态：

1、无论是接口、普通类、抽象类都是声明父类的类型 调用子类的方法，来实现多态！！