Java继承详解

继承

1.类、超类和子类

1.1定义子类

有2个类，继承Employee类来定义Manager类，这里使用关键字extends 表示继承

public class Manager extends Employee{
    //add method and fields
}

关键字extends表明正在构造的新类派生于一个已存在的类

• 已存在的类称为超类、基类或父类
• 新类称为子类、派生类或孩子类

1.2覆盖方法

父类有些方法对子类不一定适用，就需要提供一个新的方法来覆盖父类中的那个方法

public class Manager extends Employee{
    ...
    public double getSalary(){//重写父类方法
        ...
    }
    ...
}

因为在子类重写父类的方法，方法名相同，所以在子类要调用父类的getSalary()方法，就需要用关键字super解决这个问题

super.getSalary();

准确的写法3

public double getSalary(){//重写父类方法
    						//通过super.getSalary()来在子类中调用父类的方法
       double baseSalary = super.getSalary();
       return baseSalary + bouns;
    }

super的用法

可以访问下面网页进行学习:

[(https://www.cnblogs.com/GDDG123/p/15123532.html)]:

1.3 子类构造器

在例子中**(完整代码在最后)**，我们提供了一个构造器

public Manager(String name, double salary, int year, int month, int day) {
        super(name, salary, year, month, day);//调用父类含有相同参数的构造器
        bonus = 0;
    }

这里的super具有不同的含义。语句

super(name, salary, year, month, day);

是“调用父类Employee中带有name,salary,year,month,day参数的构造器”的简写

1.使用super调用构造器的语句必须是子类的第一条语句

2.如果子类的构造器没有显示地调用父类的构造器，即将自动地调用父类的无参数构造器

3.如果父类没有无参数的构造器，并且在子类的构造器中又没有显示地调用父类的其他构造器，Java编译器就会报告一个错误

• 关键字this有2个含义：1.指示隐式参数的引用，2.调用该类的其他构造器
• 关键字super也有2个含义：1.调用父类的方法，2.调用父类的构造器

ManagerTest.java

package com.book.company;

public class ManagerTest {
    public static void main(String[] args)
    {
        // construct a Manager object
        Manager boss = new Manager("Carl Cracker", 80000, 1987, 12, 15);
        boss.setBonus(5000);

        Employee staff[] = new Employee[3];

        // fill the staff array with Manager and Employee objects

        staff[0] = boss;
        staff[1] = new Employee("Harry Hacker", 50000, 1989, 10, 1);
        staff[2] = new Employee("Tommy Tester", 40000, 1990, 3, 15);

        // print out information about all Employee objects
        for (Employee e : staff) {
            System.out.println("name=" + e.getName() + ",salary=" + e.getSalary());
        }
    }
}

Manager.java

package com.book.company;

public class Manager extends Employee{
    //add method and fields
    private double bonus;

    public Manager(String name, double salary, int year, int month, int day) {
        super(name, salary, year, month, day);
        bonus = 0;
    }

    @Override
    public double getSalary() {
        double baseSalary = super.getSalary();
        return baseSalary+bonus;

    }

    public void setBonus(double b){
        bonus = b;
    }
}

Employee.java

package com.book.company;

import java.time.LocalDate;

public class Employee {
    private String name;
    private double salary;
    private LocalDate hireDay;


    public Employee(String name, double salary, int year, int month, int day)
    {
        this.name = name;
        this.salary = salary;
        hireDay = LocalDate.of(year, month, day);
    }

    public String getName()
    {
        return name;
    }

    public double getSalary()
    {
        return salary;
    }

    public LocalDate getHireDay()
    {
        return hireDay;
    }

    public void raiseSalary(double byPercent)
    {
        double raise = salary * byPercent / 100;
        salary += raise;
    }
}

1.4多态

"is-a"规则，它指出子类的每个对象也是父类的对象。

"is-a"规则的另一种表述是替换原则，它指出程序中出现父类对象的任何地方都可以使用子类对象替换

例如：

Employee e;
e = new Employee(...);//Employee object expected
e = new Manager(...);//OK,Manager can be used as well

在Java中，对象变量是多态的，一个Employee类类型的变量既可以引用一个Employee类型的对象，也可以引用Employee类的任何一个子类的对象(例如：Manager，Executive,Secretary)

**注意：**在Java中，子类引用的数组可以转换成父类引用的数组，而不用使用强制类型转换，如：下面是一个经理数组

Manager[] managers = new Managers[10];

将它转换成Employee[]数组完全是合法的

Employee[] staff = managers;

1.4.1多态概念

1.多态体现为父类引用变量可以指向子类对象。

注意：在使用多态后的父类引用变量调用方法时，会调用子类重写后的方法

2.多态的定义与使用格式

​ 定义格式：父类类型 变量名=new 子类类型();

3.理解:

​ 多态是同一个行为具有多个不同表现形式或形态的能力。

​ 多态就是同一个接口，使用不同的实例而执行不同操作。

1.4.2多态成员的特点

1. 多态成员变量：编译运行看左边

Fu f = new Zi();
System.out.println(f.num);//f是Fu中的值，只能取到父中的值

2. 多态成员方法：编译看左边，运行看右边

Fu f1=new Zi();
System.out.println(f1.show());//f1的门面类型是Fu,但实际类型是Zi,所以调用的是重写后的方法。

1.4.3.instanceof关键字

作用：用来判断某个对象是否属于某种数据类型。

• 注意： 返回类型为布尔类型

  使用案例：

Fu f1=new Zi();
Fu f2=new Son();
if(f1 instanceof Zi){
    System.out.println("f1是Zi的类型");
}
else{
    System.out.println("f1是Son的类型");
}