A.静态代码块----给类进行初始化

B.构造代码快----给对象初始化

C.构造函数----给对应对象初始化

顺序A-->B-->C

对否？

求简单说说应用中实例

熊攀 发表于 2013-1-15 20:41
我想问下  这个小练习的 第2个输出语句 如果是4？    那么 Demo2.x=3  ， new Demo().x=1 !加起来就是4.
...

    你也明白第一个输出语句System.out.println( Demo2.x + new Demo2().x ); //4里，Demo2.x是3，new Demo().x是1，两者加起来是4，那么第二句  System.out.println( Demo2.x + new Demo2().x ); //2里，这个new Demo().x你应该也知道是1了吧，主要还是Demo2.x，对吧！

    其实这里的Demo2.x你就可以当做new Demo2.x来看的，因为第一个语句里已经调用了静态构造方法，而静态构造方法仅仅第一次调用的时候初始化，之后就不在初始化了，所以第二句里的Demo2.x也是1！这样的解释你明白嘛？！

王晓明 发表于 2013-1-15 13:47
谔谔，最近好多人对这里迷糊了，给你一个例子看一下，你拷贝运行一下，多运行几次，基本就懂了！
public cl ...

我想问下  这个小练习的 第2个输出语句 如果是4？    那么 Demo2.x=3  ， new Demo().x=1 !加起来就是4.

那为什么最后个输入语句是2，很疑惑。求解答

谔谔，最近好多人对这里迷糊了，给你一个例子看一下，你拷贝运行一下，多运行几次，基本就懂了！
public class Demo1{
        public static void main(String[] args){
                Person p1=new Person();
                Person p2=new Person("李磊",28);
                Person p3=new Person("jack",22);
                Person p4=new Person("rose",20);
        }
}
class Person{
        //静态成员变量
        static String country="US";
       
        //静态代码块
        static{
                country="CN";
                System.out.println("静态代码块用于类初始化.");       
        }
        //成员变量
        private String name="rose";
        private int age;
       
        //构造代码块
        {
                this.name="jack";
                this.age=1;
                System.out.println("构造代码块");       
        }
        //构造函数
        Person(){
                System.out.println("无参数构造");
        }
        Person(String name ,int age){
                this.age=age;
                this.name=name;
                System.out.println("有参数构造C");
        }
       
        public void setName(String name){
                this.name=name;
        }
        public String getName(){
                return this.name;
        }
        public void setAge(int age){
                this.age=age;       
        }
        public int getAge(){
                return age;
        }
        //成员方法
        void speak(){
                System.out.println(name+":"+age);
                System.out.println("普通的成员方法.");
        }       
}


上面的这段代码只是帮助你理解三者的关系，再给你一段代码，这段代码很好的运用到了这三者，练习一下，看你是否真的理解了（答案附带给你）：
public class Demo2{
       
        {
                x = 1;
                System.out.println("构造代码块");
        }
        //静态成员变量(类变量)
        public static int x = 2;
       
        static{
                x = 3;
                System.out.println("静态代码块");
        }


        public static void main(String[] args) {
                //System.out.println(Demo2.x); //3
                System.out.println( Demo2.x + new Demo2().x ); //4
                System.out.println( Demo2.x + new Demo2().x ); //2
        }
}

说真的，做了这个小练习你决定会懂了，我当初也是这么懂的，不懂？！那再看第一段代码吧！

我对顺序做一个简单的修改
A -> 建立对象 -> B -> C
首先静态代码块是随着类的加载而加载的，生命周期随着类的消失而消失
当只有在建立对象的时候，这时才会运行B和C，且B是给所有的对象进行初始化，也就是说每个对象的建立都会执行B，C只是给相对应的对象进行初始化
构造代码块和构造函数会随着对象的建立而运行，生命周期随着对象的消失而消失
静态代码块得生命周期比构造代码块和构造函数的生命周期长

现在学习阶段，有时候不知道如何运用。但是还是先记住结论。自己可以去google一下，看是怎么实际应用的。也许在以后的项目开发中，会见到这样的代码。

静态代码块在类加载的时候执行。

构造代码块和构造函数在new的时候执行。构造代码块先于构造函数执行。