public class Animal{

//成员

public void eat(){

System.out.println("动物在吃！");

}

}

public class Cat extends Animal{

//重写

public void eat(){

System.out.println("猫吃鱼");

}

//Cat特有的方法.

public void move(){

System.out.println("猫走猫步！");

}

}

public class Test02{

public static void main(String[] args){

  //向上转型又被称作：自动类型转换.

              //父类型的引用指向子类型对象.

              //程序分两个阶段：编译阶段，运行阶段。

              //程序编译阶段只知道a1是一个Animal类型。

              //程序在运行的时候堆中的实际对象是Cat类型。

Animal a1 = new Cat();

  //程序在编译阶段a1被编译器看做Animal类型.

              //所以程序在编译阶段a1引用绑定的是Animal类中的eat方法.(静态绑定)

              //程序在运行的时候堆中的对象实际上是Cat类型，而Cat已经重写了eat方法。

              //所以程序在运行阶段对象的绑定的方法是Cat中的eat方法.(动态绑定)

a1.eat(); //猫吃鱼

  //向下转型：强制类型转换

Animal a2 = new Cat(); //向上转型.

  //要执行move方法,怎么做？

              //只能强制类型转换,需要加强制类型转换符

Cat c1 = (Cat)a2;

c1.move();

  //判断以下程序运行的时候会出什么问题？

  //Animal a3 = new Dog(); //向上转型.

              //强制类型转换

              //Cat c2 = (Cat)a3; // java.lang.ClassCastException

              //在做强制类型转换的时候程序是存在风险的！

              //为了避免ClassCastException的发生，java引入了 instanceof

              /*

              用法：

                     1. instanceof运算符的运算结果是 boolean类型

                     2. (引用 instanceof 类型) --> true/false

                     例如：(a instanceof Cat) 如果结果是true表示：a引用指向堆中的java对象是Cat类型.

              */

Animal a3 = new Dog();

System.out.println(a3 instanceof Cat); //false

  //推荐：在做向下转型的时候要使用instanceof运算符判断，避免ClassCastException

              if(a3 instanceof Cat){

Cat c2 = (Cat)a3;

}

}

}

Person p = new Student();

Object o = new Person();//Object类型的变量o，指向Person类型的对象

o = new Student(); //Object类型的变量o，指向Student类型的对象

Student m = new Student();

m.school = “pku”;        //合法,Student类有school成员变量

Person e = new Student();

e.school = “pku”;   //非法,Person类没有school成员变量

//属性是在编译时确定的，编译时e为Person类型，没有school成员变量，因而编译错误。

public class Person{//模拟主人

/*

public void feed(Dog d){ //喂养

d.eat();

}

public void feed(Cat c){ //因为用户的业务改变了，所以软件要升级。

c.eat();

}

*/

//以上的代码得出：Person类型的扩展能力太差。

    //尽量不要面向具体编程，面向父类型编程，面向抽象编程

public void feed(Animal a){

a.eat();

}

}

public class Animal{

public void eat(){}

}

public class Cat extends Animal{//宠物1

public  void eat(){

System.out.println("猫吃东西！");

}

}

public class Dog extends Animal{//宠物2

public  void eat(){

System.out.println("狗吃东西！");

}

}

public class Test{//多态测试

public static void main(String[] args){

//1.创建主人

Person zhangsan = new Person();

//2.创建宠物

Dog d = new Dog();

Cat c = new Cat();

//3.喂

zhangsan.feed(d);

zhangsan.feed(c);

}

}

Person e = new Person();

e.getInfo();

Student e = new Student();

e.getInfo();

Person e = new Student();

e.getInfo();     //调用Student类的getInfo()方法

Person p = new Man();//向上转型

// 虚拟方法调用：通过父类的引用指向子类的对象实体，当调用方法时，实际执行的是子类重写父类的方法

p1.eat();

p1.walk();

// p1.entertainment();

// 若a是A类的实例，那么a也一定是A类的父类的实例。

// 格式： 对象a instanceof 类A：判断对象a是否是类A的一个实例.是的话，返回true；否则返回false

if (p1 instanceof Woman) {

System.out.println("hello!");

Woman w1 = (Woman) p1;

w1.shopping();

}

if (p1 instanceof Man) {

Man m1 = (Man) p1;

m1.entertainment();

}