在java语言中有这样的一个规定:
无论是向上转型还是向下转型，两种类型之间必须要有继承关系，没有继承关系情况下进行向上转型或向下转型的时候编译器都会报错，这一点需要死记硬背！ 例子： 创建一个动物类public class Animal {
public void move(){
System.out.println("动物正在在移动！");
}
}
猫类继承动物类
public class Cat extends Animal{
//方法覆盖
public void move(){
System.out.println("猫咪正在移动！");
}
//特有方法抓老鼠
public void catchMouse(){
System.out.println("猫咪会抓老鼠");
}
}
鸟类继承动物类
public class Bird extends Animal{
@Override
public void move() {
System.out.println("鸟儿在移动！");
}
//特有方法
public void fly(){
System.out.println("鸟儿在飞翔！");
}
}
测试：
public class Test {
public static void main(String[] args) {
Animal a1 = new Cat();
a1.move();
Animal a2 = new Bird();
a2.move();
}
}
运行结果是：
猫咪正在移动！
鸟儿在移动！
以上程序演示的就是多态，多态就是“同一个行为（move）”作用在“不同的对象上”会有不同的表现结果。
java中之所以有多态机制，是因为java允许一个父类型的引用指向一个子类型的对象。
也就是说允许这种写法：
Animal a2 = new Bird()，
因为
Bird is a Animal是能够说通的。
其中
Animal a1 = new Cat()
Animal a2 = new Bird()
都是父类型引用指向了子类型对象，都属于向上转型（Upcasting），或者叫做自动类型转换。
我来解释一下这段代码片段
Animal a1 = new Cat();
a1.move();
Java程序包括编译和运行两个阶段，分析Java程序一定要先分析编译阶段，然后再分析运行阶段，在编译阶段编译器只知道a1变量的数据类型是Animal，那么此时编译器会去Animal.class字节码中查找move()方法，发现Animal.class字节码中存在move()方法，然后将该move()方法绑定到a1引用上，编译通过了，这个过程我们可以理解为“静态绑定”阶段完成了。
紧接着程序开始运行，进入运行阶段，在运行的时候实际上在堆内存中new的对象是Cat类型，也就是说真正在move移动的时候，是Cat猫对象在移动，所以运行的时候就会自动执行Cat类当中的move()方法，这个过程可以称为“动态绑定”。
但无论是什么时候，必须先“静态绑定”成功之后才能进入“动态绑定”阶段。
public class Test {
public static void main(String[] args) {
Animal a = new Cat();
a.catchMouse();
}
}
public class Test {
public static void main(String[] args) {
//向上转型
Animal a = new Cat();
//向下转型，为了调用子类中的特有方法
Cat c = (Cat)a;
c.catchMouse();
}
}
运行结果：
public class Test {
public static void main(String[] args) {
Animal a = new Bird();
Cat c = (Cat)a;
}
}
public class Test {
public static void main(String[] args) {
Animal a = new Bird();
if(a instanceof Cat) {
Cat c = (Cat)a;
c.catchMouse();
}
}
}
以上程序运行之后不再发生异常，并且什么也没有输出，那是因为if语句的条件并没有成立，因为在运行阶段a引用指向的对象不是Cat类型，所以(a instanceof Cat)是false，自然就不会进行向下转型了，也不会出现ClassCastException异常了。在实际开发中，java中有这样一条默认的规范需要大家记住：在进行任何向下转型的操作之前，要使用instanceof进行判断，这是一个很好的编程习惯。
总结：
多态存在的三个比必要条件是：
1.继承
2.方法覆盖
3.父类型引用指向子类型对象
总结：
多态显然是离不开方法覆盖机制的，多态就是因为编译阶段绑定父类当中的方法，程序运行阶段自动调用子类对象上的方法，如果子类对象上的方法没有进行重写，这个时候创建子类对象就没有意义了，自然多态也就没有意义了，只有子类将方法重写之后调用到子类对象上的方法产生不同效果时，多态就形成了。
实际上方法覆盖机制和多态机制是捆绑的，谁也离不开谁，多态离不开方法覆盖，方法覆盖离开了多态也就没有意义了。
静态方法的“覆盖是没有意义的”，静态方法的执行与对象无关，既然和对象无关，那么就标识和多态无关。
那么问题来了，java中多态的作用是什么呢？
1.降低程序的耦合度，提高程序的扩展力
2.能使用多态尽量多使用多态
3.父类型引用指向子类型对象
核心是：面向抽象编程，尽量不要面向具体编程。
下面写一个例子：
主人类
public class Master {
//Master主人类面对的是一个抽象的pet，不面向具体的宠物
public void feed(Pet pet){
//Pet pet是一个父类型的引用
// 传进来的可以是Pet pet = new Cat()，Pet pet = new Dog()，
//父类型的引用指向了子类型的对象
System.out.println("主人开始喂食了");
pet.eat();
System.out.println("主人喂食完毕了");
}
}
宠物类：
public class Pet {
String name;//宠物有名字
public void eat(){//宠物有吃的方法
}
}
狗类：继承宠物类，并重写eat的方法
public class Dog extends Pet {
public Dog(String name){
this.name = name;
}
public void eat(){
System.out.println(this.name +"吃骨头！");
}
//小狗特有的run方法
public void run(){
System.out.println(this.name + "再跑")
}
}
猫类：继承宠物类,并重写eat方法
public class Cat extends Pet {
public Cat(String name) {
this.name = name;
}
public void eat(){
System.out.println(this.name + "正在吃鱼！");
}
}
测试类：
public class Test {
public static void main(String[] args) {
Dog dog = new Dog("小花");
Master master = new Master();
master.feed(dog);
Cat cat1 = new Cat("Tom");
master.feed(cat1);
Pig pig1 = new Pig("梨花");
master.feed(pig1);
}
}
运行结果：
主人开始喂食了
小花吃骨头！
主人喂食完毕了
主人开始喂食了
Tom正在吃鱼！
主人喂食完毕了
主人开始喂食了
梨花在吃粥!
主人喂食完毕了