刚才在看静态代码块时，毕老师有写到一个构造代码块，谁能举例说明下它的作用？谢谢

为对象初始化。在静态代码块之后执行。

class Test {
        public static void main(String[] args) {
                {                                                                        //局部代码块,限定变量的生命周期
                        int x = 10;
                }

                Person p1 = new Person();

                Person p2 = new Person("张三",20);

        }
}

class Person {
        private String name;
        private int age;

        public Person(){}

        public Person(String name,int age) {
                this.name = name;
                this.age = age;
        }

        {                                                                                        //构造代码块,初始化块,构造代码块创建几次对象就执行几次
                System.out.println("aaaaaaaaa");                //作用,当所有的对象具备了相同的属性或行为时,定义在构造代码块中
        }

        static {                                                                        //静态代码块,随着类的加载而加载,且只加载一次
                System.out.println("bbbbbbbbb");                        //加载驱动
        }
       
}

千殇轮回 发表于 2014-4-30 21:44
class Test {
        public static void main(String[] args) {
                {                                                                        //局部代码块,限定变量的生命周期

讲的很详细,赞一个!

千殇轮回 发表于 2014-4-30 21:44
class Test {
        public static void main(String[] args) {
                {                                                                        //局部代码块,限定变量的生命周期

讲的很详细,赞一个!

构造代码块优先于静态代码块，优先于构造方法执行。对象创建几次，构造代码块就调用几次。张孝祥老师讲的吧。

class Person {
    private String name;
    private int age;
    Person(){
         System.out.print("这是构造函数");
     }
    Person(String name,int age) {
       this.name = name;
       this.age = age;
    }
    {
          System.out.println("这是构造代码块");
    }
}
class Test {
         public static void main(String[] args) {
              Person p = new Person();
        }
}


输出是：
这是构造代码块
这是构造函数
（温馨提示，笔者纯手打^-^）

用一个花括号圈起来的。

syusikoku 发表于 2014-4-30 22:41
构造代码块优先于静态代码块，优先于构造方法执行。对象创建几次，构造代码块就调用几次。张孝祥老师讲的吧 ...

静态代码块优先于构造代码块吧？  难道是我记错了？？？类加载时就已经初始化到内存中去了啊 ，而且是唯一的，不管对象创建了几个，都只加载一次静态代码块！  new 对象的顺序是 静态代码块优先于构造代码块，构造代码块优先于构造函数！
而且，代码的加载顺序在父子类的继承关系时有一点要注意的，父类全部加载完，才能加载子类的，而只有子类的静态代码块是例外，他是类加载进内存就自动被初始化，不需要new 对象的。
我写了个代码 ，祝你理解 ，包括构造代码块我都给你写上了  

代码如下 ↓

1. class fu
   
2. {
   
3.         static
   
4.         {
   
5.                 System.out.println("父类中的静态代码块初始化   : 1");  
   
6.         }
   
7.         {
   
8.                 System.out.println("父类中的构造代码块初始化  :  3");
   
9.         }
   
10.         fu()
    
11.         {
    
12.                 System.out.println("父类中的构造函数初始化    :  4");
    
13.         }
    
14. }
    
15. class zi extends fu
    
16. {
    
17.         static
    
18.         {
    
19.                 System.out.println("子类中的静态代码块初始化   : 2");  
    
20.         }
    
21.         {
    
22.                 System.out.println("子类中的构造代码块初始化  :  5");
    
23.         }
    
24.         zi()
    
25.         {
    
26.                 System.out.println("子类中的构造函数初始化    :  6");
    
27.         }
    
28. }
    
29. 
    
30. class Demo2
    
31. {
    
32.         public static void main(String[] args)
    
33.         {
    
34.                
    
35.                 new zi();
    
36.         }
    
37. }

复制代码

运行结果如下↓

小周务商 发表于 2014-5-1 08:13
用一个花括号圈起来的。

谢谢了。。。。。。

千殇轮回 发表于 2014-4-30 21:44
class Test {
        public static void main(String[] args) {
                {                                                                        //局部代码块,限定变量的生命周期

//作用,当所有的对象具备了相同的属性或行为时,定义在构造代码块中

如果是这样的话，那构造代码块的内容放到特定的构造函数的函数体内，目的也达到了。。

syusikoku 发表于 2014-4-30 22:41
构造代码块优先于静态代码块，优先于构造方法执行。对象创建几次，构造代码块就调用几次。张孝祥老师讲的吧 ...

毕老师的那个基础视频也有讲到哈，，

看一下 呵呵