理解父类引用指向子类对象

java多态,如何理解父类引用指向子类对象

要理解多态性,首先要知道什么是“向上转型”。

我定义了一个子类Cat,它继承了Animal类,那么后者就是前者是父类。我可以通过   Cat c = new Cat(); 实例化一个Cat的对象,这个不难理解。

但当我这样定义时:   Animal a = new Cat(); 这代表什么意思呢?

很简单,它表示我定义了一个Animal类型的引用,指向新建的Cat类型的对象。由于Cat是继承自它的父类Animal,所以Animal类型的引用是可以指向Cat类型的对象的。

那么这样做有什么意义呢?因为子类是对父类的一个改进和扩充,所以一般子类在功能上较父类更强大,属性较父类更独特,   定义一个父类类型的引用指向一个子类的对象既可以使用子类强大的功能,又可以抽取父类的共性。

所以,父类类型的引用可以调用父类中定义的所有属性和方法,而对于子类中定义而父类中没有的方法,它是无可奈何的;   同时,父类中的一个方法只有在在父类中定义而在子类中没有重写的情况下,才可以被父类类型的引用调用;   对于父类中定义的方法,如果子类中重写了该方法,那么父类类型的引用将会调用子类中的这个方法,这就是动态连接。也可以叫做动态绑定。

动态绑定是指”在执行期间(而非编译期间)“判断所引用对象的实际类型,根据实际的类型调用其相应的方法。

看下面这段程序:

