精华内容
下载资源
问答
  • 展开全部在father中在定义一个62616964757a686964616fe59b9ee7ad9431333335313738调用父类的方法,在子类逐级调用。。。classGrandPa{voidMethod(){System.out.println("Hello,IamGrandPa!");}}...

    展开全部

    在father中在定义一个62616964757a686964616fe59b9ee7ad9431333335313738调用父类的方法,在子类逐级调用。。。class GrandPa

    {

    void Method()

    {

    System.out.println("Hello,   I   am   GrandPa! ");

    }

    }

    class Father extends GrandPa

    {

    void Method()

    {

    System.out.println("Hello,   I   am   Father! ");

    }

    /** 定义一个调用父类的方法 */

    void getParentMethod()

    {

    super.Method();

    }

    }

    class Son extends Father

    {

    void Method()

    {

    /** 这么逐级调用就可以了 */

    super.getParentMethod();

    System.out.println("And   Son   is   followed! ");

    }

    public static void main(String[] args)

    {

    Son son = new Son();

    son.Method();

    }

    }

    展开全文
  • 这篇文章主要介绍了Java super关键字调用父类过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下话不多说,直接上代码:package com.my.pac14;/*** @...

    这篇文章主要介绍了Java super关键字调用父类过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下

    话不多说,直接上代码:

    package com.my.pac14;

    /**

    * @auther Summerday

    */

    public class SuperTest {

    public static void main(String[] args) {

    SubClass sb = new SubClass(20);

    //创建子类的对象,调用子类的print方法

    sb.print();

    }

    }

    class BaseClass {

    public int a = 5;

    public int b;

    static public int c = 30;

    BaseClass(int b) {

    this.b = b;

    System.out.println("superb:" + this.b);

    }

    public void print() {

    System.out.println("父类的a = " + a);

    //System.out.println(this.a);

    }

    public void read() {

    System.out.println("read..");

    }

    }

    class SubClass extends BaseClass {

    public int a = 10;

    //子类中的实例变量将父类中的隐藏,所以下面的this.b=0

    public int b;

    static public int c = 40;

    SubClass(int b) {

    //调用父类的构造器

    super(b);//20

    System.out.println("superb:" + super.b + ",subb:" + this.b);//0

    }

    public void print() {

    //打印父类中的a=5

    System.out.println(super.a);//5

    //调用父类的print方法,打印a=5

    super.print();//5

    //直接打印a,会打印出当前类的a,打印子类的a=10

    System.out.println("子类的a = " + a);

    //类变量也会覆盖

    System.out.println(c);

    //用父类名访问父类的类变量

    System.out.println("父类中的类变量c = " + BaseClass.c);

    //没有重写,不需要使用super调用父类方法

    read();

    }

    }

    super用于限定该对象调用从父类继承得到的实例变量或方法,因此和this相同的是,super不能出现在static修饰的方法中。(因为static修饰的方法属于类,调用者将会是类,而不是一个对象)

    调用父类成员变量

    实例变量

    可以直接利用super.xx限定访问父类的实例变量。

    //父类

    public int a = 5;

    //子类

    public int a = 10;

    //在子类中访问父类的实例变量

    public void print() {

    //打印父类中的a=5

    System.out.println(super.a);//5

    //直接打印a,会打印出当前类的a,打印子类的a=10

    System.out.println("子类的a = " + a);

    }

    类变量

    如果父类变量是用static修饰的类变量,则需要用父类类名.xx限定访问其类变量。(虽然可以使用super访问父类中的类变量,就像我们之前说的用类的实例访问类变量,但是极不规范,不建议。)

    //父类

    static public int c = 30;

    //子类

    static public int c = 40;

    //在子类中访问父类的类变量

    public void print() {

    //类变量也会隐藏

    System.out.println(c);

    //用父类名访问父类的类变量

    System.out.println("父类中的类变量c = " + BaseClass.c);

    }

    总结:

    子类中没有包含和父类同名的成员变量,就无需使用super或父类名显式调用。

    如果在没够方法中访问某成员变量,但没有显式指定调用者,则查找该成员变量的顺序:

    查找该方法中有没有。

    查找该类中有没有。

    查找父类中有没有。

    ……

    如果没有找到,就会报错。

    当创建一个子类对象时,系统不仅会为该类中定义的实例变量分配内存,也会为它从父类继承得到的所有实例变量分配内存,即使子类定义了与父类中同名的实例变量。所以,子类中定义与父类同名的实例变量并不会完全覆盖父类中定义的实例变量,只是简单地隐藏。

    调用父类的方法

    我们之前说过,子类中定义与父类同名且参数列表相同的实例方法(static方法不能被重写)就是所谓的方法重写,此时子类的方法会覆盖父类的方法。

    在子类中想调用父类的同名实例方法,可以利用:super.父类方法名;

    如果是类方法,则可以用父类名.父类方法名调用。(super依旧可以,但不建议)

    如果没有同名,就不需要显式用super调用父类方法。

    //父类

    public void print() {

    System.out.println("父类的a = " + a);

    //System.out.println(this.a);

    }

    public void read() {

    System.out.println("read..");

    }

    //子类

    public void print() {

    //调用父类的print方法,打印a=5

    super.print();//5

    //没有重写,不需要使用super调用父类方法

    read();

    }

    调用父类构造器

    关于子类中利用super关键字调用父类构造器,在上一篇中,已经做出总结,具体可参看:Java继承构造器使用过程解析

    以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持聚米学院。

    展开全文
  • 由于子类不能继承父类的构造方法,因此,要调用父类的构造方法,必须在子类的构造方法体的第一行使用 super() 方法。该方法会调用父类相应的构造方法来完成子类对象的初始化工作。在以下情况下需要使用 super 关键字...

    由于子类不能继承父类的构造方法,因此,要调用父类的构造方法,必须在子类的构造方法体的第一行使用 super() 方法。该方法会调用父类相应的构造方法来完成子类对象的初始化工作。

    在以下情况下需要使用 super 关键字:

    在类的构造方法中,通过 super 语句调用该类的父类的构造方法。

    在子类中访问父类中的成员。

    使用 super 调用父类的构造方法

    子类可以通过 super 关键字来调用一个由父类定义的构造方法,格式如下:

    super(parameter-list);

    其中,parameter-list 指定了父类中构造方法所需的所有参数。super() 必须是在子类构造方法的主体第一行。

    例如,在 Person 类中指定了两个构造方法。示例代码如下:

    public People(String name,int age,String sex,String sn)

    {

    this.name=name;

    this.age=age;

    this.sex=sex;

    this.sn=sn;

    }

    public People(String name,String sn)

    {

    this.name=name;

    this.sn=sn;

    }

    那么,Student 类继承了 Person 类,就可以使用 super 语句来定义 Student 类的构造方法。示例代码如下:

    public Student(String name,int age,String sex,String sn,String stuno,String department)

    {

    super(name,age,sex,sn); //调用父类中含有4个参数的构造方法

    this.stuNo=stuno;

    this.department=department;

    }

    public Student(String name,String sn,String stuNo)

    {

    super(name,sn); //调用父类中含有两个参数的构造方法

    this.stuNo=stuNo;

    }

    从上述 Student 类构造方法代码可以看出,super 用来直接调用父类中的构造方法,使用它可以使书写代码更简洁方便。

    使用 super 访问父类成员

    使用 super 访问父类中的成员与 this 关键字的使用相似,只不过它引用的是子类的父类,基本形式如下:

    super.member

    其中,member 是父类中的方法或属性名称。这种形式多用于子类的成员名隐藏了父类中的同名成员的情况。

    例 1

    在 Animal 类和 Cat 类中分别定义了 public 类型的 name 属性和 private 类型的 name 属性,并且 Cat 类继承 Animal 类。那么,我们可以在 Cat 类中通过 super 关键字来访问父类 Animal 中的 name 属性,通过 this 关键字来访问本类中的 name 属性,如下面的代码:

    //父类Animal的定义

    public class Animal

    {

    public String name; //动物名字

    }

    //子类Cat的定义

    public class Cat extends Animal

    {

    private String name; //名字

    public Cat(String aname,String dname)

    {

    super.name=aname; //通过super关键字来访问父类中的name属性

    this.name=dname; //通过this关键字来访问本类中的name属性

    }

    public String toString()

    {

    return"我是"+super.name+",我的名字叫"+this.name;

    }

    public static void main(String[] args)

    {

    Animal cat=new Cat("动物","喵星人");

    System.out.println(cat);

    }

    }

    上述代码演示了使用 super 实现子类的成员名隐藏父类中同名成员的情况。尽管 Cat 类中的属性 name 隐藏了 Animal 类中的 name 属性,但是 super 允许访问父类中的 name 属性。另外,super 还可以用于调用被子类隐藏的方法。

    运行程序,输出结果如下:

    我是动物,我的名字叫喵星人

    展开全文
  • Java构造函数中显示的调用父类A的有参构造函数点击次数:1571更新日期:2013-03-16class Personpublic Person}class Student extends Personpublic Studentpublic Student}class Test}/==============================...

    Java构造函数中显示的调用父类A的有参构造函数

    点击次数:1571  更新日期:2013-03-16

    class Person

    public Person

    }

    class Student extends Person

    public Student

    public Student

    }

    class Test

    }

    /

    =======================================

    输出如下:

    E:“JavaWorkjava Test

    st1:

    person无参数构造函数

    student 无参数的构造函数

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

    st2:

    person无参数构造函数

    student 3 参数的构造函数

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

    st3:

    person 2 参数的构造函数

    student 4 参数的构造函数,super.

    说明了创建一个子类的对象实例的时候,必先调用父类的无参数的构造函数(默认构造函数),假如父类有带参数的构造函数,那么系统将不会给它创建无参数的构造函数,这时,子类在实例化的时候,因为找不到父类的默认构造函数,编译器将会报错,但假如在子类的构造函数中指定用父类的带参数的构造函数的时候,或者在父类中加一个无参数的构造函数,就不会报错。

    =============================================

    我们假设A是B的父类,B是A的子类。

    1、假如程序员没有给类A没有提供构造函数,则编译器会自动提供一个默认的无参数的构造函数,假如用户提供了自己的构造函数,则编译器就不在提供默认的无参数构造函数。

    2、子类B实例化时会自动调用父类A的默认构造函数,所以假如A的默认的无参数的构造函数为private,则编译器会报错,而假如A没有提供默认的无参数的构造函数,而提供了其他类型的构造函数,编译器同样会报错,因为B找不到A的默认无参数构造函数。所以,我们最好给父类A提供一个无参数的构造函数。

    3、或者在B的构造函数中显示的调用父类A的有参构造函数。

    \n\n\n

    展开全文
  • 1)父类构造函数java中当调用某个类的构造方法的时候,系统总会调用父类的非静态初始化块进行初始化,这个调用是隐式的,而且父类的静态初始化代码块总是会被执行,接着调用父类的一个或者多个构造器执行初始化,这个...
  • 这是我的代码的摘录package...import java.util.Iterator;import java.util.LinkedList;import java.util.regex.*;public class IntelliCwDB extends CwDB {public IntelliCwDB(String filename) {super(filename);}...
  • PHP,如果子类有构造函数,就不会再去调用父类的构造函数,如果子类的构造函数为空,则取调用父类的,如果父类的构造函数为空,那就调取父类的父类构造函数,以此类推,直接到默认的构造函数JAVA,子类总是调用父类的...
  • java调用父类构造器

    千次阅读 2014-11-15 21:35:59
    子类不会获得父类的构造器,但子类构造器里可以调用父类构造器的初始化代码
  • public abstract class Animal{private String name;public String getName(){return name;}public Animal(String theName){name = theName;}}public class Hippo extends Animal{public Hippo(String name){super(n...
  • java中有super和this这2个关键字,我有时候对super有一些疑惑,我甚至认为我对super和this这2个关键字还没理解!大家请看下面的代码,帮我解惑一些呗!谢谢package com.jiongmeng;class Father {String name;int ...
  • public abstract class Animal{private String name;public String getName(){return name;}public Animal(String theName){name = theName;}}public class Hippo extends Animal{public Hippo(String name){super(n...
  • Java中的继承是通过extends关键字来实现的,在定义类的时候使用extends关键字来指明新定义类的父类,那么就在这两个类之间建立了继承关系,新定义的类就称为子类。在继承关系中:有域的隐藏和方法的覆盖域的隐藏是指...
  • 点击上方“简说Java”,关注并“星标”带你从零学Java作者:周同学来源:简说Java这是简说Java的第20篇原创文章大家好,我是周同学~持续更新Java入门系列教程:Java基础 | Java运行环境JDK的配置Java基础 | 第一个...
  • ——子类和父类之间继承中构造函数的调用规则1.子类的构造过程中,必须调用其父类的构造方法2.如果子类的构造方法中没有显示的调用基类构造方法,则系统默认调用基类无参数的构造方法——代码class SuperClass{...
  • protected void setActionsActivated(boolean state) { Method method= null; try { method= AbstractTextEditor.class.getDeclaredMethod("setActionActivation", new Class[] { boolean.class...
  • 此处的多个类称为子类(此类,派生类,拓展类),单独的这个类称为父类(基类 ,超类)。可以理解为:“子类 is a 父类”。类继承语法规则: class Subclass extends SuperClass{ };以下几点需要注意:子类继承了父类所有...
  • 表示父类对象的默认引用如果子类要调用父类被覆盖的实例方法,可用super作为调用者调用父类被覆盖的实例方法。...super必须放在第一句Java在执行子类的构造方法前会先调用父类无参的构造方法,其目的是为了...
  • 因为子类不可以继承父类的构造方法,所以,想要调用父类的构造方法的话,那么就可以使用得到super关键字下面的话就来对这个方面做一下详细的讲解。super关键字能够用来访问父类的构造方法、普通方法和属性。super...
  • java子类调用父类的方法中包含子类重写的实例方法# 看题目是不是很绕,这个我也不知道怎么才能更简单的表达了# 先看代码:public class Common {public static void main(String[] args) {Sub sub = new Sub();...
  • 父类的构造方法不能被子类继承。以下语句中MyException类继承了java.lang.Exception类。public class MyException extends Exception{} //MyException类只有一个隐含的默认构造方法尽管在Exception类中定义了如下...
  • java在父类中创建父类型的子类型对象是可以调用父类的私有方法的吗? 如图:父类有一个私有方法f(),然后再父类中创建一个父类型的子类对象student,然后用子类对象student调用f()方法。 ![图片说明]...
  • } } # 上面的代码的输出结果是: com.qq.demo.common.Sub # 大致流程是 main 中调用子类的 testSub()方法 -- testSub()方法中调用父类的testParent() 方法 -- testParent() 方法调用test()方法;需要注意的是test()...
  • ////子类直接调用父类的public方法,可以把公用类放到父类中,这样子类中无需再定义一遍, testSon.fun3(); } // 从结果中可以看出:调用某个类的构造方法的时候总是会先执行父类的非静态代码块,然后执行父类的构造...
  • java子类调用父类的方法:1、子类的对象调用方法时,会首先在子类中查找,如果子类中没有该方法,再到父类中查找;2、如果该方法中又调用了其他方法,那么还是按照之前的顺序,先在子类中查找,再在父类中查找。...
  • classsuperClass{inty;superClass(){y=30;System.out.println("insuperClass:y="+y);}voiddoPrint(){System.out.println("InsuperClass.doPrint()");}}classsubClassextendssuperClas...class superClass {int y;...
  • 子类实例化时,默认调用父类的无参构造方法(不管子类的构造器有没有参数,因为子类继承的是父类的属性和方法,只调用父类的无参构造器就可以继承父类的属性和方法,因此不会调用父类的有参构造器),再调用子类的有参...
  • Java中,子类的构造过程中,必须调用其父类的构造函数,是因为有继承关系存在时,子类要把父类的内容继承下来,通过什么手段做到的?答案如下:当你new一个子类对象的时候,必须首先要new一个父类的对像出来,这个...
  • java子类调用父类构造器函数

    万次阅读 多人点赞 2019-06-25 15:52:54
    java子类调用父类构造器函数详解

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 14,629
精华内容 5,851
关键字:

java调用父类

java 订阅