A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 番茄君   /  2016-5-4 23:53  /  7833 人查看  /  31 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

多态中,调用方法形式参数是父类对象时,传实际参数时可以传递子类对象.因为子类继承了父类,有除了私有成员外的所有属性和功能.转型可以简化代码
回复 使用道具 举报
看完评论又有更深理解了
回复 使用道具 举报
多态时,父类的引用不能访问子类的特有成员;
当多态时: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多态的的必要三个前提。
回复 使用道具 举报
12
您需要登录后才可以回帖 登录 | 加入黑马