精华内容
下载资源
问答
  • 父类引用指向子类对象指的是: 例如父类Animal,子类Cat,Dog。其中Animal可以是类也可以是接口,Cat和Dog是继承或实现Animal的子类。 Animal animal = new Cat(); 即声明的是父类,实际指向的是子类的一个对象。 那...

    最近有所感悟,写一下最多态新的理解吧:
    父类引用指向子类对象指的是:

    例如父类Animal,子类Cat,Dog。其中Animal可以是类也可以是接口,Cat和Dog是继承或实现Animal的子类。

    Animal animal = new Cat();

    即声明的是父类,实际指向的是子类的一个对象。

    那这么使用的优点是什么,为什么要这么用?可以用这几个关键词来概括:多态、动态链接,向上转型

    也有人说这是面向接口编程,可以降低程序的耦合性,即调用者不必关心调用的是哪个对象,只需要针对接口编程就可以了,被调用者对于调用者是完全透明的。让你更关注父类能做什么,而不去关心子类是具体怎么做的,你可以随时替换一个子类,也就是随时替换一个具体实现,而不用修改其他.

    以后结合设计模式(如工厂模式,代理模式)和反射机制可能有更深理解。

    下面介绍java的多态性和其中的动态链接,向上转型:

    面向对象的三个特征:封装、继承和多态;

    封装隐藏了类的内部实现机制,可以在不影响使用者的前提下修改类的内部结构,同时保护了数据;

    继承是为了重用父类代码,子类继承父类就拥有了父类的成员。

    方法的重写、重载与动态连接构成多态性。C#之所以引入多态的概念,原因之一是它在类的继承问题上和C++不同,后者允许多继承,这确实给其带来的非常强大的功能,但是复杂的继承关系也给C++开发者带来了更大的麻烦,为了规避风险,C#只允许单继承,派生类与基类间有IS-A的关系(即“猫”is a “动物”)。这样做虽然保证了继承关系的简单明了,但是势必在功能上有很大的限制,所以,C#引入了多态性的概念以弥补这点的不足,此外,抽象类和接口也是解决单继承规定限制的重要手段。同时,多态也是面向对象编程的精髓所在。

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

    我定义了一个子类Cat,它继承了Animal类,那么后者就是前者是父类。我可以通过

    Cat c = new Cat();
    实例化一个Cat的对象,这个不难理解。但当我这样定义时:

    Animal a = new Cat();
    这代表什么意思呢?

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

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

    那什么是动态链接呢?当父类中的一个方法只有在父类中定义而在子类中没有重写的情况下,才可以被父类类型的引用调用; 对于父类中定义的方法,如果子类中重写了该方法,那么父类类型的引用将会调用子类中的这个方法,这就是动态连接。
    对于多态,可以总结以下几点:

    一、使用父类类型的引用指向子类的对象;
    二、该引用只能调用父类中定义的方法和变量;
    三、如果子类中重写了父类中的一个方法,那么在调用这个方法的时候,将会调用子类中的这个方法;(动态连接、动态调用)
    四、变量不能被重写(覆盖),”重写“的概念只针对方法,如果在子类中”重写“了父类中的变量,那么在编译时会报错。
    可以参照此链接,进一步了解:https://www.cnblogs.com/ChrisMurphy/p/5054256.html

    展开全文
  • 2.父类的引用指向子类的对象 下面通过几个实例来详细讲解这个知识点: (1)定义父类Person (2)定义子类Student (3)定义测试类Test Person person = new Student();这里为父类的引用指向子类的对象,(引用...

    多态

    多态即事物的多种多样的状态。

    1.重载重写都是多态的表现。重载重写此处不再赘述。
    2.父类的引用指向子类的对象

    下面通过几个实例来详细讲解这个知识点:
    (1)定义父类Person
    在这里插入图片描述
    (2)定义子类Student
    在这里插入图片描述
    (3)定义测试类Test
    在这里插入图片描述
    Person person = new Student();这里为是”向上转型“,即父类的引用指向子类的对象。(引用的知识请看前几篇博文,此处不再赘述)。

    通过person调用方法调用的是Person类的方法还是Student类?
    通过输入person.的提示我们知道要想编译通过,应该调用Person类的方法。如下
    在这里插入图片描述
    编译通过。
    在这里插入图片描述
    运行的是子类重写的方法。

    总结:编译的时候看赋值等号的左边,运行的时候看等号右边。

    那么怎么才能在Person person = new Student();这句下利用person调用Student类的方法?
    答案是”向下转型“,实际上就是强制类型转化,代码如下
    在这里插入图片描述
    这样就OK了。

    instanceof函数

    下面为这个函数的使用方法例子:
    在这里插入图片描述
    运行中关键在于:
    传参Person p = student;然后instanceof检测参数属于Student 类,进入if表达式。这个函数避免了大量重复性检查变量类型 的函数的定义。

    展开全文
  • 父类的引用指向子类的对象或者接口指向实现类均是可以的。 例如(下图为父类的引用指向子类的对象) 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 publicclassFather { ...

    父类的引用指向子类的对象或者接口指向实现类均是可以的。

    例如(下图为父类的引用指向子类的对象)

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    public class Father {
            public void pri() {
                System.out.println("father");
            }
    }
    public class Sun   extends  Father{
          public void pri() {
              System.out.println("sun");
          }
    }
    public class TestMulStatus {
            public static void main(String[] args) {
                Father f=new Sun();
                f.pri();
            }
    }

    这样是可行的,当然下面这个也是可行的:(此例子为接口的引用指向实现类的)

    1
    List<Integer> b=new ArrayList<Integer>();

    转载于:https://www.cnblogs.com/toSeeMyDream/p/4538956.html

    展开全文
  • * 父类的引用指向子类的对象,此为多态性Polymorphism。 * 此对象a能调用父类的方法和子类重写的方法,父类被重写的方法被覆盖了。 * !! 不能调用子类添加的方法。 * 构造方法从父类到子类。 */ class Animal...
    /**
     * @Lin 2018.5.7
     * Animal a = new Dog()
     * 父类的引用指向子类的对象,此为多态性Polymorphism。
     * 此对象a能调用父类的方法和子类重写的方法,父类被重写的方法被覆盖了。
     * !! 不能调用子类添加的方法, 除非强制转化为子类的对象 ((Dog).a).play()
     * Animal a = new Dog();  //a是父类Animal的对象,所以默认可以调用父类的所以方法(重写的会被子类覆盖),它不能调用子类的新加方法,但是是指向子类,可以调用子类的重写方法
     * 构造方法从父类到子类。
     */
    class Animal {
        void eat() {
            System.out.println("Animal eat! 父类的方法");
        }
    
        public Animal() {
            System.out.println("Animal 构造方法!!");
        }
    
        void go() {
            System.out.println("Animal go 父类没被子类重写的方法");
        }
    }
    
    class Dog extends Animal{
        public Dog() {
            System.out.println("Dog 构造方法!!");
        }
    
        @Override
        void eat() {
            System.out.println("Dog eat 子类重写父类的方法");
        }
    
        void play() {
            System.out.println("Dog play -- 子类添加的方法");
        }
    }
    
    public class PolymorphismTest {
        public static void main(String[] args) {
            Dog d = new Dog();      // 构造方法先运行父类,再到子类
            d.go();
            d.eat();
            System.out.println("------");
            System.out.println("父类的引用指向子类的对象");
            Animal a = new Dog();
            a.eat();    // 子类重写父类的方法
            ((Dog)a).play();   // 强制转化可以调用子类新添加的方法
            a.go();      // 父类的方法
        }
    }


    输出:
    Animal 构造方法!!
    Dog 构造方法!!
    Animal go 父类没被子类重写的方法
    Dog eat 子类重写父类的方法
    ------
    父类的引用指向子类的对象
    Animal 构造方法!!
    Dog 构造方法!!
    Dog eat 子类重写父类的方法
    Dog play -- 子类添加的方法
    Animal go 父类没被子类重写的方法
    
    Process finished with exit code 0


    展开全文
  • /*向上转型:子类的对象赋值给父类的引用(父类的引用指向的属性是父类的属性) ,如此就可调用父类类的方法,而不可以调用自身的方法,但如果父类的方法被子类重写, 那就调用子类的方法 。好处:减少重复代码*/ ...
  • 多态。 如果说父类中有这个属性跟方法,子类有重写过,那么调用的是子类中的属性跟方法。 如果父类中没有这个属性跟方法,那么子类调用就会... 如果父类有这个属性跟方法,而子类没有,则调用的是父类的属性跟方法。
  • 书上有这么一句 Collection c=new ArrayList(); 不太明白为什么不写成这样子 ArrayList c=new ArrayList(); 他这样写,引用C能访问ArrayList()里方法还是Collection里方法 呢?
  • 多态中总不理解Father f = new Son()是怎么引用子类对象的,现在从从对象的内存角度来理解试试. 假设现在有一个父类Father,它里面变量需要占用1M内存.有一个它的子类Son,它里面变量需要占用0.5M内存. 现在...
  • 我有一个A类, B:public A A有virtual void fun(), B有virtual void fun(), 用一个vector<A>存放一些A和一些B, 循环遍历调用fun(), 如何才能在当里面某元素是B类时候执行B类方法?
  • 动态绑定的概念:父类类型引用指向子类对象,调用的是子类方法,子类类型引用指向子类对象,调用的是子类的方法。 那么在父类类型引用指向子类对象的情况下,调用子类特有方法会怎样呢? 答案是会报错。 如上图...
  • 可以指向的引用类型不确定:父类的引用指向子类对象能执行哪些方法,主要看对象的左边,和右边的关系不大! public class Person{ public void run(){} } public class Student Extends Person{ @Override ...
  • class Test{ public static void main(String[] args){ First s = new Second(); System.out.println(s.var); System.out.println(s.var); } } class First { int var =1; int method(){ ...}
  • java 父类的引用指向子类对象时 为什么不能调用子类特有的方法? JAVA SEMPER_FI2015-04-18 15:10:47 我建立了两个类 子类为airplane 拥有一个fly()方法 而父类transportation则没有这个方法 package com.ljx...
  • Java 父类的引用指向子类对象有啥用 总结

    千次阅读 多人点赞 2018-06-07 23:11:10
    你可能会写如下2个方法feed(Cat cat){ }feed(Dog dog){ }如果Cat、Dog都是Animal子类... //父类引用指向子类对象Animal a2=new Cat();feed(a1);feed(a2);有人说这是面向接口编程,可以降低程序耦合性,即...
  • 1.从对象的内存角度来理解. 假设现在有一个父类Father,它里面的变量需要占用1M内存.有一个它的子类Son,里面的变量需要占用0.5M...因为子类中有一个隐藏的引用super会指向父类实例,所以在实例化子类之前会先实例化一个父
  • 1.从对象的内存角度来理解. 假设现在有一个父类Father,它里面的变量需要占用1M内存.有一个它的子类Son,里面的变量需要占用0.5M内存...因为子类中有一个隐藏的引用super会指向父类实例,所以在实例化子类之前会先实例...
  • 面向对象编程有三个特征,即封装、继承和多态。 封装隐藏了类内部实现机制,从而可以在不影响使用者前提下改变类内部结构,同时保护了数据。 继承是为了重用父类代码,同时为实现多态性作准备。那么什么...
  • 假设有父类Fu ,其子类为Zi ,从对象的内存角度,假设Fu类里面的变量占内存2M, ...因为子类中有一个隐藏的引用super会指向父类实例,所以在实例化子类之前会先实例化一个父类,也就是说会先执行父类的构造函数.所以
  • 父类的引用指向子类

    2016-10-14 22:40:50
    面向对象编程有三个特征,即封装、继承和多态。 封装隐藏了类内部实现机制,从而可以在不影响使用者前提下改变类内部结构,同时保护了数据。 继承是为了重用父类代码,同时为实现多态性作准备。那么什么...
  • 多态。 如果说父类中有这个属性跟方法,子类有重写过,那么调用的是子类中的属性跟方法。 如果父类中没有这个属性跟方法,那么子类调用就...如果父类有这个属性跟方法,而子类没有,则调用的是父类的属性跟方法。 ...
  • 父类的引用指向子类的对象,它只能看的到父类的那些方法~ 子类自身的方法看不到~~ ······························· 如: interface Singer { //定义了一个接口,它属于...
  • 例如父类Person指向子类Student:Person p = new Student(); 父类类型实例p可以调用父类中定义所有属性和方法,而对于子类中定义而父类中没有方法,它是无可奈何; 同时,父类一个方法只有在在父类中定义...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,392
精华内容 2,556
关键字:

父类的引用指向子类的对象