1.什么是多态？

        多态是同一个行为具有多个不同表现形式或形态的能力。或者说：多态就是同一个接口，通过调用不同的实例执行不同操作。

        通俗的说：

                         多态就是“对于同一个消息的响应，不同对象响应结果不同”。

    ---->>为帮助你更好的理解“多态”概念，下面举几个例子，一定要仔细思考：

        （1）举例1：

                类1 ---->> Type1 ：按 “年-月-日” 输出日期；

                类2 ---->> Type2 ：按 “月-日-年” 输出日期；

                类3 ---->> Type3 ：按 “日-月-年” 输出日期；

         当传递参数给Type1、Type2、Type3时，传入年、月、日参数，则对应三种不同的输出格式。也就是说：“年、月、日”是同一种数据，但是 “不同的 类” 对这一数据的响应结果不同，也就是所谓的“多态”。

        （2）举例2：

                主函数中有以下语句：

                int a = 123;
                double d = (double)a;
                byte b = (byte)a;//强制类型转换为byte
                System.out.println("int强制类型转换为double后的值等于"+d);
                System.out.println("int强制类型转换为byte后的值等于"+b);

        在这个例子中，对于同一 int 型数据a，分别强制转换为double、byte类型数据，这也带有多态的身影，即不同的语句对传递来的参数 a 响应结果不同，输出不同的数据，得到不同结果。

        （3）举例3：

                打开电脑，不同情况下按下 F1 键：

                        如果当前在 Flash 界面下弹出的就是Falsh帮助；

                        如果当前在 Word 下弹出的就是 Word 帮助；

                        在 Windows 下弹出的就是 Windows 帮助和支持。

                也就是说：同一个事件（按下F1键）发生在不同的对象上会产生不同的结果。

        （4）举例4：

           如下图片，打印机可以打印黑白的，也可以打印彩色的，这就是多态，命令传给“打印机”，但是“打印机对 命令的响应结果不同，从而 打印黑白或彩色样式”。

2.多态优点

        消除类型之间的耦合关系、可替换性、可扩充性、接口性、灵活性、 简化性。

3.实现多态的必要条件

        （1）继承：子类继承父类。

        （2）重写：在子类中重写从父类继承来的方法。

        （3）向上转型：即父类引用指向子类对象，如：Parent p = new Child()。

        下面根据下图具体举例说明：

        首先：

                父类Shape中有draw()方法，分别创建Circle类、Triangle类、Square类作为子类继承（extends）父类Shape。Circle类、Triangle类、Square类 继承父类Shape 后，也分别含有了 从父类Shape中继承来的draw()方法。

        之后：

                分别在Circle类、Triangle类、Square类 中对继承来的“ draw() 方法” 进行重写，使得不同 子类 中的draw() 方法实现不同功能，如下所示：

                Circle类 中 draw() 方法 ---->> 实现 绘制 “圆”；

                Triangle类 中 draw() 方法 ---->> 实现 绘制 “三角形”；

                Square类  中 draw() 方法 ---->> 实现 绘制 “正方形”；

        当通过Shape s = new Circle() 或 Shape s = new Triangle() 、Shape s = new Square() 语句创建父类Shape对象 s 时，子类Circle、Triangle、Square 会自动“向上转型”到父类，之后父类引用会指向子类，从而调用不同子类中的draw()方法，实现不同功能，实现多态。

        上述  同时满足了“继承、重写、向上转型”三个条件，从而实现了多态。

4.代码实例测试

//定义主类 Test，进行测试
public class Test {
    public static void main(String[] args) {
      show(new Cat()); //用Cat对象初始化父类Animal并调用定义的show方法
      show(new Dog()); //用Dog对象初始化父类Animal并调用定义的show方法    
      Animal a = new Cat();//向上转型，Cat类对象初始化父类Animal 
      a.eat();//父类引用指向子类Cat，调用Cat类中的eat()方法
      Cat c = (Cat)a;//新建Cat类对象c，将对象a强制转换为Cat类对象，即向下转型  
      c.work();//向下转型后c为Cat类对象，调用的是Cat类中的work()方法
   }
		
