黑马程序员技术交流社区

标题: 那位大侠讲解一下下面的程序。 [打印本页]

作者: ﹎◇waiting﹎ 时间: 2012-7-20 15:06
标题: 那位大侠讲解一下下面的程序。
本帖最后由﹎◇waiting﹎于 2012-8-1 13:58 编辑

这个程序是如何执行的及原因
class StaticCode
{
int num=9;
StaticCode()
{
System.out.println("b");
}
static
{
System.out.println("a");
}
{
System.out.println("c"+this.num);
}
StaticCode(int x)
{
System.out.println("d");
}
public static void show()
{
System.out.println("show run");
}
}
class StaticCodeDemo
{
public static void main(String[] args)
{
new StaticCode(4);
}
}

作者: 夏儒日 时间: 2012-7-20 15:39
该程序主要考察静态代码快、构造代码块以及构造函数的执行顺序。明白了他们之间的执行顺序，就不难理解改程序的执行顺序了。
静态代码块顺着类的加载而加载，类一加载它就执行，不管此时有没有创建对象；
构造代码块是给该类所有对象惊醒初始化，故只要有对象创立，构造代码块就执行；
构造函数是给该类的相对应对象进行初始化，即创建相对应的该类对象时，调用相对应的构造函数。

class StaticCode
{
int num=9;
StaticCode()
{
System.out.println("b");
}
   static//2、静态代码块随着类的加载而加载，故加载类StaticCode后执行该静态代码块，打印a
   {
System.out.println("a");
   }
   //3、接着执行构造代码块，打印c9
{
System.out.println("c"+this.num);
}
   StaticCode(int x)//4、最后执行相对应的构造函数，打印d
{
   System.out.println("d");
}
   public static void show()
{
System.out.println("show run");
   }
   }
class StaticCodeDemo
{
   public static void main(String[] args)
{
new StaticCode(4);//1、主函数执行该语句，加载类StaticCode
}
}

作者: rslheima 时间: 2012-7-20 16:04
本帖最后由 rslheima 于 2012-7-20 16:07 编辑

首先你要了解类初始化的顺序，之后就可以理解你的程序了。
初始化顺序依次是（静态变量、静态初始化块）>（变量、初始化块）>构造器

详细资料请看http://www.cnblogs.com/jackyrong/archive/2008/08/12/1266161.html

public class InitialOrderTest {
// 静态变量
public static String staticField = "静态变量";
// 变量
public String field = "变量";
// 静态初始化块
static {
System.out.println(staticField);
System.out.println("静态初始化块");
}
// 初始化块
{
System.out.println(field);
System.out.println("初始化块");
}
// 构造器
public InitialOrderTest() {
System.out.println("构造器");
}
public static void main(String[] args) {
new InitialOrderTest();
}
}

运行以上代码，我们会得到如下的输出结果：

静态变量
静态初始化块
变量
初始化块
构造器

//-------------------------------------------所以你的程序运行顺序是1,2,3,4
class StaticCode
{
int num=9;//=========2  变量
StaticCode()
{
System.out.println("b");
}
static
{
System.out.println("a");//=====》1  静态初始化块
}
{
System.out.println("c"+this.num);//======》3  初始化块
}
StaticCode(int x)//=======》4  构造器
{
System.out.println("d");
}
public static void show()
{
System.out.println("show run");
}
}
class StaticCodeDemo
{
public static void main(String[] args)
{
new StaticCode(4);
}
}

作者: 苑占丽 时间: 2012-7-20 16:10
本帖最后由苑占丽于 2012-7-20 16:14 编辑

这个程序是如何执行的及原因//分析如下：
class StaticCode
{
int num=9;
StaticCode()
{
System.out.println("b");
}
static
{
System.out.println("a");
}//2.静态代码块，随着类的加载而执行，且执行一次，所以先输出a
{
System.out.println("c"+this.num);//3.构造代码块，也优于对象执行，仅次于静态代码块，所以再次输出c9
}
StaticCode(int x)
{
System.out.println("d");//4.执行这一句，输出d。程序执行完毕。
}
public static void show()
{
System.out.println("show run");
}
}
class StaticCodeDemo
{
public static void main(String[] args)
{
new StaticCode(4);//1.加载类，并创建一个对象并传参数4
}
}

作者: 张水荣 时间: 2012-7-20 16:41
本帖最后由张水荣于 2012-7-20 16:47 编辑

<div class="blockcode"><blockquote>class StaticCode {
      int num = 9;

      StaticCode() {//无参数构造函数
            System.out.println("b");
      }

      static {//静态语句块：static后跟上一个{},{}中的代码叫做静态语句块。
            System.out.println("a");//1. 当执行一个类时，首先执行静态语句块，所以首先此句语句。
      }
      {//动态语句块：运行类的构造函数时，首先运行的是动态语句块，然后再运行构造函数中的代码。动态语句块相当于把它里面的语句放在构造函数中的第一行位置。
            //无论你运行的是哪个构造函数，动态语句块都会先运行。
            System.out.println("c" + this.num);//2. 执行构造函数时，首先执行此句语句。
      }

      StaticCode(int x) {
            System.out.println("d");//3. 执行完动态语句后，执行此句语句。
      }

      public static void show() {//静态方法，只有调用其时才会执行其中的语句块，如：StaticCode.show()。
            System.out.println("show run");
      }
}
</blockquote></div><br />

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

黑马程序员IT技术论坛 X3.2