精华内容
下载资源
问答
  • 子类继承父类构造器
    2021-11-26 16:15:30
    • 子类继承父类时
      1、若父类显式写出了有参构造器,父类必须显式写出无参构造器。
      2、若父类没有显式写出有参构造器,父类的无参构造器可写可不写
    • 子类无法重写父类的无参与有参的构造器
    • 在子父继承中
      使用父类的变量和函数分为两种情况:
      1、直接调用(子类没用重写父类的方法)
      2、super关键字调用(调用父类中被子类重写的方法)
    更多相关内容
  • Java子类继承父类构造器

    千次阅读 2018-05-04 11:16:26
    2.子类父类构造器执行顺序?二、创建父类创建父类Animal,有两个构造器class Animal{ private Integer high; public Animal() { System.out.println("Animal()"); } public Animal(Integer high)...

    一、研究问题

    1.子类如何继承父类的构造器?

    2.子类与父类构造器执行顺序?

    二、创建父类

    创建父类Animal,有两个构造器

    class Animal{
        private Integer high;
    
        public Animal() {
            System.out.println("Animal()");
        }
    
        public Animal(Integer high) {
            System.out.println("Animal(Integer high)");
            this.high = high;
        }
    
    //    set、get方法
        public Integer getHigh() {
            return high;
        }
    
        public void setHigh(Integer high) {
            this.high = high;
        }
    }

    三、创建子类

    创建子类Dog,继承Animal,有四个构造器

    class Dog extends Animal{
        private String name;
    
        public Dog() {
            System.out.println("Dog()");
        }
    
        public Dog(String name) {
            this.name = name;
            System.out.println("Dog(String name)");
        }
    
        public Dog(Integer high) {
            super(high);
            System.out.println("Dog(Integer high)");
        }
    
        public Dog(Integer high, String name) {
            super(high);
            this.name = name;
            System.out.println("Dog(Integer high, String name)");
        }
    
    //    set、get方法
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    }

    四、调用子类构造器

    public class MyMain {
        public static void main(String[] args) {
            System.out.println("- - - - - - - new Dog() - - - - - - -");
            Dog dog = new Dog();
    
            System.out.println("- - - - - - - new Dog(Integer high) - - - - - - -");
            Dog highDog = new Dog(180);
    
            System.out.println("- - - - - - - new Dog(String name) - - - - - - -");
            Dog nameDog  = new Dog("张二狗");
    
            System.out.println("- - - - - - - new Dog(Integer high, String name) - - - - - - -");
            Dog highNameDog = new Dog(180,"张二狗");
    
        }
    }

    五、输出结果

    - - - - - - - new Dog() - - - - - - -
    Animal()
    Dog()
    - - - - - - - new Dog(Integer high) - - - - - - -
    Animal(Integer high)
    Dog(Integer high)
    - - - - - - - new Dog(String name) - - - - - - -
    Animal()
    Dog(String name)
    - - - - - - - new Dog(Integer high, String name) - - - - - - -
    Animal(Integer high)
    Dog(Integer high, String name)

    六、结论

    1.子类通过super调用父类构造器

    子类通过super()调用父类无参构造器;通过super(参数)调用父类有参构造器;如果不写super,子类默认调用父

    类无参构造器

    2.子类创建对象时,父类构造器会先执行。

    因为在构造器中super必须放在第一个执行,否则会报错


    展开全文
  • 关于子类继承父类构造器 super问题 当子类想继承父类时,父类必须有无参的构造方法,如果不主动添加系统会默认添加一个无参的构造方法,此时子类可以顺利继承父类 但是当父类添加了一个带参的构造方法时,此时系统将...

    当子类想继承父类时,父类必须有无参的构造方法,如果不主动添加系统会默认添加一个无参的构造方法,此时子类可以顺利继承父类
    但是当父类添加了一个带参的构造方法时,此时系统将不会再默认添加无参的构造方法,所以此时必须自己手动添加一个无参的构造方法,这样才能保证被子类顺利的继承

    在实例化子类的时候会自动的实例化父类,如果此时的父类还继承了其他的类,那么便会逐级的向上查询,知道找到顶级的父类,然后开始逐个的实例化,在实例化的同时

    便会自动调用无参的构造方法,但是如果想要调用父类的带参的构造方法,此时就必须通过super(i)进行调用

    public class Father {
    	 //年龄  
        private int age;  
        //仅有一个带参数的构造方法  
        public Father (int i){  
        	this.age = i;  
        	System.out.println("实例化父类 ag = " + age);  
        }  
        public Father() {
        	System.out.println("这是父类的无参的构造方法");  
        	// TODO Auto-generated constructor stub
        }
        //main方法  
        public static void main (String []  args) {  
        	//实例化对象时必须指定参数以运行对应的构造方法实例(构造)对象  
        	Father fa = new Father(40);  
        	Father fa1 = new Father(50); 
        	Father fa2 =new Father();
        }  
    }
     
     
    实例化父类 ag = 40
    实例化父类 ag = 50
    这是父类的无参的构造方法
    
    public class Son extends Father{  
    	private int age;  
    	//子类构造方法——必须先显式调用父类构造方法  
    	public Son(int i) {  
    		super(i);//必须先调用父类的构造方法,然后才能写子类构造方法的其他逻辑    可以注释掉这句看运行结果
    	    this.age = i - 20;  
    		System.out.println("实例化子类 age = " + age);  
    	}  
    	public Son() {
    		super();   //可以注释掉这句然后看运行结果
    		System.out.println("这是子类的无参构造方法");
    	}
    	//main方法  
    	public static void main (String [] args) {  
    		//实例化子类Son  
    		Son so = new Son(40);  
    		Son so1 = new Son(50);
    		Son so2 =new Son();
    	}  
    } 
     
     
    实例化父类 ag = 40
    实例化子类 age = 20
    实例化父类 ag = 50
    实例化子类 age = 30
    这是父类的无参的构造方法
    
    

    转载自https://blog.csdn.net/lzh_86/article/details/78187379

    展开全文
  • 1.子类继承了所有的属性和方法,但是私有属性和方法不能在子类直接访问,要通过公共的方法去访问。 package com.kxy.extend_; public class Base { public int n1=100; protected int n2=200; int n3=300; ...

    1.子类继承了所有的属性和方法,但是私有属性和方法不能在子类直接访问,要通过公共的方法去访问。

    package com.kxy.extend_;
    
    public class Base {
    	public int n1=100;
    	protected int n2=200;
    	int n3=300;
    	private int n4=400;
    }
    

    package com.kxy.extend_;
    
    public class Sub extends Base{
    	public Sub() {//子类的无参构造器
    
    	}
    	public void sayOk() {
    		//第一句话:非私有的属性和方法可以在子类访问,私有的属性和方法不能被子类访问
    		System.out.println(n1+" "+n2+" "+n3+" "  ) ;
    		System.out.printLn(n4);//错误	
    	}
    }
    

    怎么通过公共的方法去访问?我们在父类写上这个方法:

    package com.kxy.extend_;
    
    public class Base {
    	public int n1=100;
    	protected int n2=200;
    	int n3=300;
    	private int n4=400;
    	public int getN4() {//第二句话:通过公共的方法去访问子类原本不能访问的私有属性
    		return n4;
    	}
    }
    

    在子类方法里调用它就可以访问了。

    package com.kxy.extend_;
    
    public class Sub extends Base{
    	public Sub() {//子类的无参构造器
    
    	}
    	public void sayOk() {
    		//第一句话:非私有的属性和方法可以在子类访问,私有的属性和方法不能被子类访问
    		System.out.println(n1+" "+n2+" "+n3+" "  ) ;
    //		System.out.printLn(n4);//错误
    		//但是我们可以通过公共的方法去访问
    		System.out.println("n4="+getN4());
    		
    	}
    }
    

    我们在主类调用它:

    package com.kxy.extend_;
    
    public class ExtendsDetail {
    	public static void main(String[] args) {
    		Sub sub=new Sub();
    		sub.sayOk();
    	}
    }
    

    2.子类必须 调用父类的构造器,完成父类的初始化

    package com.kxy.extend_;
    
    public class Base {
    	public Base() {//父类的无参构造器
    		System.out.println("base()被调用了...");
    	}
    }
    

    package com.kxy.extend_;
    
    public class Sub extends Base{
    	public Sub() {//子类的无参构造器
    
    	}
    }
    
    package com.kxy.extend_;
    
    public class ExtendsDetail {
    	public static void main(String[] args) {
    		Sub sub=new Sub();
    	}
    }
    

    为什么创建子类的时候,子类一定会调用父类的构造器里的方法呢?

    因为在子类的无参构造器里,系统默认添加了一行代码super();

    package com.kxy.extend_;
    
    public class Sub extends Base{
    	public Sub() {//子类的无参构造器
    		super();//程序默认调用父类无参构造器
    	}
    }
    

    即使你不写,它也会被立即执行。如果不懂super是什么可以去看作者的另一个博客,点击跳转:

    super关键字什么时候使用?super的适用场景是?_❀༊烟花易冷ღ࿐❀的博客-CSDN博客

    3.当创建子类对象时,不管使用子类的哪个构造器,默认情况下总会去调用父类的无参构造器,如果父类没有提供无参构造器,则必须在子类的构造器中用super去指定使用父类的哪个构造器完成父类的初始化操作,否则编译不会通过。

    我们在子类原来基础上创建有参构造器

    package com.kxy.extend_;
    
    public class Sub extends Base{
    	public Sub() {//子类的无参构造器
    //		super();//程序默认调用父类无参构造器
    		System.out.println("Sub()被调用了...");
    	}
    	public Sub(String name) {
    		System.out.println("Sub(name)被调用了...");
    	}
    }
    

    当我们new一个有参的子类对象时

    package com.kxy.extend_;
    
    public class ExtendsDetail {
    	public static void main(String[] args) {
    		Sub sub=new Sub();
         	System.out.println("=========");
    		Sub sub2=new Sub("jack");//new一个有参子类对象
    
    	}
    }
    

     控制台输出,分割线上面是sub,下面是sub2

    通过对比我们可以发现,当我们new一个指定参数的对象,就间接的调用了指定的构造方法。

    如果父类没有提供无参构造器,则必须在子类的构造器中用super去指定使用父类的哪个构造器完成父类的初始化操作,否则编译不会通过。怎么理解?

    像这样,我们把父类的无参构造器给注释掉了,此时有参构造器就会覆盖掉原有的无参构造器。

    package com.kxy.extend_;
    
    public class Base {
    
    //	public Base() {//父类的无参构造器
    //		System.out.println("base()被调用了...");
    //	}
    	public Base(String name,int age) {
    		System.out.println("base(name,age)被调用了...");
    	}
    
    }
    

    我们来看看子类的情况如何?

    可以看到,此时子类不管是有参构造器还是无参构造器,都报了相同的错误:父类的无参构造器没有定义,必须选择其他的构造器。

    那么解决方案是什么呢?

    package com.kxy.extend_;
    
    public class Sub extends Base{
    	public Sub() {//子类的无参构造器
    //		super();//程序默认调用父类无参构造
    		super("Tom",15);
    		System.out.println("Sub()被调用了...");
    	}
    	public Sub(String name) {
    		super("Jam",18);
    		System.out.println("Sub(name)被调用了...");
    	}
    }
    

    所以,如果父类没有提供无参构造器,则必须在子类的构造器中用super去指定使用父类的哪个构造器完成父类的初始化操作。

    同样,在子类的有参构造器也是如此。

    通过对比上次的控制台输出,我们总结一个规律。

    1.如果父类没有写无参构造器,那么系统默认给你调用无参构造器,只是里面没有任何方法。

    2.如果父类写了无参构造器,那么子类必须调用父类无参构造器。

    3.如果父类写了无参构造器,又写了有参构造器,那么可以通过super指定选择使用哪个构造器,但是每个构造方法里只能super一次。也可以不使用super,那么相当于所有的子类构造方法都写了一个隐形的super();也就是默认使用无参构造器。

    4.如果父类没有写无参构造器,但写了有参构造器,那么有参覆盖无参,此时子类构造方法必须用super来完成初始化。

    ps:注意:在构造方法里,super必须在方法体里最前面。否则会报错。

    以下是关于本次博客的核心梳理:

    1.子类继承了所有的属性和方法,但是私有属性和方法不能在子类直接访问,要通过公共的方法去访问。

    2.子类必须 调用父类的构造器,完成父类的初始化

    3.当创建子类对象时,不管使用子类的哪个构造器,默认情况下总会去调用父类的无参构造器,如果父类没有提供无参构造器,则必须在子类的构造器中用super去指定使用父类的哪个构造器完成父类的初始化操作,否则编译不会通过。

    展开全文
  • 子类不能继承父类的构造器,但是在子类生成实例的时候必然会先调用父类的构造器,也就是在子类...若父类的构造器是带参构造器,则子类的构造器必须显式地用super(xx)调用父类构造器子类继承父类非private及非fin...
  • JAVA子类继承父类时的构造方法

    千次阅读 2021-12-03 16:52:22
    如果父类有自己的构造方法(这时父类不会有默认无参的构造方法),那么在子类构造方法中,必须要调用父类的某个构造方法,而且必须是在构造方法的第一个语句中进行调用。 此时再创建子类实例就需要显示的调用父类的...
  • 【代码】Java继承 子类实例化:子类构造器和父类构造器
  • java继承中子类和父类构造器的相关内容 运行后我们会发现,先调用了父类的无参构造器完成父类初始化,后才调用了子类的构造器 // 当子类对象创建时,不管使用子类的哪个构造器,默认情况下会先调用父类的...
  • 所以在子类继承父类后,必须要在子类构造方法中调用父类的构造方法。 eg: public class Test { public static void main(String[] args) { //通过无参构造创建Zi对象并调用baby() Zi xx = new Zi(); xx.baby();...
  • 子类继承父类,父类中的构造器

    千次阅读 2016-11-03 12:06:58
    子类继承父类时,父类中必需有无参构造器,子类才可以继承父类? 可是父类中只有有参构造器时,就不能实现子类继承父类了吗?
  • 子类重写父类构造器以及其他方法

    千次阅读 2018-05-18 22:04:51
    若父类重写了自身的构造器,并且还实现了自己的方法,那么,当子类继承父类后,重写自身的构造器和重写父类的其他方法时,搭配super()或者super.method()时候,会出现什么现象呢? 先看构造器 public class ...
  • java子类调用父类构造器函数

    万次阅读 多人点赞 2019-06-25 15:52:54
    java子类调用父类构造器函数详解
  • 子类继承父类后,必须显式或隐式的调用父类的构造器。 1.父类中没有显式提供构造器时,此时系统默认提供了父类的空参构造器,子类可以不去提供构造器,因为系统默认提供了隐式的子类的构造器,而在子类的构造器...
  • JAVA子类调用父类构造方法

    千次阅读 2021-03-06 16:59:23
    父类构造方法不能被子类继承。以下语句中MyException类继承了java.lang.Exception类。public class MyException extends Exception{} //MyException类只有一个隐含的默认构造方法尽管在Exception类中定义了如下...
  • 每个类都有构造函数,继承类在生成对象的时候,是不会自动调用父类构造函数的, 因此你必须在 init() 函数中显式调用父类构造函数。 它们的执行顺序是 子类构造函数 -> 父类构造函数。
  • 子类已经继承了父类,通过一个父类集合,将子类加进去,但是对父类进行遍历时,Business子类却不显示父类构造器的属性内容
  • JAVA子类继承父类

    千次阅读 2021-03-01 06:34:01
    1、类的继承知识点 (1)java不支持多重继承,也就是说子类至多只能有一个父类 (2)子类继承了其父类中不是私有的成员变量和成员方法,作为自己的成员变量和方法 (3)子类中定义的成员变量和父类中定义的成员变量...
  • 父类构造方法 子类非静态代码块 子类构造方法 2、构造器调用顺序 基类递归调用 成员构造器按声明顺序调用 该类构造器 3、多态 this.method(o) > super.method(o) > this.method((super)o) > super....
  • java子类调用父类构造方法

    千次阅读 2021-04-20 10:00:52
    java子类调用父类构造方法 来源:https://www.cnblogs.com/sunnychuh/archive/2011/09/09/2172131.html(本人用来方便查看笔记,不用于其他任何用途) java继承中对构造函数是不继承的,只是调用(隐式或显式)。 ...
  • java 子类继承父类各方法的执行顺序

    千次阅读 2022-06-24 10:41:34
    继承关系
  • java可以继承父类构造器

    千次阅读 2021-03-17 20:45:42
    子类继承了父类,若父类的构造方法没有重载,那么,子类的构造方法也不需要通过super调用父类构造方法。一个类中如果构造方法重写了并且带了参数,那么这个类的原来系统默认的无参构造方法便消失。由此,若一个父类...
  • 不管我们是否使用super调用来执行父类构造器的初始化代码,子类构造器总会调用父类构造器一次。子类构造器调用父类构造器分如下几种情况:1.子类构造器执行体的第一行使用super显式调用父类构造器,系统将根据super...
  • 1.子类继承父类后,可以直接调用父类的变量和方法,那为什么还用super调用呢? 原因:如果子类对父类的变量和方法进行了重写,你又想再使用父类的方法,这是就需要super来调用,否则默认调用你在子类中重写的变量和...
  • scala的子类调用父类构造器的使用

    千次阅读 2019-06-14 08:54:49
    //注意scala只有主构造器才可以直接调用父类构造器(主构造器和辅助构造器)子类的辅助够造器无法直接调用父类的够造放法必须通过子类中的主够造器来进行间接调用父类的够造器 object CaoLei { def main(args: Array...
  • 子类不能继承父类构造函数 构造方法是一个类独有的方法,不会被其他类继承 在构造子类时,一定会调用父类的构造方法,但是区别调用和继承 当父类有无参构造方法时 子类实例化对象时,会先调用父类的构造方法,...
  • 特点: 子类的全部构造器默认一定会先访问父类得到无参数构造器,再执行...2,子类继承父类,子类就得到了父类的属性和行为. 所以调用子类构造器初始化子类对象的时候,需要先调用父类构造器去初始化继承自父类的成员。 ...
  • 子类能不能继承父类构造函数

    千次阅读 2021-04-09 09:59:56
    一、子类继承父类构造函数? 答案是不能的。构造函数是创建对象时完成的初始化,当我们在new一个对象并传入参数时,会自动调用有参数的构造完成参数的初始化,也就是属性的初始化。试想子类继承父类构造...
  • 子类父类构造器关系

    千次阅读 2016-04-07 11:34:38
    父类:Base 子类:Driver 1.子父类都是默认构造器: ...如果父类base class只有缺省构造函数,...因为当你试图产生一个子类的实例时,首先要执行子类的构造函数,但是由于子类继承父类,所以子类的缺省构造函数自

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 167,274
精华内容 66,909
关键字:

子类继承父类构造器