1. class Block{
   
2.         
   
3.     int j = 100;      
   
4.     int i = 200;      
   
5.         {
   
6.                 j = 2000;
   
7.                            
   
8.                 int i = 1000;
   
9.                            
   
10.                 }
    
11.         
    
12.         
    
13.         public void test(){
    
14.                
    
15.                 System.out.println("第一个变量:"+j+"第二个变量："+i);
    
16.                
    
17.                 }
    
18.         
    
19.         }
    
20.         
    
21. public class TestBlock1{
    
22.         
    
23.         public static void main(String[] args){
    
24.                
    
25.                 Block block = new Block();
    
26.                 block.test();
    
27. 
    
28.                 }
    
29.         
    
30.         }

复制代码

代码块中的不应该是局部变量么 结果不应该是100 200么  菜鸟求解啊{:soso_e118:}

第六行  j = 2000;  前面少了int，如果少了int 就相当于 this.j = 2000;就将j值改变了。
int j = 2000;

{
代码} 代码块 优先与栈内存的运行 因为｛代码｝代码块 是放在方法区中的

代码块中的 j没加int，它的作用范围为整个类，而代码块中的i加了int，它的作用范围仅为代码块的{}，一出了大括号，就消亡了。并不影响i的值。

构造代码块和类的实例成员在初始化赋值的执行顺序是从上往下，刚开始  int  j = 100 ;int i = 200; 接着进入代码块，j被重新赋值2000; int i = 1000;这个 i 是局部变量，当执行完代码块，也就被释放掉。所以结果   j = 2000; i = 200..

1. class Block{
   
2.     int j = 100;  //成员变量j 作用域整个类
   
3.     int i = 200;  //成员变量i 作用域同上
   
4.         {
   
5. j = 2000;    //对成员变量j赋值为2000(被覆盖了)
   
6. int i = 1000;   //局部变量i,作用域:构造代码块内,执行完构造代码块,内存释放
   
7.                 }
   
8. 
   
9. //实例变量初始化:构造代码块的初始化和显式初始化 两者顺序和代码顺序一致
   
10. 
    
11. public void test(){
    
12.                 System.out.println("第一个变量:"+j+"第二个变量："+i);   //i,j均为成员变量-->this.j->2000,this.i->200
    
13.                 }
    
14.         }
    
15. public class TestBlock1{
    
16.         public static void main(String[] args){
    
17.                 Block block = new Block();
    
18.                 block.test();
    
19.                 }
    
20.         }
    

复制代码

int  j = 100 定义的个成员变量，j作用域是整个类， {j = 2000;  int i = 1000;}其中j=2000，只是对变量j进行重新赋值，当你Block block = new Block();时，执行构造代码块，对j进行了赋值，所以结果输出j=2000.

class Block{

    int j = 100;       //Block类的成员变量,作用范围为Block类
    int i = 200;      //Block类的成员变量,作用范围为Block类
        {
                j = 2000; //Block类的成员变量 j 被重新赋值为 2000,作用于Block类

                int i = 1000;//此处的 i 因为使用 int 定义 就变成了 {} 的局部变量 作用范围仅限 {}内,当离开{},这句话定义的 i 就从内存中消失了

                }//至此,{}内定义的 i 已经不存在了


        public void test(){

                System.out.println("第一个变量:"+j+"第二个变量："+i); //这句话里的 i 和 j 均为Block类的成员变量

                }

        }

public class TestBlock1{

        public static void main(String[] args){

                Block block = new Block();
                block.test();

                }

        }

//希望红色的注解,能对你有帮助, 建议你在复习下变量作用域部分, 共同学习 哈~~

张洪慊 发表于 2013-3-12 21:01

楼上正解
附上毕老师总结的对象初始化的过程
Person p = new Person("zhangsan",20);

该句话都做了什么事情？
1，因为new用到了Person.class.所以会先找到Person.class文件并加载到内存中。
2，执行该类中的static代码块，如果有的话，给Person.class类进行初始化。
3，在堆内存中开辟空间，分配内存地址。
4，在堆内存中建立对象的特有属性。并进行默认初始化。
5，对属性进行显示初始化。
6，对对象进行构造代码块初始化。
7，对对象进行对应的构造函数初始化。
8，将内存地址付给栈内存中的p变量。

跟据你的代码我认为这道题出现的原因是对象的初始化过程中，按照这道题的运行顺序来看，应该是非静态代码块（即构造代码块）----->成员函。
第一步：Block block = new Block();创建一个类的对象并实例化，开始分配空间并将成员变量初始化为默认值，即i =0；j=0；然后实例化成员变量，即j =100; i =200;
第二步：在对象一建立的时候就运行非静态代码块， j = 2000;   int i = 1000;在这个地方出现误区，由于j已经实例化，所以在非静态代码块中直接调用，故成员变量j=2000，然而i 由于是在非静态代码块中重新定义，所以属于局部变量，随着代码块结束而消亡。
第三步：按照顺序运行成员函数，在函数输出中调用成员函数的j 和 i，所以直接输出，j=2000，i =200

如果还有问题，请继续追问，没问题的话，请将帖子分类改成【已解决】~

谢谢大家解答啊  问题已解决

⑤ 楼说的很详细，我补充一点总结吧。

1.首先要明确是谁先执行：

本题中显示赋值先执行，构造构造代码块后执行。（注意：构造代码块，和显示赋值 是按照代码的顺序执行的，就是谁在前执行谁！）

2.要明确变量的作用域：

本题中，构造代码块中定义的变量作用于该代码块，虽然和类中的变量同名，但是不是同一个，而且会随着构造带码快的消失而消失。
（注意：如果出现 出现  “ 类型名   变量名   =   …” 或 ““ 类型名   变量名 ；”   都说明又定义了一个新的变量）