面向对象之继承，多态

类与类之间的三种关系
类与类之间有三种关系
is a:继承关系，例如：公共汽车is a汽车
use a:使用关系，例如：人 use a 钳子
has a：包含关系，例如：人has a 胳膊

继承的好处

继承的出现提高了代码的复用性，提高软件开发的效率
继承的出现让类与类之间产生了关系，提供了多态的前提

继承的定义格式

在程序中，如果想申明一个类继承另一个类，需要使用extends关键字

class 子类 extends 父类 {
    
}

使用继承

案例：公司有2个部门，人事部和研发部，各自属性如下

定义人事部类

public class PersonalDepartment {
    private int ID;// 部门编号
    private String name = "待定";// 部门名称
    private int amount = 0;// 部门人数
    private String responsibility = "待定";// 部门职责
    private String manager = "无名氏";// 部门经理
    private int count;//招聘人数

    public PersonalDepartment() {
    }

    public PersonalDepartment(int ID, String name, int amount, String responsibility, String manager, int count) {
        this.ID = ID;
        this.name = name;
        this.amount = amount;
        this.responsibility = responsibility;
        this.manager = manager;
        this.count = count;
    }

定义研发部

/**
 * 研发部
 */
public class ResourceDepartment {
    private int ID;// 部门编号
    private String name = "待定";// 部门名称
    private int amount = 0;// 部门人数
    private String responsibility = "待定";// 部门职责
    private String manager = "无名氏";// 部门经理
    private String speciality =null;//研发方向

    public ResourceDepartment() {
    }

    public ResourceDepartment(int ID, String name, int amount, String responsibility, String manager, String speciality) {
        this.ID = ID;
        this.name = name;
        this.amount = amount;
        this.responsibility = responsibility;
        this.manager = manager;
        this.speciality = speciality;
    }
    ......

问题：两个类中的属性有相同的部分，代码冗余。解决办法是将两个部门共性的属性抽取出来，放在父类中，然后让两个部门继承父类。

定义父类:两个部门共性的属性抽取到父类中

/** 部门父类：存放所有子类共性的内容 */public class Deparment {    private int ID;// 部门编号    private String name = "待定";// 部门名称    private int amount = 0;// 部门人数    private String responsibility = "待定";// 部门职责    private String manager = "无名氏";// 部门经理

子类修改如下：

1. 共性的属性删除
1. 共性属性的get和set方法删除
1. 构造方法做调整

/**
 * 人事部
 */
public class PersonalDepartment {
    private int count;//招聘人数

    public PersonalDepartment() {
    }

    public PersonalDepartment(int count) {
        
        this.count = count;
    }

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }
}

/**
 * 研发部
 */
public class ResourceDepartment {

    private String speciality =null;//研发方向

    public ResourceDepartment() {
    }

    public ResourceDepartment(String speciality) {
        this.speciality = speciality;
    }

    public String getSpeciality() {
        return speciality;
    }

    public void setSpeciality(String speciality) {
        this.speciality = speciality;
    }
}

让人事部和研发部继承部门的父类

使用extends Deparment继承部门类

人事部

public class PersonalDepartment extends Deparment{
    private int count;//招聘人数

    public PersonalDepartment() {
    }

    public PersonalDepartment(int count) {

        this.count = count;
    }

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }
}
* 使用extends Deparment继承部门类
/**
 * 研发部
 */
public class ResourceDepartment extends Deparment{

    private String speciality =null;//研发方向

    public ResourceDepartment() {
    }

    public ResourceDepartment(String speciality) {
        this.speciality = speciality;
    }

    public String getSpeciality() {
        return speciality;
    }