   //定义show函数      
   public static void show(Animal a)  {
      a.eat();  
        // 类型判断
        if (a instanceof Cat)  {  //是否是Cat类对象 
            Cat c = (Cat)a;//强制转换
            c.work(); 
        } else if (a instanceof Dog) { //是否是Dog类对象 
            Dog c = (Dog)a;//强制转换  
            c.work();  
        }  
   }  
}

//定义抽象类 Animal
abstract class Animal {  
    abstract void eat();//抽象方法，无函数体
}  

//定义子类Cat，并继承父类Animal
class Cat extends Animal { 
	//实现父类中的 eat()方法
    public void eat() {  
        System.out.println("1.Cat eat()-->>>猫喜欢吃鱼");  
    }
	//新增方法
    public void work() {  
        System.out.println("2.Cat work()-->>>猫的工作是抓老鼠");  
    }  
}  

//定义子类Dog，并继承父类Animal
class Dog extends Animal { 
	//实现父类中的 eat()方法
    public void eat() {  
        System.out.println("1.Dog eat()-->>>狗喜欢吃骨头");  
    }
	//新增方法
    public void work() {  
        System.out.println("2.Dog work()-->>>狗的工作是看家");  
    }  
}

5.运行结果

写在最后：

        如果仍有疑问可以留言哦。

package com.up;

public class Cat extends Animal{
	
	public void eat(){
		System.out.println("吃鱼");
	}
	
	
    public void work(){
    	System.out.println("抓老鼠");
    }

}

package com.up;

public class Animal {
	
	public void eat(){
		System.out.println("Animal eat");
	}
}

package com.up;

public class Main002 {
	
	public static void main(String[] args) {
		//Animal没有多态的性质向下转型失败
//		Animal animal = new Animal();
//		Cat cat = (Cat)animal;
		
		//向上转型,Animal具有多态性质   (子类对象转为父类对象)
		Animal animal = new Cat();
		//错误情况
		//Cat cat = new Animal();
		
		//调用的是Cat的eat方法
		animal.eat();
		
		//向下转型  (父类对象转为子类对象)
		Cat cat = (Cat)animal;
		cat.work();
	}

}

灵魂画手

首先，java多态是建立在java继承的基础上的，它表现的是同一种行为的不同表现形式，注意，是行为，即多态是java父子类中的方法的一个特性，而不是父子类中的属性的一个特性，比如：

 Person p1 = new Student();
    System.out.println(p1.age)
    //这里输出的就是父类中age属性的值
    
    p1.eat();
    //这里调用的是Student类中eat的方法，而不是Person类中的eat方法

向上转型：

什么是向上转型呢？向上转型是将子类对象地址赋值给父类对象使用，多态本身就是向上转型的，比如

Person p1 = new Student();            父类 《— 子类

new Student()开辟了一个新的子类对象空间，之后将这个新的子类对象空间的地址赋值给一个父类对象。

向下转型：

向下转型就是 子类 《—— 父类，也就是：

Student p2 = (Student)p1;

或者

(Student) p1

向下转型是因为当使用java多态时(以上述代码为例)，p1只能调用父类Person中存在的方法，不能调用Student中新添加的方法，所以如果想通过多态来调用父类中没有的方法，可以用这样的方式

(Student)p1.study();
//study()方法是Student子类中新添加的方法，父类Person中没有

向下转型要慎用，因为如果转型错误，在编译时并不会报错，但在运行时调用方法的时候会报错，这里java提供了一个双目运算符——instanceof 用来判断某个对象是否为某个类型，返回值为boolean，用法例子如下：

Person p1 = new Student();  

        if(p1 instanceof Person){
            System.out.println("p1对象为Person类的一个实例");
        }
        if(p1 instanceof Student){
            System.out.println("p1对象为Student类的一个实例");
        }

        String s1 = "sfsd";
        if(s1 instanceof String){
            System.out.println("这是一个String类的对象");
        }

运行结果如下：

这里如果p1写成如下形式：

Person p1 = new Person();
        if(p1 instanceof Person){
            System.out.println("p1对象为Person类的一个实例");
        }
        if(p1 instanceof Student){
            System.out.println("p1对象为Student类的一个实例");
        }

结果如下：