多态中,调用方法形式参数是父类对象时,传实际参数时可以传递子类对象.因为子类继承了父类,有除了私有成员外的所有属性和功能.转型可以简化代码

看完评论又有更深理解了

多态时，父类的引用不能访问子类的特有成员；
当多态时：1).隐式转换Animal a = new Cat();2).强制转换：Cat c = (Cat)a;
重点:为了强转安全，我们可以先使用：instanceof关键字判断
if(a instanceof Cat){
        Cat c = (Cat)a;//绝对安全的，在强转前建议这样写，这是一个好的习惯；
}

多态的定义是什么你记得么?

刚才手快,没打完就发出去了,多态前提是必须要有继承,要有方法重写,父类引用指向子类对象;你的问题最主要在于还是对于多态的应用还是不透彻,--------------多态的弊端是父类不能使用子类的属性和方法,.强转就是父类可以使用子类的属性和方法了!多态的好处在开发中基本不创建父类引用子类对象,直接创建对象当做参数传递更好,这样父类可以访问子类的特有属性和方法!

     直接创建对象就是New 但是new就是消耗堆内存，在任何语言里都是为了节省内存的思维设计的，可能一行代码没什么，但是一个系统对象和类时非常多的，随便new就是不合理，浪费内存，降低运行速度。父类没有转型的对象实际上具备子类的特点只是类型不一样，不能调用子类的方法，转型就可以调用子类的方法，得到数据或是处理数据。不转就不能用了。

直接创建对象就是New ，但是new就是消耗堆内存，在任何语言里都是为了节省内存的思维设计的，可能一行代码没什么，但是一个系统对象和类时非常多的，随便new就是不合理，浪费内存，降低运行速度。父类没有转型的对象实际上具备子类的特点只是类型不一样，不能调用子类的方法，转型就可以调用子类的方法，得到数据或是处理数据。不转就不能用子类方法。

学java不要钻牛腱遵守规则就是

楼主，你好！很高兴为您回答问题。
多态是面象对象三大特征之一。
多态的意思是：父类指向子类对象。还是通过代码来说明，可以更容易理解些：

package vince.com;

public class Test02
{
        public static void main(String[] args)
        {
                Person father=new Father();
                father.name="jack";
                father.age=18;
                father.run();
        }
       
}
class Person
{
        public Person()
        {
        }

        protected String name;
        protected int age;
        void run()
        {
                System.out.printf("我是父亲，我跑得很快");
        }
}
class Father extends Person
{
        void run()
        {
                System.out.println("我是儿子，我跑得更快！");
               
        }       
}
以上的代码运行过，是没有问题的。
通过以上的代码可以看出，Person father=new Father();
虽然这里用了Person类父类的类名，但是创造出来的还是Father的对象，这就是所谓的父类指向子类对象（自动向上提升），而且Father类的对象具有父类的所有属性，并重写了父类的方法。
理解了上面这一点，这样就不难理解向下转型的概念了。过程是相反的，即用子类指向父类对象，此时需要类型强制转换。

楼主提问说，为什么要转型，是这样的，通过父类指向子类对象，可以提高代码的柔韧性，可以使代码更灵活。
纯手打的，满意请采纳，谢谢！

多态特征主要体现在扩展性.
比如
class Fu {
   public void show() {
      System.out.println("Fu");
   }
}
class Zi extends Fu {
    public void show() {
      System.out.println("Zi");
   }
   public void eat() {
      System.out.println("eat");
   }
}
向上转型Fu f = new Zi();这样父类引用指向子类对象,Fu类对象f就可以调用自己子类重写过的show方法,输出结果"Zi";
但是这有一个弊端,就是f不能调用Zi子类中特有的方法eat(),因为它本身没有;所以这时候就需要向下转型,将f转成Zi类.
Zi z = (Zi)f;然后再调用eat()方法就没问题了,因为z是ZI类的对象了,可以使用本类方法.

转型要注意：向上转换，是自动的。向下转换，需要强制转换；比如：父 转 子：Zi z = (Zi)f;

兄弟，这是我在知乎上找的，你可以参考下

用一句话概括就是：事物在运行过程中存在不同的状态。先以教科书般举例说明,下文再举一个花木兰替父从军的例子帮助大家理解. 多态的存在有三个前提:
1.要有继承关系
2.子类要重写父类的方法
3.父类引用指向子类对,
但是其中又有很多细节需要注意。首先我们定义两个类，一个父类Animal，一个子类Cat。
父类Animal

class Animal {
        int num = 10;
        static int age = 20;
        public void eat() {
                System.out.println("动物吃饭");
        }

        public static void sleep() {
                System.out.println("动物在睡觉");
        }

        public void run(){
                System.out.println("动物在奔跑");
        }
}


子类Cat

class Cat extends Animal {
        int num = 80;
        static int age = 90;
        String name = "tomCat";
        public void eat() {
                System.out.println("猫吃饭");
        }
        public static void sleep() {
                System.out.println("猫在睡觉");
        }
        public void catchMouse() {
                System.out.println("猫在抓老鼠");
        }

}

测试类Demo_Test1

class Demo_Test1 {
        public static void main(String[] args) {       
        Animal am = new Cat();
        am.eat();
        am.sleep();
        am.run();
        //am.catchMouse();这里先注释掉，等会会说明
        //System.out.println(am.name);//这里先注释，待会说明
        System.out.println(am.num);
        System.out.println(am.age);
        }
}

以上的三段代码充分体现了多态的三个前提，即：
1、存在继承关系
Cat类继承了Animal类
2、子类要重写父类的方法
子类重写(override)了父类的两个成员方法eat()，sleep()。其中eat()是非静态的，sleep()是静态的（static）。
3、父类数据类型的引用指向子类对象。
测试类Demo_Test1中 Animal am = new Cat();语句在堆内存中开辟了子类(Cat)的对象，并把栈内存中的父类(Animal)的引用指向了这个Cat对象。
到此，满足了Java多态的的必要三个前提。