class Father { 
    public void func1() { 
        func2(); 
    } // 这是父类中的func2()方法,因为下面的子类中重写了该方法 //所以在父类类型的引用中调用时,这个方法将不再有效,取而代之的是将调用子类中重写的func2()方法 
    public void func2() { 
        System.out.println("AAA"); 
    } 

class Child extends Father { // func1(int i)是对func1()方法的一个重载 
   由于在父类中没有定义这个方法,所以它不能被父类类型的引用调用 
    所以在下面的main方法中child.func1(68)是不对的 
    public void func1(int i) { 
        System.out.println("BBB"); 
    } // func2()重写了父类Father中的func2()方法   如果父类类型的引用中调用了func2()方法,那么必然是子类中重写的这个方法 
    public void func2() { 
        System.out.println("CCC"); 
    } 

public class PolymorphismTest { 
    public static void main(String[] args) { 
        Father child = new Child(); 
        child.func1();// 打印结果将会是什么? } }

上面的程序是个很典型的多态的例子。子类Child继承了父类Father,并重载了父类的func1()方法,重写了父类的func2()方法。重载后的 func1(int i)和func1()不再是同一个方法,由于父类中没有func1(int i),那么,父类类型的引用child就不能调用func1(int  i)方法。而子类重写了func2()方法,那么父类类型的引用child在调用该方法时将会调用子类中重写的func2() 
    } 
}

那么该程序将会打印出什么样的结果呢?       很显然,应该是“CCC”。

对于多态,可以总结它为:

一、使用父类类型的引用指向子类的对象;

二、该引用只能调用父类中定义的方法和变量;

三、如果子类中重写了父类中的一个方法,那么在调用这个方法的时候,将会调用子类中的这个方法;(动态连接、动态调用)

四、变量不能被重写(覆盖),”重写“的概念只针对方法,如果在子类中”重写“了父类中的变量,那么在编译时会报错。

多态的3个必要条件:

1.继承   2.重写   3.父类引用指向子类对象。

时间: 2024-12-20 14:06:15

理解父类引用指向子类对象的相关文章

java多态,如何理解父类引用指向子类对象

摘录 要理解多态性,首先要知道什么是“向上转型”. 我定义了一个子类Cat,它继承了Animal类,那么后者就是前者是父类.我可以通过   Cat c = new Cat(); 实例化一个Cat的对象,这个不难理解. 但当我这样定义时:   Animal a = new Cat(); 表示定义了一个Animal类型的引用,指向新建的Cat类型的对象.由于Cat是继承自它的父类Animal,所以Animal类型的引用是可以指向Cat类型的对象的. 那么这样做有什么意义呢?因为子类是对父类的一个改进

理解多态AND理解父类引用指向子类对象

假设现在有一个父类Father,它里面的变量需要占用1M内存.有一个它的子类Son,它里面的变量需要占用0.5M内存. 现在通过代码来看看内存的分配情况: Father f = new Father();//系统将分配1M内存. Son s = new Son();//系统将分配1.5M内存. 因为子类中有一个隐藏的引用super会指向父类实例,所以在实例化子类之前会先实例化一个父类,也就是说会先执行父类的构造函数. 由于s中包含了父类的实例,所以s可以调用父类的方法. Son s1 = s;/

java父类引用指向子类对象

父类引用指向子类对象指的是: 例如父类Animal,子类Cat,Dog.其中Animal可以是类也可以是接口,Cat和Dog是继承或实现Animal的子类. Animal animal = new Cat(); 即声明的是父类,实际指向的是子类的一个对象. 那这么使用的优点是什么,为什么要这么用?可以用这几个关键词来概括:多态.动态链接,向上转型 也有人说这是面向接口编程,可以降低程序的耦合性,即调用者不必关心调用的是哪个对象,只需要针对接口编程就可以了,被调用者对于调用者是完全透明的.让你更关

【转】父类引用指向子类对象

父类引用指向子类对象指的是: 例如父类Animal,子类Cat,Dog.其中Animal可以是类也可以是接口,Cat和Dog是继承或实现Animal的子类. Animal animal = new Cat(); 即声明的是父类,实际指向的是子类的一个对象. 那这么使用的优点是什么,为什么要这么用?可以用这几个关键词来概括:多态.动态链接,向上转型 也有人说这是面向接口编程,可以降低程序的耦合性,即调用者不必关心调用的是哪个对象,只需要针对接口编程就可以了,被调用者对于调用者是完全透明的.让你更关

父类引用指向子类对象

1 public class Test { 2 /** 3 * 对于多态,可以总结它为: 4 5 一.使用父类类型的引用指向子类的对象: 6 7 二.该引用只能调用父类中定义的方法和变量: 8 9 三.如果子类中重写了父类中的一个方法,那么在调用这个方法的时候,将会调用子类中的这个方法:(动态连接.动态调用) 10 11 四.变量不能被重写(覆盖),”重写“的概念只针对方法,如果在子类中”重写“了父类中的变量,那么在编译时会报错. 12 13 多态的3个必要条件: 14 15 1.继承 2.重写

关于父类引用指向子类对象

例如: 有以下2个类 public class Father { public int age = 70; public static string name = "父亲"; } public class Son : Father { public int age = 30; public static string name = "儿子"; } Father f=new Son(); 这种用法叫做“父类引用指向子类对象,或者叫“父类指针指向子类对象”,指的是定义一

父类引用指向子类对象--面向对象的多态

先上代码 package com.fuzi.demo; public class FuZi { public static void main(String[] args) { FuLei fuLei = new ZiLei(); fuLei.print_info(); } } class FuLei { public void print_info() { System.out.println("父类的print_info"); System.out.println(this.get

JAVA基础复习与总结<一>(2) 父类引用指向子类对象(向上转型、动态链接)

public class Animal { public static void main(String[] args){ Animal animal = new Cat(); animal.voice(); drinkWater(animal); //调用静态方法,传入的是父类引用的子类对象 } String str; public void voice(){ System.out.println("普通动物叫声!"); } public static void drinkWater

父类引用指向子类对象详解

父类引用变量引用子类时可以调用子类覆盖的方法. 举个例子: 假设有类Cat,类Dog,类Duck...他们都有一个继承自父类Animal的方法eat(),各自覆盖了这个方法,因为猫狗鸭吃相不同 现在.我有另一类,里面有个方法处理各种动物的吃相all_eat() 当然你可以这么写: // 需要用到某个类型时给其创建对象 public Cat cat = null; public Dog dog = null; public Duck ducl = null; public void all_eat