如果调用类的一个构造器创建对象时 该构造器中调用了另一个构造器 那此时会创建一个对象还是两个对象？

谢谢楼主

谢谢了，很明了

感谢大神

这个问题很好解决，你就想一个类继承另一个类，那么子类中的构造器中默认省略了super();这一行代码，这条代码代表什么？代表了它调用了父类的构造器。但是当我们new一个子类对象的时候，是new出了一个子类对象和一个父类对象吗？显然不是的。代码证明如下：

1. public class Father
   
2. {
   
3.         String name;
   
4.         int age;
   
5.        
   
6.         public Father(){}//无参构造器（系统默认）
   
7.        
   
8.         public Father(String name, int age)//有参构造器
   
9.         {
   
10.                 this.name = name;
    
11.                 this.age = age;
    
12.         }
    
13. }
    
14. 
    
15. public class Son extends Father {
    
16.         String school;
    
17.        
    
18.         public Son()
    
19.         {
    
20.                 super();//这行代码不写的话，系统会默认加上并且隐藏的。它调用了父类构造器。
    
21.         }
    
22.         public Son(String name, int age, String school)
    
23.         {
    
24.                 super.name = name;
    
25.                 super.age = age;
    
26.                 this.school = school;
    
27.         }
    
28. }
    
29. 
    
30. public class NewTest
    
31. {
    
32.         public static void main(String[] args)
    
33.         {
    
34.                 Son Jim = new Son();//new 一个子类，很明显子类构造器中调用了父类构造方法，所以只是创建了一个子类对象。
    
35.         }
    
36. }
    

复制代码

一个对象！
我测试了一下：

1. package cn.itcast;
   
2. 
   
3. public class Test {
   
4. 
   
5.             public Test() {
   
6.                 this(0);
   
7.                 System.out.println(this.hashCode());
   
8.             }
   
9.             
   
10.             public Test(int i) {
    
11.                 System.out.println(this.hashCode());
    
12.             }
    
13.             
    
14.             public static void main(String[] args) {
    
15.                 new Test();
    
16.             }
    
17. }

复制代码

调用构造器，最终是返回对象的实例，外部可以访问，如果创建两个的话，返回的实例是1，还是2呢，貌似没有意义。最终只需要一个对象，即：new 了一次就创建了一个对象。
再说如果创建了两个但是只有一个有对象句柄，即可达，另一个则会不可达，这样后者就会成为垃圾资源，被垃圾回收。
构造器作用：
1.创建java对象的重要途径.
2.对系统产生的对象初始化
3.并将该对象作为返回值返回，是外部程序可以访问