继承提高了程序的可维护性，多态提高了程序的可扩展性。


    **1.继承

    **
    继承可以实现代码的复用，子类可以继承父类的除私有属性和私有方法外的所有属性和方法。

    extends 可以表示继承关系

    Java中不允许多继承，即可以一个父类有多个子类，一个子类不能有多个父类
    Java接口可以多继承

    当父类的方法不能自满足子类的需求，就可以对该方法重写。重写时访问权限只能扩大，返回值类型不变。

    @Override：子类重写父类的标识。

    super 可用以指向父类的方法，如super.eat()

    在子类的默认无参构造方法中，有这样一个语法：

    1. public man(){
    3. //指向父类的无参构造方法
    5. super(); 
    6. }//这是默认的，不写出来也会有

    **2.多态

    概念：多种状态，同一对象在不同情况下表现出不同的状态或行为。

    必须有继承存在，才能有多态

    调用成员方法时，编译器看左边，运行器看右边

    调用成员变量时，编译看左，运行看右。

    父类成员方法可以重写，成员变量不可以。

    不能使用子类特有成员，需要使用子类特有成员，就需要转型。

    多态分为两个阶段：编译阶段和运行阶段

    （1）向上转型：把父类的引用指向子类的对象

    1. //如：父类有一个eat方法，想要调用子类中被重写后的eat方法。
    2. //用Animal类型（父类）来接收new出的对象（子类）。
    3. //在转型过程中，子类的新有的方法都会遗失掉。
    4. Animal animal = new Cat();

    （2）向下转型：把子类的引用指向父类的对象。

    1. //类似于C语言的类型强制转换，这里是把animal的引用强转为Cat类型
    2. //如：子类Cat定义了一个属于自己的方法，父类想要调用这个方法
    3. //则需要先向上转型：
    4. Animal animal = new Cat();
    5. Cat cat1 = (Cat)animal;
    6. //转型后，向上转型中遗失的子类的自有方法就可以使用了

    注意：向下转型是向上转型后才能执行的操作,否则不安全。

    多态的好处：
    提高了程序的可维护性（由继承保证）
    提高了程序的可扩展性（由多态保证）

    多态的弊端：
    不能访问子类的特有功能
    如何访问子类的特有功能：向下转型

    instanceof：x instanceof y,用来判断x是否是y的对象。

    tips：向下转型并不属于多态，它只是一种访问子类特有功能的手段。

    主人喂养宠物的案例：
    主人喂养多个宠物，如猫cat，狗dog，兔子等等
    所有宠物都有一个eat()方法，主人有feed方法，用一个test类进行喂养测试

    1.                      一、采用对feed进行重载，每一个宠物对应一个feed方法，每增加一个宠物类就需要增加一个feed方法和一个对象。<br />但这样的程序耦合度高，可扩展性不强。

    二、给所有宠物建立一个共有父类pet，所有宠物都继承pet

    pet中定义一个eat()方法，然后给主人类定义一个feed方法，参数为（Pet pet），父类的引用指向子类的对象

    主人Master

    1. package com.jy.master;
    2. public class Master {
    3. public void feed(Pet pet){
    4.     pet.eat();
    6.         }
    7.   }

    宠物猫Cat

    1. package com.jy.master;
    3. public class Cat extends Pet {
    4. public void eat(){
    5.     System.out.println("猫吃鱼");
    6. }
    7. }

    宠物狗Dog

    1. package com.jy.master;
    3. public class Dog extends Pet {
    5.     public void eat(){
    7.         System.out.println("狗吃骨头");
    8.     }
    9. }
    11. 宠物
    13. package com.jy.master;
    15. public class Pet {
    18.     public void eat(){
    20.     }
    21. }
    25. 场景，即喂养测试
    27. ```java
    28. package com.jy.master;
    30. import javafx.animation.ScaleTransition;
    32. public class MasterTest {
    34.     public static void main(String[] args){
    36.         Master master = new Master();
    38.         Pet pet = new Pet();
    40.         Cat cat = new Cat();
    42.         Dog dog = new Dog();
    44.         master.feed(cat);
    46.         master.feed(dog);
    47.     }
    48. }

    这种方法的好处：耦合度低，可扩展性强，增加一个宠物只需加一个类，不需要修改主人Master的代码。