当没有显性的创建构造函数时，有一个默认的空参数构造函数存在，且其把属性都初始化了。
如下例子中，若输出x的值可以得到0 。

当我显性的创建构造函数时，默认的空参数构造函数就没有了对吧。

那假如我并不在里面把属性初始化，如下：
class A
｛
     private int x；
     A（）
         ｛

           ｝

   这里有 A的 方法。。。
｝

为什么我还是可以通过new A（） 来初始化对象A呢？

或者换种问法

我这里并没有去初识化属性x了，默认空参数构造函数也没有了，为什么输出x的值还是0呢？

我知道成员变量是被默认初识化了的，这里关注的问题是new A（）时构造函数的初识化作用。



为什么还可以

public class test {
        public static void main(String[] args) {
                A a=new A();
        System.out.println(a.x);
       
        }
       

}
class A{
       
             int x;
             A(){};
                

}
  输出结果是0， x私有属性的话是需要封装的
初始化的时候给了x 一个空间。默认应该为零！

c++的构造函数才有显式调用和隐式调用
没有显式构造和隐式构造的说法

我猜你是想问内存的问题
源代码是存放在代码段中
全局变量和静态变量是存放在数据段内存区
局部变量存放在栈内存区，是系统规定好的一段连续的内存区域
new运算符初始化的对象数据存放在堆内存区，是非连续的内存区域
还有常量池存放常量

艮昕辶 发表于 2014-3-6 19:04
c++的构造函数才有显式调用和隐式调用
没有显式构造和隐式构造的说法

。。。Java的方法有隐式和显式吧 比如a.show（x）中a是隐 x是显

我问得是构造函数在对对象初识化中的对对象类的属性初识化的问题噢

不过 还是谢谢你先^ _ ^

都已经分配内存了，当然有值了

当有显性构造函数时，默认空构造函数就自行消失。

当有显性构造函数时，默认空构造函数就会自行消失。
而本题中定义的是显性空构造函数，其作用的效果跟默认空构造函数是一个结果。故原程序输出x的值可以仍得到0 。

其实LZ自己已经知道答案了，只是有一部分没想通。显然x的值为0是被默认初始化了，int类型变量默认初始化的值就是0。关于默认初始化可以理解为：只要定义了变量，调用这个变量之前都要进行默认初始化。这是机器做的动作，因为创建变量时变量的值谁也说不好，机器这么做的原因我觉得是谨慎:lol。
很多时候我们定义变量还会跟着显示初始化，比如 int x=8;
它们的先后顺序是默认初始化>显示初始化>构造函数初始化.

关于“new A（）时构造函数的初识化作用”
其实如果你什么都不做，也不加private，这时候自己写的空参数的构造函数就没什么意义了，即使你不写，系统自动给加一个隐式的空参数构造函数，作用一样。
可以这么说：如果你要写构造函数，那系统是希望你做一些事情的，比如给对象的某些特殊属性进行初始化，这是设计构造函数的原意。如果你不想要用这个功能，或者不需要，那完全不必写，系统可以帮你做初始化动作，保证正常运行。

当然自己写空参数构造函数也不是完全无用的，举个例子：
建立了一个类，禁止建立本类的对象。这时候你就需要自己写构造函数了，在前边加上private就OK。如下代码：

1. class Person_1
   
2. {               
   
3.         private Person_1() //加private，禁止建立本类对象
   
4.         {        
   
5.         }        
   
6. }
   
7.         
   
8. class  Test_1
   
9. {
   
10.         public static void main(String[] args)
    
11.         {
    
12.                 Person_1 p= new Person_1();//编译时会报错，不会成功建立对象
    
13.         }
    
14. }

复制代码

关于执行几种初始化执行顺序，建议可以参考一下毕老师的第6天-第7个视频。加一段代码和毕老师的总结。希望能帮助理解

1. class Person_1
   
2. {
   
3.         private int age;//默认初始化
   
4.         private String name="haha";        //默认初始化 + 显式初始化
   
5.         private static String country="China";
   
6.         
   
7.         {        //构造代码块，给所有对象初始化
   
8.                 System.out.println(name+"..."+age);
   
9.         }
   
10. 
    
11.         Person_1(String name,int age)
    
12.         {        //构造函数初始化，给特定对象初始化
    
13.                 this.name=name;
    
14.                 this.age=age;
    
15.         }
    
16. 
    
17. }
    
18. class PersonDemo_1
    
19. {
    
20.         public static void main(String[] args)
    
21.         {
    
22.                 Person_1 p = new Person_1("zhangsan",20);
    
23.         }
    
24. }
    
25. 
    
26. /*总结
    
27. Person_1 p = new Person_1("zhangsan",20)；
    
28. 该句话都做了什么事情？
    
29. 1、因为new用到了Person_1.class文件，所以会先找到Person_1.class文件并加载到内存中
    
30. 2、如果有的话，执行该类中的static代码块，给Person_1.class类进行初始化
    
31. 3、在堆内存中开辟空间，分配内存地址。
    
32. 4、在堆内存中建立对象的特有属性，并进行默认初始化。
    
33. 5、对属性进行显示初始化。
    
34. 6、对对象进行构造代码块初始化
    
35. 7、对对象进行对应构造函数初始化
    
36. 8、将地址值赋给栈内存中的p变量。
    
37. */
    

