① B类继承A类，则称A类为超类(superclass)、父类、基类，
  B类则称为子类(subclass)、派生类、扩展类。
    class A{}
    class B extends A{}
    我们平时聊天说的比较多的是：父类和子类。
    superclass 父类
    subclass 子类
  ② java 中的继承只支持单继承，不支持多继承，C++中支持多继承，
  这也是 java 体现简单性的一点，换句话说，java 中不允许这样写代码：
    class B extends A,C{ } 这是错误的。
  ③ 虽然 java 中不支持多继承，但有的时候会产生间接继承的效果，
  例如：class C extends B，class B extends A，也就是说，C 直接继承 B，
  其实 C 还间接继承 A。
  ④ java 中规定，子类继承父类，除构造方法不能继承之外，剩下都可以继承。
  但是私有的属性无法在子类中直接访问。(父类中private修饰的不能在子类中
  直接访问。可以通过间接的手段来访问。)
  ⑤ java 中的类没有显示的继承任何类，则默认继承 Object类，Object类是 
  java 语言提供的根类（老祖宗类），也就是说，一个对象与生俱来就有 
  Object类型中所有的特征。
  ⑥ 继承也存在一些缺点，例如：CreditAccount 类继承 Account 类会导致它
  们之间的耦合度非常高，Account 类发生改变之后会马上影响到 CreditAccount 类

/**
 * 父类：动物类
 */
class Animal{
    private String name;
    //无参构造方法
    public Animal() {
    }
  //有参构造方法
    public Animal(String name) {
        this.name = name;
    }
    //动物具有吃东西的方法
    public void eat(){
    }
}

/**
 * 猫继承动物类  猫是动物
 */
class Cat extends Animal{
  //无参构造方法
    public Cat(){
    }
    //猫类重写父类eat()方法！
    public void eat(){
        System.out.println("猫吃猫粮！");
    }
}

/**
 * 狗继承动物类 狗是动物
 */
class Dog extends Animal{
  //无参构造方法
    public Dog(){
    }
    //狗类重写父类的eat()方法！
    public void eat(){
        System.out.println("狗吃狗粮！！");
    }
}

/**
 1. 测试类
 */
public class Demo {
    public static void main(String[] args) {
       //创建猫对象
        Cat cat=new Cat();
        //猫吃东西
        cat.eat();
       //创建狗对象
        Dog dog=new Dog();
        //狗吃东西
        dog.eat();
    }
}

多种形态，多种状态，编译和运行有两个不同的状态。
  编译期叫做静态绑定。
  运行期叫做动态绑定。
  Animal a = new Cat();
  // 编译的时候编译器发现a的类型是Animal，所以编译器会去Animal类中找move()方法
  // 找到了，绑定，编译通过。但是运行的时候和底层堆内存当中的实际对象有关
  // 真正执行的时候会自动调用“堆内存中真实对象”的相关方法。
  a.move();
  多态的典型代码：父类型的引用指向子类型的对象。

  向上转型：子--->父 (upcasting)
    又被称为自动类型转换：Animal a = new Cat();
  向下转型：父--->子 (downcasting)
    又被称为强制类型转换：Cat c = (Cat)a; 需要添加强制类型转换符。
  什么时候需要向下转型？
      需要调用或者执行子类对象中特有的方法。
      必须进行向下转型，才可以调用。
  向下转型有风险吗？
      容易出现ClassCastException（类型转换异常）
  怎么避免这个风险？
        instanceof运算符，可以在程序运行阶段动态的判断某个引用指向的对象
      是否为某一种类型。
      养成好习惯，向下转型之前一定要使用instanceof运算符进行判断。
  不管是向上转型还是向下转型，首先他们之间必须有继承关系，这样编译器就不会报错。

public class OverrideTest05{
  public static void main(String[] args){
    // 静态方法可以使用“引用.”来调用吗？可以
    // 虽然使用“引用.”来调用，但是和对象无关。
    Animal a = new Cat(); //多态
    // 静态方法和对象无关。
    // 虽然使用“引用.”来调用。但是实际运行的时候还是：Animal.doSome()
    a.doSome();
  }
}
class Animal{
  // 父类的静态方法
  public static void doSome(){
    System.out.println("Animal的doSome方法执行！");
  }
}
class Cat extends Animal{
  // 尝试在子类当中对父类的静态方法进行重写
  public static void doSome(){
    System.out.println("Cat的doSome方法执行！");
  }
}

/**
 * 父类：动物类
 */
class Animal{
    public Animal() {
    }
    //动物具有吃东西的方法
    public void eat(){
    }
}

/**
 * 猫继承动物类  猫是动物
 */
class Cat extends Animal {
    public Cat() {
    }
    //猫类重写父类eat()方法！
    public void eat() {
        System.out.println("猫吃猫粮！");
    }
    public void run(){
        System.out.println("猫在走猫步");
    }
}

/**
 * 狗继承动物类 狗是动物
 */
class Dog extends Animal{
    public Dog(){
    }
    //狗类重写父类的eat()方法！
    public void eat(){
        System.out.println("狗吃狗粮！！");
    }
    public void run(){
        System.out.println("狗仔跳墙！1");
    }
}

/**
 * 测试类
 */
public class Demo {
    public static void main(String[] args) {
        //向下转型：父类调用子类特有的方法。
        Animal animal=new Cat();
        Animal animal1=new Dog();
        //必须使用instanceof进行判断
        if(animal instanceof Cat) {
            Cat c=(Cat) animal;
            c.run();//子类特有
        }else if (animal1 instanceof Dog){
            Dog d=(Dog) animal1;
            d.run();//子类特有
        }
    }
}

//书
public class Book {
//书名
    String name;
//构造方法
    public Book(){
    super();
    }
  public Book(String name){
    super();
    this.name = name;
  }
 }

//纸质书
public class PaperBook extends Book {
//构造方法
    public PaperBook(){
      super();
    }
    public PaperBook(String name){
      super();
      this.name = name;
    }
//打印书名
    public void printName(){
      System.out.println("this.name->书名 ： " + this.name);
      System.out.println("super.name->书名 ： " + super.name);
    }
 }

public class BookTest {
  public static void main(String[] args) {
    PaperBook book1 = new PaperBook("零基础学 Java 卷 I");
    book1.printName();
  }
 }

//纸质书
public class PaperBook extends Book {
    String name; //在子类中也定义了一个 name 属性
//构造方法
    public PaperBook(){
      super();
    }
    public PaperBook(String name){
      super();
      this.name = name;//这里的 this.name 代表子类的 name
    }
//打印书名
    public void printName(){
    System.out.println("this.name->书名 ： " + this.name);
    System.out.println("super.name->书名 ： " + super.name);
    }
}