子父类构造函数的调用演示,区分this()和super()

首先this()和super()语句不能手动共存在一个函数中,因为这两个语句都必须在函数的第一行,

JVM虚拟机不允这种情况出现


一.当程序如下时,执行结果是:   fu-空构造函数 run
                              zi-空构造函数 run
                              zi...3
                              60

当主函数执行 Zi z = new Zi(3);这句代码时,调用顺序是:
       1.子类建立new Zi(3);对象时,先调用子类中与之对应的构造函数,也就是Zi(int x)
       2.此构造函数第一行代码时 this(),接下来会调用空参数的构造函数Zi();
          因为第一行存在了this()语句,所以不可能再存在隐式的super()语句
       3.空参数构造函数Zi()的第一行有一个隐式的super()语句,所以程序会执行父类中的空参数构造函数Fu();
       4.在Fu()中,首先会把60赋给变量num,然后执行SOP语句,结果是:fu-空构造函数 run
       5.然后执行Zi()中的SOP语句,结果是:zi-空构造函数 run
       6.接下来程序会回到Zi(3)构造函数中执行SOP语句,结果是: zi...3
       7.最后执行主函数中的SOP语句:num=60,因为在执行Fu()时,已经给num赋值了

class Fu
{
	int num ;
	Fu()
	{
		num= 60;
		System.out.println("fu-空构造函数 run");
	}
	Fu(int  x)
	{
		System.out.println("fu ...."+x);
	}
}

class Zi extends Fu
{
	Zi()
	{
		System.out.println("zi-空构造函数 run");
	}
	Zi(int x)
	{
		this();
		System.out.println("zi..."+x);
	}
}

class  ExtendsDemo3
{
	public static void main(String[] args) 
	{
		Zi z = new Zi(3);
		System.out.println("num="+z.num);
		
	}
}

二,当程序如下时,执行结果是:

                             fu...3
                             zi...3
                             num=0

    下面的代码跟上面代码的区别就是程序没有执行父类中的空参数构造函数,所以就没有对num进行赋值,
  num的打印值是默认的值0

class Fu
{
	int num ;
	Fu()
	{
		num= 60;
		System.out.println("fu-空构造函数 run");
	}
	Fu(int  x)
	{
		System.out.println("fu..."+x);
	}
}

class Zi extends Fu
{
	Zi()
	{
		System.out.println("zi-空构造函数 run");
	}
	Zi(int x)
	{
		super(x);
		System.out.println("zi..."+x);
	}
}

class  ExtendsDemo3
{
	public static void main(String[] args) 
	{
		Zi z = new Zi(3);
		System.out.println("num="+z.num);
		
	}
}

三,如果在子父类中定义有各自的静态代码块和构造代码块
     程序的执行顺序  
父类的静态代码块--子类的静态代码块---父类的构造代码块--父类的构造函数--子类的构造代码块--子类的构造函数

class Fu
{
	int num ;
	static
	{
      System.out.println("fu-静态代码块 run");
	}
	{
      System.out.println("fu-构造代码块 run");
	}
	Fu()
	{
		num= 60;
		System.out.println("fu-空构造函数 run");
	}
	Fu(int  x)
	{
		System.out.println("fu..."+x);
	}
}

class Zi extends Fu
{
	static
	{
      System.out.println("zi-静态代码块 run");
	}
	{
      System.out.println("zi-构造代码块 run");
	}
	Zi()
	{
		System.out.println("zi-空构造函数 run");
	}
	Zi(int x)
	{
		super(x);
		System.out.println("zi..."+x);
	}
}

