看完静态代码块的视频后，有点混乱了。构造函数跟静态代码块的概念跟作用是什么？在jvm中的执行顺序是什么？

静态代码块-->构造代码块-->构造函数（对应参数列表的）
这就是jvm的执行顺序
构造函数用于给对象建立时候进行初始的
静态代码块用于给整个类初始化的,它伴随着类的加载而加载

很简单，跟你说说！！呵呵~

静态代码块—默认初始化—显示初始化—构造代码块—构造函数

就是这些了，希望能帮到你啦~！

构造函数。
特点：任何用class定义的 类中，都有一个默认的空参数的构造函数。用于给该类对象进行初始化。
　　如果该类中指定了具体的构造函数，那么默认的构造函数就没有了。
　　1，函数名和类名相同。
　　2，不用定义返回值类型。
　　3，没有具体的返回值。
　　作用：给对象进行初始化。
　　穿件的每个对象都是一个实体，每个四体必须要进行初始化后才可以使用。
　　实体的初始化是需要通过动作来完成的。

---

静态代码块。
　　特点：1，随着类的加载而执行。
                  2，优先于主函数执行。
        作用：给类进行初始化。

给楼主个好的例子 我在这个论坛上看到的  收藏起来 这个很好的例子 真的很好
嘿嘿希望采纳{:soso_e100:}

要弄明白程序的执行顺序首先要明白 继承继承静态代码块构造代码块构造函数 的执行顺序，他们的顺序是：
父类静态代码块>>子类静态代码块>>父类构造代码块>>父类构造函数>> 子类构造代码块>>子类构造函数。
执行步骤（个人见解）
class Root    //第5步：找到Root，开始执行
{
static {  //第6步：由于有静态代码块，先执行静态代码块，进行初始化，打印1:Root静态构造代码块
   System.out.println("1:Root静态构造代码块") ;
}   
{   //第9步：执行父类的构造代码块，打印2:Root普通构造代码块
   System.out.println("2:Root普通构造代码块") ;
}
public Root() { //第10步：执行父类构造函数，打印3:Root构造函数
   System.out.println("3:Root构造函数") ;
}
}
class Mid extends Root    //第4步：找到Mid类，他又继承了Root，再去找Root类
{
static {     //第7步：Root初始化完成后寻找子类，也有静态代码块，先执行，并打印4:Mid静态构造代码块
   System.out.println("4:Mid静态构造代码块") ;
}
{   //第11步：执行性次构造代码块 打印5:Mid普通构造代码块
   System.out.println("5:Mid普通构造代码块");
}
public Mid() { //第12步：执行此构造函数，打印6:Mid无参构造函数
   System.out.println("6:Mid无参构造函数") ;
}
public Mid(String msg) {   //第13步：执行此构造函数打印7:Mid有参构造函数"+msg，msg由Leaf（）调用super传入疯狂java讲义，所以打印Mid有参构造函数疯狂java讲义
   this ();
   System.out.println("7:Mid有参构造函数"+msg) ;
}
}
class Leaf extends Mid   
{
static {    //第8部：理由同第六步，打印8eaf静态构造代码块。静态代码块都完成了，再找父类的构造代码块
   System.out.println("8eaf静态构造代码块") ;
}
{   //第14部最后执行子类的构造代码块，打印9eaf普通构造代码块
   System.out.println("9eaf普通构造代码块") ;
}
public Leaf() {   //第2步，要new对象，找到Leaf的构造函数
   super("疯狂java讲义");  //第3步，调用父类，并且有参数 疯狂java讲义
   System.out.println("10eaf有参构造函数") ;  //第15步，打印10eaf有参构造函数
}
}
public class demo {
public static void main(String[] args) {
   new Leaf() ;        //第1步：找到main方法开始执行这一句，
}
}

静态代码块static{}  ：用于给类初始化，类加载时就会被执行，只加载一次；
构造代码块{}：用于给所有对象统一初始化，只要建立对象该部分就会被执行，且优先于构造函数；
构造函数：给对应的对象初始化，建立对象时，选择相应的构造函数初始化对象；
三者的执行顺序：静态代码块——>构造代码块——>构造函数

你想知道答案，需要知道对象实例化的过程，首先：你new什么对象JVM就要找到你类的StaticCode.class文件加载到内存，然后执行static代码块，如果有的话，给所属的StaticCode.class类进行初始化，然后在堆内存中开辟空间，分配内存地址。看到这里你应该知道你的对象建立多少和你那个静态代码块执行次数没有关系，它是给你这个.class进行初始化的执行的，不管你有几个对象，你在内存中只有一份.class文件所以它只作用在类加载时执行，而且只执行一次，不会重复执行的...希望对你有帮助

这个楼主可以多自己写小程序验证得出答案..那样印象会深刻点!!

看完静态代码块的视频后，有点混乱了。构造函数跟静态代码块的概念跟作用是什么？在jvm中的执行顺序是什么？
==============================================
这是个老问题，楼主在论坛里搜索一下，能找到很多详细的解释。我先简单说一下。
构造函数，是为了新建立的对象的初始化，每当建立一个新的对象，根据传入参数的不同，构造函数都要对应的运行，以帮助新建对象初始化参数。