复制代码

1. //我们以Person类为例，看一下自定义无参构造函数与系统默认构造函数的区别
   
2. class Person {
   
3.        
   
4.         private int age;
   
5.         private String name;
   
6.        
   
7.         //分别查看自定义无参构造函数与系统默认构造函数生成的代码
   
8.         //通过 javap 指令查看
   
9.         //会发现他们的反编译代码是一样的
   
10.         public Person() {
    
11.                
    
12.         }
    
13. }
    
14. 
    
15. //由javap -c 指令生成反编译码如下
    
16. //class com.uc.TZone.Person {
    
17. //private int age;
    
18. //
    
19. //private java.lang.String name;
    
20. //
    
21. //com.uc.TZone.Person();
    
22. //  Code:
    
23. //     0: aload_0
    
24. //     1: invokespecial #12    //Method java/lang/Object."<init>":()V 该函数完成类实例变量的初始化
    
25. //     4: return
    
26. //}
    
27. 
    
28. //再就是实例类中字段的初始化问题，这个其实与他们的申明顺序有直接的关系
    
29. //我们仍然通过他们的反编译代码来查看
    
30. class Person {
    
31.        
    
32.         {
    
33.                 age = 15;
    
34.         }
    
35.         private int age = 10;
    
36.        
    
37.         private String name = "uc";
    
38.        
    
39.         {
    
40.                 name = "haha";
    
41.         }
    
42.        
    
43.         @Override
    
44.         public String toString() {
    
45.                 return "Person [age=" + age + ", name=" + name + "]";
    
46.         }
    
47.        
    
48. //        public Person() {
    
49. //                age = 25;
    
50. //                name = "happy";
    
51. //        }
    
52. }
    
53. 
    
54. //在这里大家可以考虑下对象创建成功后 age 与 name的值
    
55. //在main函数中调用 System.out.println(new Person());
    
56. //结果为：Person [age=10, name=haha]
    
57. //还是通过 查看反编译代码来分析原因
    
58. 
    
59. /*
    
60.    com.uc.TZone.Person();
    
61.    Code:
    
62.       0: aload_0
    
63.       1: invokespecial #12                 // Method java/lang/Object."<init>":()V
    
64.                                                                                  //这里系统首次初始化
    
65.       4: aload_0
    
66.       5: bipush        15                                        //这里为age首次赋值 15
    
67.       7: putfield      #14                 // Field age:I
    
68.      10: aload_0
    
69.      11: bipush        10                                        //再次给age赋值 10 所有 最后结果为10
    
70.      13: putfield      #14                 // Field age:I
    
71.      16: aload_0
    
72.      17: ldc           #16                 // String uc
    
73.      19: putfield      #18                 // Field name:Ljava/lang/String;
    
74.      22: aload_0
    
75.      23: ldc           #20                 // String haha
    
76.      25: putfield      #18                 // Field name:Ljava/lang/String;
    
77.                                                                                 // name 字段也是一样
    
78.      28: return
    
79. */
    
80. 
    
81. 
    
82. //大家可以再考虑下在上面的Person类中加入如下的构造函数
    
83. /*
    
84. * public Person() {
    
85. *                
    
86. *                 age = 25;
    
87. *                 name = "happy";
    
88. *
    
89. * }
    
90. */
    
91. 
    
92. //javap 反编译后如下
    
93. /*
    
94. * public com.uc.TZone.Person();
    
95.    Code:
    
96.       0: aload_0
    
97.       1: invokespecial #42                 // Method java/lang/Object."<init>":()V
    
98.       4: aload_0
    
99.       5: bipush        15
    
100.       7: putfield      #20                 // Field age:I
     
101.      10: aload_0
     
102.      11: bipush        10
     
103.      13: putfield      #20                 // Field age:I
     
104.      16: aload_0
     
105.      17: ldc           #44                 // String uc
     
106.      19: putfield      #31                 // Field name:Ljava/lang/String;
     
107.      22: aload_0
     
108.      23: ldc           #46                 // String haha
     
109.      25: putfield      #31                 // Field name:Ljava/lang/String;
     
110.      28: aload_0
     
111.      29: bipush        25
     
112.      31: putfield      #20                 // Field age:I
     
113.      34: aload_0
     
114.      35: ldc           #48                 // String happy
     
115.      37: putfield      #31                 // Field name:Ljava/lang/String;
     
116.      40: return
     
117. *
     
118. * 通过阅读上面的代码，我们推测 最后 age = 25, name = "happy"
     
119. * 实际运行后结果 如下：
     
120. * Person [age=25, name=happy]
     
121. * 与我们想的一致
     
122. */
     
123. 
     
124. //结论：
     
125. //1. 自定义无参构造函数与系统的默认构造函数初始化过程是一致的，我们可以在自定义函数中加入自己想要赋值的字段
     
126. //2. 类中实例字段初始化的顺序与他们在源代码中存在的位置有关。需要时可以通过反编译代码查看                

复制代码