精华内容
下载资源
问答
  • 因为子类不可以继承父类的构造方法...super关键字功能:super调用父类构造方法super关键字可以在子类的构造方法中显式地调用父类的构造方法。下面是基本格式:(parameter-list 指定了父类构造方法中的所有参数,sup...

    因为子类不可以继承父类的构造方法,所以,想要调用父类的构造方法的话,那么就可以使用得到super关键字下面的话就来对这个方面做一下详细的讲解。

    super关键字能够用来访问父类的构造方法、普通方法和属性。

    super关键字功能:

    super调用父类构造方法

    super关键字可以在子类的构造方法中显式地调用父类的构造方法。

    下面是基本格式:(parameter-list 指定了父类构造方法中的所有参数,super( )必须是在子类构造方法的方法体的第一行)super(parameter-list);

    示例:

    声明父类Person和子类Student,在Person类中定义一个带有参数的构造方法。public class Person

    {

    public Person(String name)

    {}

    }

    public class Student extends Person

    {}

    会发现Student类出现编译错误,提示必须显式定义构造方法。(错误信息):Implicit super constructor Person() is undefined for default constructor. Must define an explicit constructor

    JVM默认给Student类加了一个无参构造方法,而在这个方法中默认调用了super(),但是Person类中并不存在该构造方法,所以会编译错误。

    假如,一个类中没有写任何的构造方法,JVM会生成一个默认的无参构造方法。

    在继承关系中,因为,在子类的构造方法中,第一条语句默认为调用父类的无参构造方法(即默认为 super(),一般这行代码省略了)。

    所以当在父类中定义了有参构造方法,但是没有定义无参构造方法时,编译器会强制要求我们定义一个相同参数类型的构造方法。

    示例:

    声明父类Person,类中定义两个构造方法:public class Person

    {

    public Person(String name, int age)

    {}

    public Person(String name, int age, String sex)

    {}

    }

    子类Student继承了Person类,使用super语句来定义Student类的构造方法:public class Student extends Person

    {

    public Student(String name, int age, String birth)

    {

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

    }

    public Student(String name, int age, String sex, String birth)

    {

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

    }

    }

    Student类构造方法代码可以看出,super可以用来直接调用父类中的构造方法,使编写代码也更加简洁方便。

    编译器会自动在子类构造方法的第一句加上super();来调用父类的无参构造方法,必须写在子类构造方法的第一句,也可以省略不写。

    通过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 还可以用于调用被子类隐藏的方法。

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

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

    展开全文
  • super调用父类构造

    2021-03-26 08:52:15
    super调用父类构造器 特点: 子类的全部构造器默认一定会调用父类的无参数构造器 super(…):可以根据参数选择调用父类的某个构造器 public class TestDemo { public static void main(String[] args) { //创建对象...

    super调用父类构造器

    特点:
    子类的全部构造器默认一定会调用父类的无参数构造器

    super(…):可以根据参数选择调用父类的某个构造器

    public class TestDemo {
        public static void main(String[] args) {
                //创建对象
            Monkey monkey = new Monkey("金丝猴",10,'雄');
            monkey.eatBanana();
        }
    }
    
    class Monkey extends  Animal{
        public Monkey(String name, int age, char sex) {
            super(name, age, sex);//根据参数匹配调用父类构造器
        }
    
        public void eatBanana(){
            System.out.println(getName()+"-->"+getAge()+"-->"+getSex());
        }
    }
    
    class Animal{
        private String name;
        private int age;
        private char sex;
    
        public Animal() {
        }
    
        public Animal(String name, int age, char sex) {
            this.name = name;
            this.age = age;
            this.sex = sex;
        }
    
        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 char getSex() {
            return sex;
        }
    
        public void setSex(char sex) {
            this.sex = sex;
        }
    }
    

    小结:
    可以在子类构造器中通过super(…)指定调用父类的构造器,以便调用
    父类构造器初始化继承子父类的数据。

    展开全文
  • 父类构造方法不能被子类继承。以下语句中MyException类继承了java.lang.Exception类。public class MyException extends Exception{} //MyException类只有一个隐含的默认构造方法尽管在Exception类中定义了如下...

    父类的构造方法不能被子类继承。以下语句中MyException类继承了java.lang.Exception类。

    public class MyException extends Exception{} //

    MyException类只有一个隐含的默认构造方法

    尽管在Exception类中定义了如下形式的构造方法:

    public Exception(String msg)

    但MyException类不会继承以上Exception类的构造方法,因此以下代码是不合法的。

    //编译出错,MyException类不存在这样的构造方法

    Exception e=new MyException("Something is error");

    在子类的构造方法中,可以通过super语句调用父类的构造方法。例如:

    public class MyException extends Exception{

    public MyException(){

    //调用Exception父类的Exception(String msg)构造方法

    super("Something is error");

    }

    public MyException(String msg){

    //调用Exception父类的Exception(String msg)构造方法

    super(msg);

    }

    }

    用super语句来调用父类的构造方法时,必须遵守以下语法规则。

    l

    在子类的构造方法中,不能直接通过父类方法名调用父类的构造方法,而是要使用super语句,以下代码是非法的:

    public MyException(String msg){

    Exception(msg); //编译错误

    }

    l

    假如在子类的构造方法中有super语句,它必须作为构造方法的第一条语句,以下代码是非法的:

    public MyException(){

    String msg= "Something wrong";

    super(msg); //编译错误,super语句必须作为构造方法的第一条语句

    }

    在创建子类的对象时,Java虚拟机首先执行父类的构造方法,然后再执行子类的构造方法。在多级继承的情况下,将从继承树的最上层的父类开始,依次执行各个类的构造方法,这可以保证子类对象从所有直接或间接父类中继承的实例变量都被正确地初始化。例如以下父类Base和子类Sub分别有一个实例变量a和b,当构造Sub实例时,这两个实例变量都会被初始化。

    public class Base{

    private int a;

    public Base(int a){ this.a=a;}

    public int getA(){return a;}

    }

    public class Sub extends Base{

    private int b;

    public Sub(int a,int b){super(a); this.b=b;}

    public int getB(){return b;}

    public static void main(String args[]){

    Sub sub=new Sub(1,2);

    System.out.println("a="+sub.getA()+" b="+sub.getB()); //打印a=1

    b=2

    }

    }

    在例程11-3(Son.java)中,Son类继承Father类,Father类继承Grandpa类。这3个类都显式定义了默认的构造方法,此外还定义了一个带参数的构造方法。

    例程11-3 Son.java

    class Grandpa{

    protected Grandpa(){

    System.out.println("default Grandpa");

    }

    public Grandpa(String name){

    System.out.println(name);

    }

    }

    class Father extends Grandpa{

    protected Father(){

    System.out.println("default Father");

    }

    public Father(String grandpaName,String fatherName){

    super(grandpaName);

    System.out.println(fatherName);

    }

    }

    public class Son extends Father{

    public Son(){

    System.out.println("default Son");

    }

    public Son(String grandpaName,String fatherName,String

    sonName){

    super(grandpaName,fatherName);

    System.out.println(sonName);

    }

    public static void main(String args[]){

    Son s1= new Son("My Grandpa", "My Father", "My Son"); //①

    Son s2=new Son(); //②

    }

    }

    执行以上main()方法的第①条语句,打印结果如下:

    My Grandpa

    My Father

    My Son

    此时构造方法的执行顺序如图11-1所示。

    如果子类的构造方法没有用super语句显式调用父类的构造方法,那么通过这个构造方法创建子类对象时,Java虚拟机会自动先调用父类的默认构造方法。执行以上Son类的main()方法的第②条语句,打印结果如下:

    default Grandpa

    default Father

    default Son

    展开全文
  • Java里子类调用父类构造方法问题

    千次阅读 2021-02-13 01:44:43
    在Java中,子类的构造过程中,必须调用其父类的构造函数,是因为有继承关系存在时,子类要把父类的内容继承下来,通过什么手段做到的?...构造方法是new一个对象的时候,必须要调的方法,这是规定,要new父类对象出...
  • java子类调用父类构造函数-----super()详解 java子类调用父类构造函数-----super()详解 1.子类不能继承父类的构造函数,但是可以调用父类构造函数 2.如果父类没有定义构造函数,系统会默认定义一个无参无...
  • 如果子类的构造没有通过super调用父类构造函数,那么子类会先调用子类自己的构造函数,再调用父类不含参数的构造函数。 C. 创建子类的对象时,子类构造方法总是先调用父类的构造函数更多相关问题教育科学研究要遵循...
  • 原因在于当实例化子类时会递归调用父类中的构造方法。而这又是为什么呢? 首先,这涉及到Java对象的生命周期。在Java中,对象的生命周期包括以下几个阶段: 创建阶段(Created) 应用阶段(In Use) 不可见阶段...
  • java中的继承(子类调用父类构造方法还不懂)declarations n. 声明extends v. 继承继承中注意的问题:1 重写(也叫覆盖,也叫重构):重写方法必须和被重写方法具有相同的方法名称、参数列表和返回值类型;重写方法不能...
  • 使用super调用父类方法使用super调用父类的构造方法调用构造方法本类中调用另一个重载构造方法用this(参数列表)子类构造方法调用父类构造方法用super(参数列表)子类调用父类的构造方法时:super必须放在第一句Java在...
  • java子类调用父类构造方法 来源:https://www.cnblogs.com/sunnychuh/archive/2011/09/09/2172131.html(本人用来方便查看笔记,不用于其他任何用途) java继承中对构造函数是不继承的,只是调用(隐式或显式)。 ...
  • B继承AB x = new B();//会不会调用A的构造函数?在 Java 中,无论是 explicit...如果 父类有自己的构造方法(这时父类不会有默认无参的构造方法),那么在子类的构造方法中,必须要调用父类的某个构造方法,而且必须是...
  • super调用父类

    2021-04-19 09:25:51
    一、父类 package com.opp.demo05; //父类 //java中任何类都直接或者间接继承object类 //java中只有单继承、没有多继承 public class Person { protected String name="qiu"; //或者public也是可以的 //私有的...
  • 调用父类构造方法

    千次阅读 2021-01-19 09:44:56
    1、使用super调用父类构造方法,必须是子类构造方法的第一个语句。 使用this调用重载的构造方法,也必须是构造方法的第一个语句。 可以看到,程序中已经标红,这是不行的。解决这个问题,可以自己定义一个init...
  • 这篇文章主要介绍了Java super关键字调用父类过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下话不多说,直接上代码:package com.my.pac14;/*** @...
  • Java中子父类构造方法 Java 程序在执行子类的构造方法之前,如果没有用 super() 来调用父类特定的构造方法,则会调用父类中“没有参数的构造方法”。因此,如果父类中只定义了有参数的构造方法,而在子类的构造方法...
  • protected继承继承有个特点,就是子类无法访问父类的private字段或者private方法。例如,Student类就无法访问Person类的name和age字段:class Person {private String name;private int age;}class Student extends ...
  • 所以在子类继承父类后,必须调用父类里面的构造方法。 目的就是为了初始化父类的参数,子类才能使用 class E{ private String e; E(String e){ this.e=e; } } class F extends E{ F(String e){ super(e);...
  • 在Java中,子类的构造过程中,必须调用其父类的构造函数,是因为有继承关系存在时,子类要把父类的内容继承下来,通过什么手段做到的?...构造方法是new一个对象的时候,必须要调的方法,这是规定,要new父类对象出...
  • 在Java中,子类的构造过程中,必须调用其父类的构造函数,是因为有继承关系存在时,子类要把父类的内容继承下来,通过什么手段做到的?...构造方法是new一个对象的时候,必须要调的方法,这是规定,要new父类对象出...
  • super调用父类中的构造函数,super必须在子类this之前调用,必须先调用父类中的构造函数,才能使用子类中的构造函数。 class Father { constructor(x,y){ this.x = x; this.y = y; } sum(){ console.log...
  • public class UnSafeSequence {public class TestMath{private TestMath(){System.out.println("父类实例化");}}public class TestMath1 extends TestMath{public TestMath1(){System.out.println("子类实例化");}}/...
  • (2)在子类中用super()调用父类的无参构造方法,此时系统不再默认调用父类构造方法,也就是父类的构造方法只被调用一次。注意:super()要放在子类构造方法的第一条语句。 2、 父类中定义了父类的构造方法,...
  • 构造方法用来初始化类的对象,与父类的其它成员不同,它不能被子类继承(子类可以继承父类所有的成员变量和成员方法,但不继承父类的构造方法)。因此,在创建子类对象...如果子类没有定义构造方法,则调用父类的无参...
  • 1、super调用父类构造方法,必须在构造方法的第一个。 2、super必须只能出现在子类的方法或构造方法中! 3、super和this不能同时调用构造方法! 在继承中,子类要调用父类的属性,需要使用super关键字 ...
  • 当创建任何 Java 对象时,程序总会先依次调用每个父类非静态初始化块、父类构造器(总是从 Object 开始,因为Java 程序里所有类的最终父类都是 java.lang.Object 类)执行初始化,最后才调用本类的非静态初始化块、...
  • public abstract class Animal{private String name;public String getName(){return name;}public Animal(String theName){name = the...}}public class Hippo extends Animal{public Hippo(String name){super(n...
  • java子类调用父类方法中包含子类重写的实例方法# 看题目是不是很绕,这个我也不知道怎么才能更简单的表达了# 先看代码:public class Common {public static void main(String[] args) {Sub sub = new Sub();...
  • Java构造函数中显示的调用父类A的有参构造函数点击次数:1571更新日期:2013-03-16class Personpublic Person}class Student extends Personpublic Studentpublic Student}class Test}/==============================...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 168,171
精华内容 67,268
关键字:

super调用父类构造方法