1. <p>
   
2. class Bank{
   
3.         private int sum;//sum没有初始化值为什么可以编译成功呢？
   
4.         public synchronized void add(int n){
   
5.                 sum = sum+n;
   
6.                 System.out.println("sum = "+sum);
   
7.         }
   
8.         
   
9. }
   
10. class Custom implements Runnable{
    
11.         private Bank bank = new Bank();
    
12.         public void run(){
    
13.                 for(int i=0; i<3;i++){
    
14.                 bank.add(100);
    
15.                 }
    
16.         }
    
17. }
    
18. 
    
19. public class BankDemo {
    
20. 
    
21.         public static void main(String[] args) {
    
22.                 Custom cus = new Custom();        
    
23.                 Thread t1 = new Thread(cus);
    
24.                 Thread t2 = new Thread(cus);
    
25.                 t1.start();
    
26.                 t2.start();
    
27.         }
    
28. }</p><div class="blockcode"><blockquote>
    
29. <p> </p>

复制代码

这里的sum是因为初始化为0吗？

王浩龙 发表于 2014-3-13 07:52
楼下的是正解哦

快快找版主给我补分，，，，
我这算不算说的很清楚啊，，，
super();后“再”接着“属性显示初始化”后再是“构造代码块”，都是在构造函数“内”隐式调用的，，
这可是我自我感觉讲得比老师还清楚呀，，

王浩龙 发表于 2014-3-13 07:52
楼下的是正解哦

public class Main {
        public static void main(String[] args) {
                new Man();
        }
}
class Person {
        public Person() {
                System.out.println("父类构造器");
        }
}
class Man extends Person {
        {
                System.out.println("子类构造代码块");
        }
        public Man() {
                super();
                //构造代码块紧接在super();后执行
                System.out.println("子类构造器");
        }
}
/*结果:

父类构造器
子类构造代码块
子类构造器
*/
/*

1，加载字节码文件进内存
2，在堆内存中开辟空间，分配地址，静态区初始化
3，属性默认初始化
4，调用对应构造函数，
5，遇到默认super，调用父类构造函数
6，父类初始化完毕，属性显示初始化
7，构造代码块
8，继续执行构造器
9，完毕返回地址值
4到8步都是子类构造函数
先执行构造函数，在构造函数过程中调用了构造代码块
*/

目标 发表于 2014-3-12 21:50
构造代码块和构造函数哪个先运行呢？

public class Main {
        public static void main(String[] args) {
                new Man();
        }
}
class Person {
        public Person() {
                System.out.println("父类构造器");
        }
}
class Man extends Person {
        {
                System.out.println("子类构造代码块");
        }
        public Man() {
                super();
                //构造代码块紧接在super();后执行
                System.out.println("子类构造器");
        }
}
/*结果:

父类构造器
子类构造代码块
子类构造器
*/
/*

1，加载字节码文件进内存
2，在堆内存中开辟空间，分配地址，静态区初始化
3，属性默认初始化
4，调用对应构造函数，
5，遇到默认super，调用父类构造函数
6，父类初始化完毕，属性显示初始化
7，构造代码块
8，继续执行构造器
9，完毕返回地址值
4到8步都是子类构造函数
先执行构造函数，在构造函数过程中调用了构造代码块
*/

int sum;  sum是int型的，如果没有初始化，那么默认的int值就是0，等价于sum=0；每一种数据类型都有默认值，如果没有进行初始化，就会是默认值。

定义成员变量时不赋值，int类型初始值默认为0，编译不会出错，如果是局部变量，则会编译错误
还有，成员变量在所在类被实例化后，存在堆内存中；局部变量在所在方法调用时，存在栈内存空间中。

咸鱼 发表于 2014-3-12 20:29
1，加载字节码文件进内存
2，在堆内存中开辟空间，分配地址，静态区初始化
3，属性默认初始化

楼下的是正解哦

你定义的是一个整型变量，虽然你没有初始化，但是你一运行时，系统就是自动初始化，并且为零。

nicholyx 发表于 2014-3-12 22:07
构造代码块先于构造函数

谢谢哦      

目标 发表于 2014-3-12 21:50
构造代码块和构造函数哪个先运行呢？

构造代码块先于构造函数

1. 
   
2. class Main {
   
3.         Main(){
   
4.                         System.out.println("无参数构造方法。");
   
5.                 }
   
6. 
   
7.         {
   
8.                 System.out.println("构造代码块。");
   
9.         }
   
10. 
    
11.         static {
    
12.                 System.out.println("静态代码块。");
    
13.         }
    
14.                
    
15. }
    
16. class MainTest {
    
17.         public static void main(String[] args) {
    
18.                 new Main();
    
19.         }
    
20. }
    
21. /*
    
22. 输出结果为：
    
23. 静态代码块。
    
24. 构造代码块。
    
25. 无参数构造方法。
    
26. */
    

复制代码

咸鱼 发表于 2014-3-12 20:29
1，加载字节码文件进内存
2，在堆内存中开辟空间，分配地址，静态区初始化
3，属性默认初始化

构造代码块和构造函数哪个先运行呢？

1，加载字节码文件进内存
2，在堆内存中开辟空间，分配地址，静态区初始化
3，属性默认初始化
4，调用对应构造函数，
5，遇到默认super，调用父类构造函数
6，父类初始化完毕，属性显示初始化
7，构造代码块
8，继续执行构造器
9，完毕返回地址值

是，没有显示初始化的话，系统默认初始化为为0.