class Animal {
  public void hobby() {
    System.out.println("动物的叫声有很多种！");
  }
}
class Cat extends Animal {
  public void hobby() { //子类重写父类的 hobby 方法
    super.hobby(); //要想调用父类中被重写的方法，必须使用 super 关键字
    System.out.println("猫：喵喵喵！");
  }
}
class Dog extends Animal { //Dog 子类的理解和上面的 Cat 子类是一样的
  public void hobby() {
    super.hobby();
    System.out.println("狗：汪汪汪！");
  }
}
public class Study {
  public static void main(String[] args) {
    Animal a=new Cat(); //父类声明对象，子类实例化对象，即向上转型
    a.hobby();
    Animal b=new Dog(); //父类声明对象，子类实例化对象，即向上转型
    b.hobby();
  }
}

abstract class Animal {//抽象类
  public abstract void eat();//继承它的子类必须重写这个方法
}
class Cat extends Animal {
  public void eat() {
    System.out.println("猫喜欢吃鱼！");
  }
  public void work() {
    System.out.println("猫也会抓老鼠！");
  }
}
class Dog extends Animal {
  public void eat() {
    System.out.println("狗喜欢吃骨头！");
  }
  public void work() {
    System.out.println("狗也会看家！");
  }
}
public class Testing {
  public static void show(Animal a) {//实例化一个对象a
  //在 main 方法中，直接使用类进行调用，所以 show 方法需定义为静态的
    a.eat(); //将两个子类的对象进行向上转型，并且子类已经重写了抽象父类的抽象方法eat
    //所以就相当于在调用两个字类中各自的 eat 方法
    if(a instanceof Cat) { //类型判断，如果 a 是子类 Cat 的对象
      Cat b=(Cat)a;
      b.work();
    }
    else if(a instanceof Dog) { //类型判断，如果 a 是子类 Dog 的对象
      Dog b=(Dog)a;
      b.work();
    }
  }
  public static void main(String[] args) {
    show(new Cat()); //通过 Testing 类调用 show 方法，具体在 Cat 类中实现
    show(new Dog()); //通过 Testing 类调用 show 方法，具体在 Dog 类中实现
    Animal c=new Cat(); //父类声明对象，子类实例化对象，即向上转型
    c.eat(); //调用 Cat 类的 eat 方法
    Cat d=(Cat)c; //将对象 c 强制转换回来，即向下转型
    d.work(); //调用 Cat 类的 work 方法
  }
}

show(new Cat());//等价于下面的这两行代码
Animal a=new Cat();//这两行更能体现“静态方法由类调用”这句话
Testing.show(a);