静态代码块，是为了加载的类进行初始化，有些静态成员变量可能需要提前加载，或者是执行在建立对象前需要进行的操作，这个要根据程序的具体需求来决定。

下面我手写了一个小程序，楼主可以运行下试试，加深对构造函数和静态代码块的理解。

class Person
{
      String name = "Tom";
      int age = 20;
      public Person(String name, int age)    //构造函数
      {
            this.name = name;
            this.age = age;
            System.out.println("构造函数  running");
      }
      static             //静态代码块
      {
              System.out.println("static {} running");
      }

      public static void main(String[] args)
      {
             Person person1 = new Person("张三",20);
             Person person2 = new Person("李四",22);
       }
}
==============运行后输出结果如下=================
static {} running
构造函数  running
构造函数  running
=====================
由此看出，建立2个对象，static代码块在构造函数之前运行，且只加载一次；
而构造函数只要新建立一个对象，就会运行一次，在static之后运行。
以上纯手工制作，希望有帮到你。~~

静态代码块是加载类时对类进行初始化的，必须先执行。而构造函数是创建对象时调用的，会不会执行还看你是否调用，因为一个类可以有多个构造函数，一个对象只能调用一个构造函数。

静态代码快最先运行，因为构造代码快跟构造函数 都是随着对象的建立而运行，静态代码快跟其他几个 在内存中所处的位置不一样，所以静态代码快具有最先运行的权利。其次就是构造代码快，最后是构造函数。

静态代码块是在类加载时自动执行的，非静态代码块在创建对象自动执行的代码，不创建对象不执行该类的非静态代码块。 顺序： 静态代码块--》非静态代码块--》类构造方法。

这是我截得PPT的文档，不难理解。
特点： 1,随着类的加载而执行，而且只能执行一次。
           2,静态代码块优先于主函数public，就是先执行静态代码块中的语句，在执行，主函数public中的语句。
作用：是给类进行初始化。
下面的运行流程图。

关于这个问题，我这么和你说吧。注意看。

java中关于执行顺序的问题在构造代码块、静态代码块、以及主函数之间有几个小细节要注意。

java中静态代码块Static{}随着类的第一次加载而执行，只执行一次，并优于主函数执行。

而构造代码块{}的作用是给所有对象统一初始化。对象一建立就运行，而且优先于构造函数执行。

构造代码块和构造函数的区别：构造代码块是给所有对象初始化，而构造函数是给对应的对象初始化。

比如有如下代码：

class StaticCode

{

//静态代码块

       static

       {

              System.out.println("a");

       }

//下面是构造代码块

       {

              System.out.println("b");

       }

       public static void show()

       {

       System.out.println("show run");   

       }

}

class  StaticCodeDis

{

       static

       {

              System.out.println("主函数中的静态代码块优先于主函数执行的例子！执行第一次");

       }

       public static void main(String[] args)

       {

              System.out.println("Hello World!");

              StaticCode.show();

              StaticCode s=new StaticCode();

       }

       static

       {

              System.out.println("主函数中的静态代码块优先于主函数执行的例子！执行第二次");

       }

}我们javac和java之后得到的运行结果会是：

主函数中的静态代码块优先于主函数执行的例子！执行第一次

主函数中的静态代码块优先于主函数执行的例子！执行第二次

Hello World!

因为当StaticCodeDis加载后，该类会执行该类下的静态代码块，该类下有两处静态代码块。因此打印出

“

主函数中的静态代码块优先于主函数执行的例子！执行第一次

主函数中的静态代码块优先于主函数执行的例子！执行第二次

Hello World!

a

show run

b

”

这时类再调用主函数StaticCodeDis.main(),在main中我们又调用了StaticCode.show()

方法，这时StaticCode类就被加载进来，同理，静态代码块优先执行，这时会执行StaticCode下的静态代码块，因此输出a，当静态代码块执行完毕后，会执行调用的show（）方法，输出show run。当执行到StaticCode s=new StaticCode()时;对象建立，因此会优先执行构造代码块{System.out.println("b");}，因此打印出一个b。

java中构造代码块、构造函数、静态代码块、以及主函数之间的一些小细节要多加注意，不然面试的时候就会出问题。

1.构造器是一个特殊的方法，用于创建实例时执行初始化。创建对象时系统会为对象的所有field进行默认初始化，默认初始化将所有基本类型的field设为0（对数值型field）或false（对布尔型field），把所有引用类型的field设为null。因而如果需要指定初始化值，就需要自定义构造器。
2.使用static修饰的初始化块是静态初始化块，也叫类初始化块。系统在类初始化阶段执行静态初始块，普通初始化块在创建对象时执行，因而静态初始化块比普通初始化块先执行。
3.jvm在对类进行初始化时，对静态field进行初始化，继而使用构造器初始化对象。
4.java的初始化十分复杂，我现在也对其初始化问题感到难以抓住要点。

李志群 发表于 2012-7-13 16:56
给楼主个好的例子 我在这个论坛上看到的  收藏起来 这个很好的例子 真的很好
嘿嘿希望采纳

嘿嘿 老例子分享喽嘿嘿:D 不过我认为这个真的很给力哦哈哈