class  ExtendsDemo3
{
	public static void main(String[] args) 
	{
		Zi z = new Zi(3);
		System.out.println("num="+z.num);
		
	}
}


  • 1
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: 在Java中,子类构造函数在创建对象时会默认调用父类的无参构造函数。如果父类中没有无参构造函数,那么子类构造函数必须在第一行显式的调用父类的有参构造函数子类构造函数调用父类构造函数的方式有两种: 1. 使用super关键字调用父类构造函数 使用super关键字调用父类构造函数时,需要在子类构造函数的第一行使用super关键字,并传递相应的参数,如: ``` public class Son extends Father { public Son(String name, int age) { super(name, age); // 子类构造函数其他操作 } } ``` 2. 在父类中定义有参构造函数,并在子类构造函数调用父类中定义有参构造函数时,子类构造函数不必使用super关键字调用父类构造函数,只需在子类构造函数中传入相应的参数即可,如: ``` public class Father { String name; int age; public Father(String name, int age) { this.name = name; this.age = age; } } public class Son extends Father { public Son(String name, int age) { // 子类构造函数中不需要调用super关键字 // 父类中有参构造函数可以直接使用 this.name = name; this.age = age; // 子类构造函数其他操作 } } ``` 以上就是子类构造函数调用父类构造函数的两种方式,具体使用哪种方式要根据实际情况来决定。 ### 回答2: 在面向对象的编程中,子类继承了父类的属性和方法,并且可以在此基础上添额外的属性和方法。在子类构造函数中,我们需要调用父类构造函数来初始化继承的属性。 子类通过使用super关键字来调用父类构造函数super关键字既可以用来调用父类构造函数,也可以用来调用父类的方法。调用父类构造函数有两种方式:一是调用无参的构造函数,二是调用有参的构造函数。 如果父类定义了无参构造函数子类可以直接调用它来初始化继承的属性。例如: ``` public class Parent{ private int age; private String name; public Parent(){ age = 20; name = "ZhangSan"; } } public class Child extends Parent{ private String school; public Child(){ super(); // 调用父类的无参构造函数 school = "Tsinghua University"; } } ``` 如果父类定义了有参构造函数,就需要在子类构造函数中显示地调用它。例如: ``` public class Parent{ private int age; private String name; public Parent(int age,String name){ this.age = age; this.name = name; } } public class Child extends Parent{ private String school; public Child(int age,String name,String school){ super(age,name); // 调用父类的有参构造函数 this.school = school; } } ``` 在调用父类构造函数时,需要注意以下几点: 1. super()必须是子类构造函数中的第一行代码; 2. 如果子类调用父类构造函数是有参构造函数,也要确保父类有相应的构造函数; 3. 如果子类没有显示地调用父类构造函数,Java编译器会自动调用父类的无参构造函数。 总之,在子类构造函数调用父类构造函数是初始化继承属性的必要步骤,也是实现类之间继承的核心机制。对于Java的面向对象程序设计,这一点不容忽视。 ### 回答3: 在面向对象编程中,一个类可以作为另一个类的子类(也称为派生类)。子类可以继承父类的属性和方法,并且还可以添自己的属性和方法。在子类构造函数中,可以通过调用父类构造函数来实现对父类属性的赋值。 在C++中,子类构造函数调用父类构造函数的方式是在子类构造函数初始化列表中调用父类构造函数。如下所示: ``` class Parent{ public: Parent(int a){ this->a = a; } private: int a; }; class Child: public Parent{ public: Child(int a, int b): Parent(a){ //调用父类构造函数 this->b = b; } private: int b; }; ``` 在上述代码中,Child是Parent的子类。当Child的构造函数调用时,会首先调用Parent的构造函数,初始化Parent类中的成员变量a,然后再初始化Child类中的成员变量b。 需要注意的是,在子类构造函数中,必须首先调用父类构造函数,因为子类继承了父类的属性和方法,需要确保这些属性和方法在子类对象被创建时已经得到正确的初始化。 除了初始化列表,还可以在子类构造函数中通过调用父类构造函数的方式来实现对父类属性的赋值,但是这种方式更繁琐,且容易出错。因此,在子类构造函数中,最好采用初始化列表的方式调用父类构造函数进行赋值。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值