精华内容
下载资源
问答
  • 2020-07-22 19:14:05

    为什么要声明父类对象调用子类对象?

    原因:多态
    1.声明父类对象,指向子类对象

    2.声明的父类对象只能调用父类中定义的方法和变量

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

    4.变量不能被重写(覆盖),"重写"的概念只针对方法,如果在子类中重新定义修改了父类中的变量,声明的父类对象调用的依然是父类中的变量

    多态的3个必要条件:
    ①继承
    ②重写
    ③父类引用指向子类对象

    更多相关内容
  • Java 中父类怎么调用子类方法

    千次阅读 2021-02-12 10:27:41
    父类调用子类方法吗?答:能。怎么做?● 把子类传递到父类的有参构造中,然后调用。● 使用反射的方式调用,你使用了反射还有谁不能调用的?!● 父类调用子类的静态方法。案例展示:package com.ywq;public ...

    父类能调用子类的方法吗?

    答:能。

    怎么做?

    ● 把子类传递到父类的有参构造中,然后调用。

    ● 使用反射的方式调用,你使用了反射还有谁不能调用的?!

    ● 父类调用子类的静态方法。

    案例展示:

    package com.ywq;

    public class Test2{

    public static void main(String[] args)

    {

    Son son = new Son();

    Father father=new Father(son);

    father.fun1();

    father.fun4();

    }

    }

    class Father{

    public Son son;

    public Father(Son son){

    this.son=son;

    }

    public Father() {

    }

    public void fun4(){

    //方法3:使用反射的方式调用子类方法

    try {

    Class cls=Class.forName("com.ywq.Son");

    Son son=(Son) cls.newInstance();

    son.fun2();

    } catch (Exception e) {

    e.printStackTrace();

    }

    }

    public void fun1(){

    //方法1:把子类传递到父类的有参构造函数中,然后调用。

    System.out.println("我是父类的方法");

    son.fun2();

    //方法2:父类调用子类的静态方法。

    Son.fun3();

    }

    }

    class Son extends Father{

    public static void fun3(){

    System.out.println("我是子类的静态方法");

    }

    public void fun2(){

    System.out.println("我是子类的方法");

    }

    }

    这三种都是父类直接调用子类的方法,

    好用不?好用!

    解决问题了吗?解决了!

    项目中允许使用不?不允许!

    我就一直没有搞懂为什么要用父类调用子类的方法。如果一定要调用子类,那为什么要继承它呢?搞不懂。其实这个问题可以换个角度去理解,父类建立框架,子类在重写了父类部分的方法后,再调用从父类继承的方法,产生不同的结果(而这正是模板方法模式)。这是不是也可以理解为父类调用了子类的方法呢?你修改了子类,影响了父类行为的结果,曲线救国的方式实现了父类依赖子类的场景,模板方法模式就是这种效果。

    ---------------------

    作者:温柔狠角色

    原文:https://blog.csdn.net/qq_25827845/article/details/52916513

    展开全文
  • Java父类调用子类方法

    千次阅读 2021-07-23 16:33:22
    接口和继承 public interface In { void doSomething(); } 父类: public class T{ ... // 需要子类重写的普通方法 protected void layoutChildren() { } public void Hello(){ // 用子类.
    1. 接口和继承
    public interface In {
        void doSomething();
    }
    

    父类:

    public class T{
        private In in;
    
        public void setIn(In in){
            this.in = in;
        }
    
        // 需要子类重写的普通方法
        protected void layoutChildren() {
        }
    
        public void Hello(){
        	// 用子类对象,会调用子类实现方法
            layoutChildren();
            // 调用接口方法
            in.doSomething();
        }
    
    }
    

    子类:

    public class CT extends T implements In {
    
        @Override
        protected void layoutChildren() {
            System.out.println("HAHAHA");
        }
    
        @Override
        public void doSomething() {
            System.out.println("Do Something.");
        }
    
        @Test
        public void getT(){
            setIn(this);
            Hello();
        }
    }
    

    结果:
    在这里插入图片描述

    1. 即常规做法,讲子类对象直接传进去,但没人这么写代码;
    2. 将父类需要调用的方法,在子类中写为public static,但更加离谱,因为父类不关心子类,不应该知道子类的类名,更不应该知道子类的方法。
    3. 既然可以父类通过类名来调用静态,那么也就可以使用反射的方式。但还是很离谱,原因同上。

    所以一般而言使用为上面的两种方式,注意到在父类中的layoutChildren方法我们没有实现,可以申明为抽象方法,即:

    public abstract class T{
        private In in;
    
        public void setIn(In in){
            this.in = in;
        }
    
        // 需要子类重写
        protected abstract void layoutChildren();
    
        public void Hello(){
            layoutChildren();
            in.doSomething();
        }
    }
    

    那么,我们父类在调用layoutChildren方法的时候,就是调用子类的实现,但具体是哪个子类的实现,其实父类并不关心。接口也是如此的思想。也就是:

    • 行为由父类/接口控制,子类实现。

    当然上面代码的接口方式我感觉写的不好,感觉可以尝试使用SpringDI方式。

    展开全文
  • 现在定义三个类 Person作为父类 Student类和Teacher类是子类 两个子类都有自己特有的属性和方法 并且重写父类say()方法 分别是 Person类 package www.polyarr; //创建Person类 public class Person { private

    我们先进行了解Java的动态绑定机制

    1. 当调用对象方法的时候,该方法会和该对象的内存地址/运行类型进行绑定
    2. 当调用对象属性的时候,没有动态绑定机制,在哪里声明就在哪里使用。属性没有动态绑定机制

    现在定义三个类 Person作为父类 Student类和Teacher类是子类 两个子类都有自己特有的属性和方法 并且重写父类say()方法

    • 分别是 Person类
    package www.polyarr;
    //创建Person类
    public class Person {
        private String name;//设置两个成员变量 name 和 age 并增加get set方法
        private int age;
        public Person(String name , int age) {// 类构造器
            this.name=name;
            this.age=age;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
        public String say() {//say方法 返回name和age值
            return "name"+getName()+"age"+getAge();
        }
        
    } 
    
    • Student类
    package www.polyarr;
    
    public class Student extends Person{//继承Person类
        private double scores;//定义成员变量 scores(成绩)
        public Student(String name, int age, double scores) {//继承父类构造器 并加入自己的变量
            super(name, age);
            this.scores=scores;
            // TODO Auto-generated constructor stub
        }
        public double getScores() {
            return scores;
        }
        public void setScores(double scores) {
            this.scores = scores;
        }
        public String say() {//重写父类say()方法
            return "学生"+super.say()+"scores="+getScores();
        }
        public void student() {//写入student方法 
            System.out.println("学生"+getName()+"正在学习");
        }
    }
    
    • Teacher类
    package www.polyarr;
    
    public class Teacher extends Person{//继承Person类
        private int salary;//定义成员变量 salary(薪水)
        public Teacher(String name, int age,int salary) {//继承父类构造器 并加入自己的变量
            super(name, age);
            this.salary=salary;
            // TODO Auto-generated constructor stub
        }
        public int getSalary() {
            return salary;
        }
        public void setSalary(int salary) {
            this.salary = salary;
        }
        public String say() {//重写父类say()方法
            return "老师"+super.say()+"salary="+getSalary();
        }
        public void teacher() {//写入teacher方法 
            System.out.println("老师"+getName()+"正在教书");
        }
    }
    
    • 在主类中定义一个Person类的数组 存入一个Person类对象 两个Student类对象 和两个Teacher类对象循环调用say()方法 在运行是调用运行类型的方法 依次输出信息
    name张三age16
    学生name小明age18score=100.0
    学生name小强age19score=80.0
    老师name张兰age28salary=6000
    老师name王明age32salary=8000
    
    • 此时 如果我想调用两个子类特有的方法 是无法被调用到的 此时我们使用if判断 使用instanceof 比较当前类是否等于Students类
    • 如果等于的话 将当前类向下转型并调用它特有的方法 Teahcer类同理
    package www.polyarr;
    
    public class Polyarr {
        public  static void main(String[]arge) {
            Person person[]=new Person[5];//定义一个Person数组  进行赋值
            person[0]=new Person("张三",16);
            person[1]=new Student("小明",18,100);
            person[2]=new Student("小强",19,80);
            person[3]=new Teacher("张兰",28,6000);
            person[4]=new Teacher("王明",32,8000);
            for (int i = 0; i < person.length; i++) {
                System.out.println(person[i].say());//循环输出say方法  此时输出的say()方法是按照引用类型 就是进行new的实例化类型调用的
                if (person[i] instanceof Student) {//进行判断 是否为Student类
                    ((Student)person[i]).student();//对Person数中的对象 进行向下转型 并调用student方法
                } else if(person[i] instanceof Teacher){//进行判断 是否为Teacher类
                    ((Teacher)person[i]).teacher();//对Person数中的对象 进行向下转型 并调用teacher方法
                }else {
                    System.out.println("类型不正确");
                }
            }
        }
    }
    
    • 最后输出
    name张三age16
    类型不正确
    学生name小明age18score=100.0
    学生小明正在学习
    学生name小强age19score=80.0
    学生小强正在学习
    老师name张兰age28salary=6000
    老师张兰正在教书
    老师name王明age32salary=8000
    老师王明正在教书
    
    展开全文
  • 父类子类方法调用

    千次阅读 2022-04-18 10:44:57
    由于没有找到想要的解释,于是自己就在idea上自测来寻找答案。 关于父类,子类,多态之间方法的调用。 package 思考;...//父类无法调用子类 an.eat(); an.go(); //an.keep();调用子类报错 System.o.
  • 例如父类Person指向子类Student:Person p = new Student(); 父类类型实例p可以调用父类中定义...对于父类中定义的方法,如果子类中重写了该方法,那么父类类型的引用将会调用子类中的这个方法,这就是动态连接。 ...
  • 父类对象可以调用子类中的方法吗?

    万次阅读 多人点赞 2017-03-30 11:03:38
    2.我们new一个子类对象赋给父类(父类的引用指向了子类的对象,也就是说java里说的多态,),父类对象不可以调用子类的方法,但如果子类重写了父类的某个方法,则此时父类调用的是子类方法的内容。
  • 文章开始前,我们先抛出一个链式问题:Java中父类调用子类方法吗?如果不可以,原因?如果可以,如何做?每种实现方式,在实际项目被允许吗?不被允许的原因有哪些?如果在实际项目中,的确有这样的特殊业务场景...
  • 父类引用调用子类对象

    千次阅读 2017-12-07 09:30:03
    创建对象时,会为每个对象开辟一块 动态存储区 ---用来存放对象的属性 在"生成"类时,会为每个类开辟一块 静态存储区 ---用来存放该类...子类对象调用父类继承来的方法(未重写),从父类的静态存储区调用父类方法
  • 一、父类指针指向子类对象 先上代码: class Base { public: void base_fun1() {} virtual void base_fun2() { cout << "this is Base fun2()" << endl; } public: int a_a; protected: int a...
  • 变量person实实在在指向对象Person(父类对象),所能看到的是父类的方法shout()所对应的地址。由于存在方法重写,所以父类方法的地址指向创建对象的类(Student类)所对应的方法shout(),打印Student对象属性:student
  • 用子类的构造函数创建父类对象只能调用父类的方法或者子类重写父类的方法,不能调用子类独有的方法.
  • ![图片说明](https://img-ask.csdn.net/upload/201712/05/1512488608_850150.png) ![图片说明]...为什么子类方法也被调用了 而且还是优先父类方法调用的!!!
  • 因为子类中有一个隐藏的引用super会指向父类实例,所以在实例化子类之前会先实例化一个父类,也就是说会先执行父类的构造方法,由于s中包含了父类的实例,所以s可以调用父类方法。 下面我们来看一下代码:
  • Java子类在创建子类的时候,不会创建父类对象,只是会调用父类的构造器,对从父类中继承过来的属性和方法进行初始化。特别要注意,调用父类的构造方法,并不意味这创建父类对象 具体详解 ...
  • 父类调用子类重写方法---------多态

    千次阅读 2019-08-23 16:51:59
    1.如果父类构造器调用了被子类重写的方法,且通过子类构造函数创建子类对象调用了这个父类构造器(无论显示还是隐式),就会导致父类在构造时实际上调用的是子类覆盖的方法(你需要了解java继承中的初始化机制)。...
  • 关于用子类创建父类对象的问题
  • 什么是多态: ...父类型的引用可以指向new出的子类型的对象,但不能调用子类中的方法,如果需要会进行强制类型转换,父类转子类。 具有继承关系的父子类,父类中的public非静态方法在子类中被重写,则用父类
  • 创建子类对象时,会把父类里的成员变量和方法也加载进内存(因为要加载进内存,所以要看下这些数据是怎么初始化的,所以调用了父类的构造,仅此而已,并不是去创建父类对象) 然后用this和super这两个引用来区分...
  • 创建一个类的时候,首先创建父类对象,在创建子类对象,这是一个层层创建的过程。
  • 父类:A 子类:Person A a1 = new Person(); if(a1 instanceof Person) { System.out.println("true");... //调用子类独有的方法 } 转载于:https://www.cnblogs.com/paul011/p/8072796.ht...
  • 因此,在创建子类对象时,为了初始化从父类继承来的数据成员,系统需要调用其父类的构造方法。  如果没有显式的构造函数,编译器会给一个默认的构造函数,并且该默认的构造函数仅仅在没有显式地声明构造函数情况下...
  • 创建一个子类对象会不会创建父类对象? 不会,只创建了一个子类对象,但是往父类对象的构造方法里传了子类对象的地址;给子类对象初始化的时候,调用了父类的构造方法。 证明: class A{ public A(){ System.out...
  • python中进行面向对象编程,当在子类的实例中调用父类的属性时,由于子类的__init__方法重写了父类的__init__方法,如果在子类中这些属性未经过初始化,使用时就会出错。 例如以下的代码: class A(object): def __...
  • java 中父类引用指向子类对象

    千次阅读 2021-03-06 18:06:02
    继承和方法重写已经很熟悉了,这次主要验证一下,当一个父类的引用指向一个对象的时候,它会调用子类方法,而不是父类的。引用在栈内存中存在对象的内存地址。真正的对象(通过 new Student()创建的)存放在堆内存里...
  • 父类 对象 = new 子类()

    千次阅读 2021-03-03 20:44:22
    如上,对象b调用属性的时候调用父类属性,将对象b调用方法的时候调用子类方法。 class Animal{ } class Dog extends Animal{ } public class Test4 { public static void main(String[] args) { Animal a = ...
  • 在java中,当创建一个子类对象会不会先创建父类对象?(如果父类是抽象类呢?) 被一些教材和资料误导和困扰,有些教材和资料上说,按照面向对象的思想,“没有爸爸,怎么会有儿子”,即 “没有父类怎么会有子类”...
  • android端父类调用子类重写的方法

    千次阅读 2018-06-29 09:34:33
    看一段代码:public class main_class { public static void main(String[] args){ new c2(); } } class c1{ String name="... //父类构造函数 public c1(){ print(); } //该构造函数自始...
  • class Parent { public: int a }; class Child :public Parent { public: int b;... 因为被子类指针指向的由父类创建对象,根本没有要访问的那些内容,那些是子类特有的,只有用子类初始 化对象时才会有.

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 313,674
精华内容 125,469
关键字:

创建父类对象调用子类方法