黑马程序员技术交流社区

标题: 求一个比较直观的例子 [打印本页]
作者: 张运恒    时间: 2013-7-21 19:11
标题: 求一个比较直观的例子
本帖最后由 张运恒 于 2013-7-22 16:16 编辑

静态代码块  构造代码块  构造函数  对于初学者的总是让我搞混淆， 求大神来个比较直观的例子 比较容易记住的窍门
作者: 月亮人生    时间: 2013-7-21 19:38

  2. /*


  5. 区别：

  7. 1、静态代码块：它是随着类的的加载而执行，类一加载,静态代码块就会执行，并且只执行一次
  8. 2、构造代码块：是用于给对象进行初始化，对象一建立，构造代码块就会运行
  9. 3、成员代码块：是类对象在调用的类的方法的时候，才会执行。
  10. 4、所以静态代码块比构造代码块先执行，构造代码块比构造函数先执行，构造函数比成员代码块先执行；

  12. */



  16. class StaticCode{
  17. int num=1;

  19. //建立构造函数
  20. StaticCode(){
  21.   System.out.println("third");
  22. }

  24. //建立静态代码块
  25. static{
  26.   System.out.println("first");
  27. }

  29. //建立构造代码块
  30. {
  31.   System.out.println("second");
  32. }

  34. //建立一个show()方法
  35. public static void show(){
  36.   System.out.println("show  run");
  37. }
  38. }
  39. class Demo1{
  40. public static void main(String[] args){
  41. StaticCode sc= new StaticCode();
  42.   System.out.println("调用成员了……");
  43.   sc.show();
  44. }
  45. }

  47. /*
  48. 输出结果：
  49. first
  50. second
  51. third
  52. 调用成员了……
  53. show  run


  56. 从输出结果看到：先是静态代码块，然后是构造代码块，然后是构造函数，最后才是类的成员函数。从new一个对象
  57. 可以看出，对象一建立，就迅速执行了这些程序。

  59. */
复制代码
作者: hoyouly    时间: 2013-7-21 21:20
class A
{
        //静态代码块，
        static
        {
                System.out.println("这是类A中的静态代码块");
        }
       
        //        构造代码块
        {
                System.out.println("这是类A中的构造代码块");
        }
       
        // 无参构造函数
        public A()
        {
                System.out.println("这是A类的构造函数");
        }

        // 带有形参的构造函数
        public A( int a)
        {
                System.out.println("这是A类的构造函数"+" a="+a);
        }
       
        //定义A类中一个普通的方法show()
        public void show()
        {
                System.out.println("这是A类中的show方法");
        }

        //定义A类中一个静态的方法static_show()
        public static void static_show()
        {
                System.out.println("这是A类中的static_show方法");
        }
}

class  Test2
{
        static
        {
                System.out.println("这是主函数中的静态代码块");
        }

        {
                System.out.println("这是主函数中的构造代码块");
        }

        public static void main(String[] args)
        {
                System.out.println("------main 函数开始执行-------");
                new A();
                System.out.println("---------------");
                A a=new A(3);
                System.out.println("---------------");
                A.static_show();
                a.show();
               
        }
}


解释：先执行了主函数中的静态代码块，然后主函数中的main函数再执行，主函数中的main中是new A（） 这句话，先执行Ａ中的静态代码块，然后执行构造代码块，在执行了Ａ的构造函数，可是当执行A a =new A();时候，却没有再执行静态代码块，而是直接执行了构造代码块，和构造函数，这就说明，静态代码块 随着类的加载而执行，只执行一次,并优先于主函数。

这是我自己改编的一个小程序，你可以看看，希望对你理解这几个问题有帮助。
作者: 张强1    时间: 2013-7-21 23:04
//静态代码块，如下代码是以类关键字代码形式写的
        static
        {

        }
//构造函数，方法名于函数名是一致的
class A
{              
        // 无参构造函数
       A()
        {
               
        }





欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2