    public void setSpeciality(String speciality) {
        this.speciality = speciality;
    }
}

验证子类是否真的从父类继承了数据

验证方法：

创建人事部和研发部的对象，如果能够调用出父类的方法，证明继承了

创建一个公司类，测试一下：

/**
 * 公司类
 */
public class Company {
    public static void main(String[] args) {
        //创建人事部对象
        PersonalDepartment personalDepartment = new PersonalDepartment();
        //创建研发部对象
        ResourceDepartment resourceDepartment = new ResourceDepartment();
        //调用父类的方法
        System.out.println(personalDepartment.getName()); //getName()是父类的
        System.out.println(resourceDepartment.getName()); //getName()是父类的
    }
}

如上：

实现代码复用
父类可以控制子类能继承什么，通过封装控制
注意：对象的属性可以通过方法赋值

创建子类对象时的运行规则

第一个方面：构造函数的调用顺序问题
1. new子类时，首先调用子类构造函数，但是不执行子类构造函数
2. 子类构造函数被调用后立即调用父类的构造函数。
第二个方面：属性初始化顺序的问题
1. 从Object类开始初始化
2. 然后依次从父到子的顺序初始化（哪个类定义的属性，就由哪个类负责初始化）
  子类通过关键字super()调用父类的构造函数
super()必须放在子类构造函数的第一行代码

继承的注意事项

类只支持单继承，不允许多继承

class A{} 
class B{}
class C extends A,B{}  // C类不可以同时继承A类和B类

多个类可以继承一个父类

class A{}
class B extends A{}
class C extends A{}   // 类B和类C都可以继承类A

允许多层继承

class A{}
class B extends A{}   // 类B继承类A，类B是类A的子类
class C extends B{}   // 类C继承类B，类C是类B的子类，同时也是类A的子类

子类和父类是一种相对概念

也就是说一个类是某个类父类的同时，也可以是另一个类的子类。例如上面的这种情况中，B类是A类的子类，同时又是C类的父类。

继承的体系之 Object类

Object是所有类的父类
如果一个类没有显示定义父类，那么默认继承Object类
Object类中没有定义属性，但是定义了12个方法，并且这些方法都是实例方法。因此每个对象都拥有这14个方法。

继承过程分析(父子类的实例话顺序)
当new子类时，父类也new了

执行：从父到子

调用：从子到父

哪个类定义的属性，就由哪个类赋值初始化，对于父类来说，初始化的数据是由子类通过super(数据)传入给父类的

继承后子类的成员的变化

    了解了继承给我们带来的好处，提高了代码的复用性。继承让类与类或者说对象与对象之间产生了关系。那么，当继承出现后，类的成员之间产生了那些变化呢？

    子类中的成员包括

子类自己定义的属性和方法
从父类继承的属性和方法
子类不能使用从父类继承的私有成员，因为被封装了。

this和super

继承中的this（调用子类成员）

this可以调用子类成员
this可以调用子类重载的构造函数，必须是子类构造函数的第一行

继承中的super（调用父类成员）

super调用父类成员
super调用父类构造函数，必须是子类构造函数的第一行

this和super

this代表自己，this可以调用

自己的属性和方法
在奔类的构造函数内调用其他构造函数

super代表父类，super可以调用

父类的属性和方法
在子类构造中调用父类构造

this和static

this表示实例

static表示静态

static不能调实例

对象名可以调用static，但是this确不能调用static

方法重写(override)

如果子类从父类继承的方法不能满足子类的需要，或者不适合子类的需要。

此时子类可以将从父类继承的方法重写定义成满足自己需要的方法。

重新定义称为重写。

class Pet {//宠物
    public void sound(){
        System.out.println("宠物叫");
    }
}
class Dog extends Pet {//狗

    //方法重写
    @Override
    public void sound() {
        System.out.println("汪汪汪");
    }
}
class Cat extends Pet{//猫
    //方法重写
    @Override
    public void sound(){
        System.out.println("喵喵喵");
    }
}

public class PetShop{//宠物店
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.sound();//调用狗的sound()
        Cat cat = new Cat();
        cat.sound();//调用猫的sound()
    }
}

注意事项

在子类中将父类的方法再重新定义一遍
方法重写时，方法的发返回值类型，方法名参数列表都要与父类一样。
*子类方法覆盖父类方法，必须要保证权限大于等于父类权限

