精华内容
下载资源
问答
  • 2021-12-03 16:52:22

    在 Java 中,无论是 explicit 还是 implicit 方式,都要求在子类的构造方法中调用其父类的构造方法。如果父类无构造方法(其实是一个默认无参的构造方法),那么子类的构造方法中会自动进行调用;如果父类有自己的构造方法(这时父类不会有默认无参的构造方法),那么在子类的构造方法中,必须要调用父类的某个构造方法,而且必须是在构造方法的第一个语句中进行调用。

    此时再创建子类实例就需要显示的调用父类的构造方法,并且进行传参,否则创建不出来父类的实例就会编译出错

    当父类有多个构造方法时,子类需要显示的决定使用哪一个构造方法

    究其原因,想必是 Java 语言设计者,要求子类有责任保证它所继承的父类尽快进入到一个稳定、完整的状态中。试想,如果没有这个约束,那么子类的某个继承自父类的方法可能会使用到父类中的一些变量,而这些变量并没有进行初始化,从而产生一些难以预料的后果。

    父类的构造方法子类不可以继承,更不存在覆盖的问题。

    所以子类构造方法默认调用父类的无参构造方法。(所以养成写无参构造的习惯)

    如果子类访问父类的有参构造方法,必须在子类构造方法第一行使用super(参数)

    当构造一个对象的时候,系统先构造父类对象,再构造子类对象。

    如果直接new子类实例,就会调用到父类刚刚这个自动生成的没有参数的构造方法

    当父类里有构造方法时,并且这个构造方法带参数的时候,编译器就不再自动生成无参数版本的构造方法了。l

    例子:父类有了明确参数的构造方法

    public class Animal {
        String name;
        int age;
        public Animal(String name){
        this.name=name;
    }
        public void eat(){
            System.out.println(name+"正在吃");
        }
        public  void getage(){
            System.out.println(name+"年龄是"+age);
        }
    }

    子类继承时也需要在构造方法中为父类的构造方法赋值。不调用父类的构造方法就会报错

    public class Dog extends    Animal{
    String name;
    int age;
        public Dog(String name) {
            super(name);
           // this.name=name;
        }
        public void eat(){
            System.out.println(name+"正在吃ff");
        }
        public void neweat(){
            System.out.println("neweat");
        }
    }
    

    更多相关内容
  • 本篇文章介绍了,Java中子类调用父类构造方法的问题分析。需要的朋友参考下
  • java子类调用父类构造方法 来源:https://www.cnblogs.com/sunnychuh/archive/2011/09/09/2172131.html(本人用来方便查看笔记,不用于其他任何用途) java继承中对构造函数是不继承的,只是调用(隐式或显式)。 ...

    java子类调用父类构造方法

    来源:https://www.cnblogs.com/sunnychuh/archive/2011/09/09/2172131.html(本人用来方便查看笔记,不用于其他任何用途)

    java继承中对构造函数是不继承的,只是调用(隐式或显式)。

    以下是例子:

    public class FatherClass {
    
     public FatherClass() {
           System.out.println(100);
     }
    
     public FatherClass(int age) {
          System.out.println(age);
     }
    
    }
    
     
    
    public class SonClass extends FatherClass{
    
            public SonClass() {
             }
    
            public SonClass(int c) {
                     System.out.println(1234);
            }
      
     public static void main(String[] args) {
    
      SonClass s = new SonClass(66);
     
     }
    }
    

    编译后执行结果如下是什么呢?

    分析:SonClass s = new SonClass(66);执行这句时,调用

    public SonClass(int c) {
                     System.out.println(1234);
    //系统会自动先调用父类的无参构造函数(super())
            }
    

    在这个构造函数中,等价于

    public SonClass(int c) {
    
                    super();
                    //必须是第1行,否则不能编译
                     System.out.println(1234);
            }
    

    所以结果是 100
    1234

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

    3.如果子类构造函数是这样写的

    public SonClass(int c) {
    
                    super(22);
                    //必须是第1行,否则不能编译
        //显式调用了super后,系统就不再调用无参的super()了;
                     System.out.println(1234);
            }
    

    执行结果是 22
    1234

    总结1:构造函数不能继承,只是调用而已。

    如果父类没有无参构造函数

    创建子类时,不能编译,除非在构造函数代码体中第一行,必须是第一行显式调用父类有参构造函数

    如下:

    SonClass (){
    
    super(777);//显示调用父类有参构造函数
    
    System.out.println(66);
    
    }
    

    如果不显示调用父类有参构造函数,系统会默认调用父类无参构造函数super();

    但是父类中没有无参构造函数,那它不是不能调用了。所以编译就无法通过了。

    总结2:创建有参构造函数后,系统就不再有默认无参构造函数。

    如果没有任何构造函数,系统会默认有一个无参构造函数。

    展开全文
  • java中的继承(子类调用父类构造方法还不懂).doc
  • Java子类调用父类构造方法.pdf
  • JAVA子类调用父类构造方法

    千次阅读 2021-03-06 16:59:23
    父类构造方法不能被子类继承。以下语句中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-04-16 16:45:12
    class FatherClass{ public FatherClass(){ System.out.println("父类 无参 构造函数"); } public FatherClass(int i){ System.out.println("父类 一个参数构造函数...
    class FatherClass{
    	public FatherClass(){
    		System.out.println("父类 无参 构造函数");
    	}
    	public FatherClass(int i){
    		System.out.println("父类 一个参数构造函数super = "+i);
    	}
    	public FatherClass(int i,String j){
    		System.out.println("父类 一个参数构造函数superi = "+i+",superj = "+j);
    	}
    

    }

    class SonClass extends FatherClass{
    public SonClass(){
    // super(22);//line 1
    System.out.println(“子类 无参 构造函数”);
    }
    public SonClass(int a){
    super(33,“Hello”);//line 2
    System.out.println("子类一个参数构造函数sub = "+a);
    }
    public void fun(int a){//子类中定义一个实例函数
    //super(33,“Hello”);//构造函数调用必须声明在构造函数中,这行代码不注释的话会报错
    System.out.println("子类一个参数构造函数sub = "+a);
    }
    }
    public class ConstructorExtend {//测试子类继承父类的构造函数
    public static void main(String args[]){
    // FatherClass fa = new FatherClass();
    // FatherClass fa1 = new FatherClass(100);
    // SonClass son = new SonClass();
    SonClass son1 = new SonClass(200);
    son1.fun(2);
    }
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36

    子类 调用 父类的构造函数:(构造函数不会被继承,只是被子类调用而已)

    1、子类所有的 构造函数 默认调用父类的无参构造函数(其实是默认省略掉了一行代码:super(););省略掉的这行super()代码可以自行添加到构造函数的第一行(必须是第一行,否则报错)

    2、如果父类没有定义构造函数,系统会默认定义一个无参无返回值的构造函数,子类继承时无需(无需的意思是:可以写可以不写)在子类构造函数中显式调用super( );如果父类定义了构造函数,系统不会再默认定义任何 无参无返回值 的构造函数,此时子类的构造函数中必须显式调用super( [arg0][,arg1]…),即,显式调用对应的参数个数、对应参数类型与此super( [arg0][,arg1]… )的父类构造函数。

    3、如果子类的某个构造函数 想 调用父类的其他的带参数的构造函数,在构造函数的第一行人为添加 super(val1,val2[,val3…]),super()括号中的变量数量由想调用的父类的构造函数中的变量数量决定。如代码中的line 2,调用的是父类构造函数中两个参数的构造函数,那么Super(20,“Hello”)就两个变量。

    4、自行添加super(val1,val2,…),就可以指定调用父类的那个参数类型和数量一致的构造函数。之后在此子类构造函数中,系统不会再默认调用父类无参构造函数;

    5、如果子类的每个构造函数都自行添加super([val1,]…),除非人为调用父类无参构造函数,否则的话父类的无参构造函数可以不写。有super指定调用的父类构造函数存在即可

    2017-7-25追加
    6、super指代 父类对象 可以在子类中使用 super.父类方法名();调用父类中的方法(无论是类方法还是实例方法都可以,除此调用实例方法的还可以在方法内部实例化再调用)
    **

    总之:存在继承关系的子类初始化,必须先调用父类构造器,你自己不显式调用,Java就强制默认让你调用父类无惨构造方法;

    **

    我说的语言比较繁琐,为了能说一丝不苟的说明问题,所以会这么啰嗦
    这个参考博客语言简洁:http://blog.csdn.net/youngstar70/article/details/60953578
    参考2:http://www.cnblogs.com/LittleRedPoint/p/3478015.html

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

    千次阅读 2020-05-20 20:44:47
    一、自动调用父类无参构造方法 //这是父类 public class SuperClass { //父类无参构造方法 public SuperClass(){ System.out.println("父类无参构造方法"); } //父类参构造方法 public SuperClass(String ...
  • 并且测试类里面实例化的是子类的带参构造方法,那么,此时不会先调用父类无参构造方法,而是先调用父类参构造方法再调用子类的有参构造方法; 下面上代码和结果: 结果是: 2.2、子类父类同时...
  • Java子类调用父类构造方法

    万次阅读 多人点赞 2017-09-29 14:49:15
    Java中,子类构造过程中,必须调用其父类的构造函数,是因为有继承关系存在时,子类要把父类的内容继承下来,通过什么手段做到的?   答案如下:   当你new一个子类对象的时候,必须首先要new一个父类...
  • java子类调用父类构造器函数

    万次阅读 多人点赞 2019-06-25 15:52:54
    java子类调用父类构造器函数详解
  • 像这样的对象声明,类名与构造方法不对应,学习过集合的人可能会知道 ArrayList类是List类的子类,这说明可以声明子类类型的父类对象。以下代码说明了这一特性: //文件名:Test3.java class Test{ int a=10; ...
  • Java里子类调用父类构造方法问题

    千次阅读 2021-02-13 01:44:43
    Java中,子类的构造过程中,必须调用其父类的构造函数,是因为有继承关系存在时,子类要把父类的内容继承下来,通过什么手段做到的?...构造方法是new一个对象的时候,必须要调的方法,这是规定,要new父类对象出...
  • 使用子类构造时候父类没有提供无参构造父类没有提供无参构造,在写子类构造器时候会报错 public class Animals { private String name; private int age; public Animals(String name, int age) { // super...
  • Java 子类构造方法与父类构造方法的问题 看一段代码 class Base{ public Base(String s){ System.out.print("B"); } } public class Derived extends Base{ public Derived (String s) { System.out.print...
  • 如果子类要调用父类无参构造函数,...此时, 如果父类仅定义了有参构造方法, 并且子类没有定义任何的构造方法(系统会为它提供一个无参构造方法, 然后隐式调用父类无参构造方法), 或子类定义的构造方法中没有显式调用父
  • 子类构造方法与父类构造方法的关系 先来看代码 public class Demo2 {//这是父类 public Demo2(){//写出父类默认的构造方法 System.out.println("demo2类的无参构造方法"); } public Demo2(int a){//父类有...
  • public class A { public String name;... System.out.println("父类参数构造方法"); } public A(String str){ this.name=str; System.out.println("父类的有参数构造方法"); } } ...
  • 关于子类调用父类构造方法的问题

    万次阅读 多人点赞 2018-03-29 22:01:04
    昨天班级有一个小测验,结果自己觉得还不错的错了好几道题...1.子类会默认调用父类无参构造方法举例来看:public class Derived extends Base { public Derived (String s) { System.out.println("这是子类的...
  • 如果父类没有不带参数的构造方法,且子类构造方法中有没有显式的调用父类其他构造方法,则java编译器会报错 父类无参子类无参=两者都输出(父类先、子类后) 父类(无参)++子类(没有super父类)=父类无参+...
  • 子类不可以继承父类构造方法,只可以调用父类构造方法子类中所有的构造函数都会默认访问父类中的空参数构造函数,这是因为子类的构造函数内第一行都有默认的super()语句。 super()表示子类在初始化时调用...
  • 所谓方法覆盖(重写)即父类中有一个方法子类中有一个和父类一模一样的方法(注意哈我这里又是父类又是 子类的当然是需要继承的(extends)) 下面既有方法的重写也有方法的调用未被重写之前的方法(还有注意...
  • /* 举个例子:在恰当的时间使用:super(实际参数列表) */ //测试程序 public class SuperTest03{ public static void main(String[] ... //构造方法 public Account(){ } public Account(String actno,double bal
  • java父类子类构造方法及方法的调用

    千次阅读 2019-04-13 13:43:44
    接着是调到父类构造方法去了,要执行setValue()方法,我天真地是调用A的setValue(),然而,现实是: 执行了B类的setValue,原因是我们目前是在执行B类的构造方法,所以如果A类和B类有相同的方法名,会优先调用...
  • 首先,构造方法本身会有一个隐式的无参构造(默认):①不写构造方法,类中的第一行代码事实上有一个默认的无参构造(系统会隐式为你写好)public class Student {private String name;// public Student() {} 隐式地...
  • java训练题目 编写程序实现子类父类构造方法的引用?
  • 一句话概括就是:子类一定会调用(不是继承)父类构造方法! 即遵循一个原则:子类的构造一定是在父类已构造的基础上!(以上属于自己归纳,可能有问题) 这句话要分为几种情况来理解(下面只讨论父类有构造函数)...
  • Java子类重写父类方法

    千次阅读 多人点赞 2020-05-20 21:35:49
    Java子类重写父类方法 一、方法名一致 //这是父类 public class SuperClass { public void test(){ System.out.println("我是父类方法"); } } //这是子类 public class SubClass extends SuperClass{ //...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 250,917
精华内容 100,366
关键字:

java无参子类覆盖父类的构造方法

java 订阅