class Fu{   
    void show(){}
    public void method(){}
}
class Zi extends Fu{
    public void show(){}  //扩大show的访问权限，编译运行没问题
    void method(){}       //缩小method的访问权限，编译错误
}

方法重写时，子类不能缩小父类抛出的异常。

class Pet {//宠物
    public void sound() throws RuntimeException{
        System.out.println("宠物叫");
        
    }
}
class Cat extends Pet{//猫
    //方法重写
    public void sound() throws Exception{//错误，因为Exception 小于 RuntimeException
        System.out.println("喵喵喵");
    }
}

方法重载与方法重写的区别

方法重载：
1.在同一类中(包括从父类继承的）方法同名不同参与返回值无关
*方法重写：
1.方法重写存在于继承关系中
2.父子类之间的方法同名，同参，同返回
里氏替换原则(父类引用指向子类实例）
实现：
设计宠物类，猫类，狗类，让猫和狗继承宠物类
在宠物类中定义sound方法，表示宠物的叫声，但是叫声不能由具体的行为。
猫和狗重写父类的sound方法，以实现具体的叫声

class Pet {//宠物
    public void sound() throws RuntimeException{

    }
}
class Dog extends Pet {//狗

    //方法重写
    @Override
    public void sound() {
        System.out.println("汪汪汪");
    }
}
class Cat extends Pet{//猫
    //方法重写
    @Override
    public void sound() throws RuntimeException{
        System.out.println("喵喵喵");
    }
}

实现：购买宠物要求宠物叫一声，以此判断是否买它代码如下：

public class PetShop{//宠物店
    public static void main(String[] args) {
        Pet pet= null
        pet=new Dog();
        pet.sound();
    }
}

"运行结果：汪汪汪"

父类引用pet 赋值时赋的是子类对象Dog的实例。就是这行代码 pet = new Dog();
我们发现 pet = new Dog(); 这行代码 = 的右侧 new的是子类的实例，而 = 左侧是父类的引用。我们把这种情况称为“父类引用指向子类实例”

"父类引用指向子类对象的结论"

父类引用可以代表任何其子类对象，代码表现为 Pet pet = new Dog() 或者

父类引用指向哪个子类对象，调用的方法就是哪个子类中的方法。例如:

Pet pet = new Dog();
pet.sound(); //调用Dog的sound方法
pet = new Cat();
pet.sound(); //调用Cat的sound方法

父类引用指向子类对象其实是增强了父类的功能。
注意：
因为父类引用调用方法时，必须知道子类有哪些方法，知道的才能调用，不知道的是不能调用的。子类Cat新增的climb()方法父类并不知道，但是父类一定知道子类从父类继承的方法。所以父类引用只能调用子类与父类保持继承关系的方法。可以是重写的方法。

子类引用指向父类实例：

 public static void main(String[] args) {
        pet pet = null;
        Dog dog = pet;//报错： 子类引用dog指向父类实例
    }

当子类指向父类引用时，子类会丢失数据，因此不允许转换。
如果非要转，就要强转，认可丢失的数据。Dog dog = (Dog)pet;

里氏替换原则的调用规则：

当子类指向父类引用时，子类会丢失数据，因此不允许转换。
如果非要转，就要强转，认可丢失的数据。Dog dog = (Dog)pet;

final关键字

实现：

类的属性不允许修改
类的方法不允许覆盖
类不允许继承

面向对象之继承，多态

继承的定义格式

使用继承

创建子类对象时的运行规则

继承的注意事项

类只支持单继承，不允许多继承

多个类可以继承一个父类

允许多层继承

子类和父类是一种相对概念

继承的体系 之 Object类

继承后子类的成员的变化

this和super

继承中的this（调用子类成员）

继承中的super（调用父类成员）

this和super

this和static

方法重写(override)

方法重载与方法重写的区别

子类引用指向父类实例：

里氏替换原则的调用规则：

final关键字

推荐阅读更多精彩内容

继承的体系之 Object类