精华内容
下载资源
问答
  • 静态代码块:用staitc声明,jvm加载类时执行,仅执行 构造代码块:类中直接用{}定义,每一创建对象时执行执行顺序优先级:静态块,main(),构造块,构造方法。 构造函数 public HelloA(){ // 构造...

    静态代码块:用staitc声明,jvm加载类时执行,仅执行一次

    构造代码块:类中直接用{}定义,每一次创建对象时执行。

    执行顺序优先级:静态块,main(),构造块,构造方法。

     

    构造函数

    public HelloA(){ // 构造函数
    
    }

    关于构造函数,以下几点要注意:

    1. 对象一建立,就会调用与之相应的构造函数,也就是说,不建立对象,构造函数时不会运行的。
    2. 构造函数的作用是用于给对象进行初始化。
    3. 一个对象建立,构造函数只运行一次,而一般方法可以被该对象调用多次。

     

    构造代码块

    { // 构造代码块    
    
    }

    关于构造代码块,以下几点要注意:

    1. 构造代码块的作用是给对象进行初始化。
    2. 对象一建立就运行构造代码块了,而且优先于构造函数执行。这里要强调一下,有对象建立,才会运行构造代码块,类不能调用构造代码块的,而且构造代码块与构造函数的执行顺序是前者先于后者执行
    3. 构造代码块与构造函数的区别是:构造代码块是给所有对象进行统一初始化,而构造函数是给对应的对象初始化,因为构造函数是可以多个的,运行哪个构造函数就会建立什么样的对象,但无论建立哪个对象,都会先执行相同的构造代码块。也就是说,构造代码块中定义的是不同对象共性的初始化内容。

     

    静态代码块

    static { // 静态代码块    
    
    }

    关于静态代码块,要注意的是:

    1. 它是随着类的加载而执行,只执行一次,并优先于主函数。具体说,静态代码块是由类调用的。类调用时,先执行静态代码块,然后才执行主函数的。
    2. 静态代码块其实就是给类初始化的,而构造代码块是给对象初始化的
    3. 静态代码块中的变量是局部变量,与普通函数中的局部变量性质没有区别。
    4. 一个类中可以有多个静态代码块。
    public class Test{
    	staitc int cnt=6;
    
    	static {
    		cnt+=9;
    	}
    
    	public static void main(String[] args) {
    		System.out.println(cnt);
    	}
    
    	static {
    		cnt/=3;
    	}
    }
    
    运行结果:

     

    Java类初始化顺序

    对于一个类的情况

    例子1

    public class HelloA {
    
        public HelloA(){ // 构造函数
            System.out.println("A的构造函数");    
        }
    
        { // 构造代码块
            System.out.println("A的构造代码块");    
        }
    
        static { // 静态代码块
            System.out.println("A的静态代码块");        
        }
    
        public static void main(String[] args) {
        }
    }
    
    运行结果:
    A的静态代码块

    例子2

    public class HelloA {
        public HelloA(){ // 构造函数
            System.out.println("A的构造函数");    
        }
    
        { // 构造代码块
            System.out.println("A的构造代码块");    
        }
    
        static { // 静态代码块
            System.out.println("A的静态代码块");        
        }
    
        public static void main(String[] args) {
            HelloA a=new HelloA();    
        }
    }
    
    运行结果:
    A的静态代码块
    A的构造代码块
    A的构造函数

    例子3

    public class HelloA {
    
        public HelloA(){ // 构造函数
            System.out.println("A的构造函数");    
        }
    
        { // 构造代码块
            System.out.println("A的构造代码块");    
        }
    
        static { // 静态代码块
            System.out.println("A的静态代码块");        
        }
    
        public static void main(String[] args) {
            HelloA a=new HelloA();
            HelloA b=new HelloA();
        }
    }
    
    运行结果:
    A的静态代码块
    A的构造代码块
    A的构造函数
    A的构造代码块
    A的构造函数

    对于一个类而言,按照如下顺序执行:

    1. 执行静态代码块
    2. 执行构造代码块
    3. 执行构造函数

    对于静态变量、静态初始化块、变量、初始化块、构造器,它们的初始化顺序依次是(静态变量、静态初始化块)>(变量、初始化块)>构造器。

    例子4

    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. 初始化块

    5. 构造器

    对于继承情况

    public class HelloA {
    
        public HelloA(){ // 构造函数
            System.out.println("A的构造函数");    
        }
    
        { // 构造代码块
            System.out.println("A的构造代码块");    
        }
    
        static { // 静态代码块
            System.out.println("A的静态代码块");        
        }
    }
    
    public class HelloB extends HelloA{
    
        public HelloB(){ // 构造函数
            System.out.println("B的构造函数");    
        }
    
        { // 构造代码块
            System.out.println("B的构造代码块");    
        }
    
        static { // 静态代码块
            System.out.println("B的静态代码块");        
        }
    
        public static void main(String[] args) {
            HelloB b=new HelloB();        
        }
    }
    
    运行结果:
    A的静态代码块
    B的静态代码块
    A的构造代码块
    A的构造函数
    B的构造代码块
    B的构造函数

    当涉及到继承时,按照如下顺序执行:

    1. 执行父类的静态代码块,并初始化父类静态成员变量
    2. 执行子类的静态代码块,并初始化子类静态成员变量
    3. 执行父类的构造代码块,执行父类的构造函数,并初始化父类普通成员变量
    4. 执行子类的构造代码块, 执行子类的构造函数,并初始化子类普通成员变量

    Java初始化顺序如图

    例子6

    class Parent {
            /* 静态变量 */
        public static String p_StaticField = "父类--静态变量";
             /* 变量 */
        public String    p_Field = "父类--变量";
        protected int    i    = 9;
        protected int    j    = 0;
            /* 静态初始化块 */
        static {
            System.out.println( p_StaticField );
            System.out.println( "父类--静态初始化块" );
        }
            /* 初始化块 */
        {
            System.out.println( p_Field );
            System.out.println( "父类--初始化块" );
        }
            /* 构造器 */
        public Parent()
        {
            System.out.println( "父类--构造器" );
            System.out.println( "i=" + i + ", j=" + j );
            j = 20;
        }
    }
    
    public class SubClass extends Parent {
             /* 静态变量 */
        public static String s_StaticField = "子类--静态变量";
             /* 变量 */
        public String s_Field = "子类--变量";
            /* 静态初始化块 */
        static {
            System.out.println( s_StaticField );
            System.out.println( "子类--静态初始化块" );
        }
           /* 初始化块 */
        {
            System.out.println( s_Field );
            System.out.println( "子类--初始化块" );
        }
           /* 构造器 */
        public SubClass()
        {
            System.out.println( "子类--构造器" );
            System.out.println( "i=" + i + ",j=" + j );
        }
    
    
            /* 程序入口 */
        public static void main( String[] args )
        {
            System.out.println( "子类main方法" );
            new SubClass();
        }
    }
    
    结果:
    父类--静态变量
    父类--静态初始化块
    子类--静态变量
    子类--静态初始化块
    子类main方法
    父类--变量
    父类--初始化块
    父类--构造器
    i=9,j=0
    子类--变量
    子类--初始化块
    子类--构造器
    i=9,j=20

    子类的静态变量和静态初始化块的初始化是在父类的变量、初始化块和构造器初始化之前就完成了。静态变量、静态初始化块,变量、初始化块初始化了顺序取决于它们在类中出现的先后顺序。

     

    分析

    (1) 访问SubClass.main(),(这是一个static方法),于是装载器就会为你寻找已经编译的SubClass类的代码(也就是SubClass.class文件)。在装载的过程中,装载器注意到它有一个基类(也就是extends所要表示的意思),于是它再装载基类。不管你创不创建基类对象,这个过程总会发生。如果基类还有基类,那么第二个基类也会被装载,依此类推。

    (2) 执行根基类的static初始化,然后是下一个派生类的static初始化,依此类推。这个顺序非常重要,因为派生类的“static初始化”有可能要依赖基类成员的正确初始化。

    (3) 当所有必要的类都已经装载结束,开始执行main()方法体,并用new SubClass()创建对象。

    (4) 类SubClass存在父类,则调用父类的构造函数,你可以使用super来指定调用哪个构造函数。基类的构造过程以及构造顺序,同派生类的相同。首先基类中各个变量按照字面顺序进行初始化,然后执行基类的构造函数的其余部分。

    (5) 对子类成员数据按照它们声明的顺序初始化,执行子类构造函数的其余部分。

    展开全文
  • 代码执行顺序

    2009-09-28 22:38:00
    常见代码块有以下种:(1)普通代码块:以{}括起来的程序段,例如方法体。(2)构造块:直接在类中定义的代码块,也是以{}括起来的。(3)静态块:static {},以关键字static修饰的块。(4)同步代码块:...

     

    常见代码块有以下几种:

    (1)普通代码块:以{}括起来的程序段,例如方法体。

    (2)构造块:直接在类中定义的代码块,也是以{}括起来的。

    (3)静态块:static {},以关键字static修饰的块。

    (4)同步代码块:synchronized{}以关键字synchronized修饰的块。

    执行顺序:
    一般情况下:构造块会被重复调用多次,构造块会优于构造方法执行,静态块主要目的是用来为静态属性初始化,静态块优于主方法执行,静态块优于构造块执行,而且只执行一次。

    综上可以的知道:

    各部分基本顺序为:

    静态代码块  > 构造块 > 匿名构造器 > 构造方法 >其他

    并且每部分都是先执行父类中的代码,接着再执行子类中的相应部分。匿名构造器和构造方法只有在创建实例对象时才执行,静态代码块则是在类加载和字节码分析完成后再执行,演示只执行静态代码块,不执行匿名构造器和构造方法的代码用的是 Class.forName("xxx.xx.MyClass");

    展开全文
  • java 内部类(六)

    2010-06-10 08:37:46
    1.普通代码块,在一个方法中直接用{},就称为普通代码块。2.构造代码块,直接在类中用{},构造块会优先于构造...new 几次类的时候会执行多次。3.静态块,使用static声明的代码块,静态块的主要目的是静态属性初始化。...

    1.普通代码块,在一个方法中直接用{},就称为普通代码块。
    2.构造代码块直接在类中用{},构造块会优先于构造方法执行。new 几次类的时候会执行多次。
    3.静态块,使用static声明的代码块,静态块的主要目的是静态属性初始化。static{...}
    new 几个次类的时候会执行一次。静态块优先于构造块执行。
    4.在屏幕上输出helloworld,但不使用主方法。
    public class Test{
        static{
             System.out.println("Hello World!!"): 
             System.exit(1);
        }
    }
    5.内部类:
    class Outer{
     private String name = "HELLO WORLD!!!" ;
     class Inner{
      public void print(){
       System.out.println("name = " + name) ;
      }
     };
     public void fun(){
      new Inner().print() ; // 打印信息
     };
    };
    public class InnerClassDemo01{
     public static void main(String args[]){
      new Outer().fun() ;
     }
    };
    //这样程序有点混乱,改进如下:
    class Outer{
     private String name = "HELLO WORLD!!!" ;
     public void fun(){
      new Inner(this).print() ; // 打印信息 };
     public String getName(){
      return this.name ;
     }
    };
    class Inner{
     private Outer out ;
     public Inner(Outer out){
      this.out = out ;
     }
     public void print(){
      System.out.println("name = " + this.out.getName()) ;
     }
    };
    public class InnerClassDemo02{
     public static void main(String args[]){
      new Outer().fun() ;
     }
    };
    内部类唯一的好处就是可以方便访问外部类的私有成员,如果要在外部直接使用内部类的实例化对象:
    外部类.内部类 内部类对象=外部类实例.new 内部类实例().
    class Outer{
     private String name = "HELLO WORLD!!!" ;
     class Inner{
      public void print(){
       System.out.println("name = " + name) ;
      }
     };
    };
    public class InnerClassDemo03{
     public static void main(String args[]){
      Outer ut = new Outer() ; // 外部类实例
      Outer.Inner in = out.new Inner() ; //实例化内部类对象
      in.print() ;
     }
    };
    一个内部类如果使用static关键字的话,则内部类将成为外部类。直接可以通过外部类.内部类访问
    class Outer{
     private static String name = "HELLO WORLD!!!" ;
     static class Inner{
      public void print(){
       System.out.println("name = " + name) ;
      }
     };
    };
    public class InnerClassDemo04{
     public static void main(String args[]){
      Outer.Inner in = new Outer.Inner() ; // 实例化内部类对象
      in.print() ;
     }
    };
    内部类可以在任意的地方使用,在方法中声明:
    class Outer{
     private String name = "HELLO WORLD!!!" ;
     public void fun(){
      class Inner{
       public void print(){
        System.out.println("name = " + name) ;
       }
      }
      new Inner().print() ;
     }
    };
    public class InnerClassDemo05{
     public static void main(String args[]){
      new Outer().fun() ;
     }
    };
    在方法中定義的內部類,可以直接訪問外部類的各方法成員,但如果訪問方法中的參數,則在參數上要使用final關鍵字申明。
    class Outer{
     private String name = "HELLO WORLD!!!" ;
     public void fun(final int temp){
      class Inner{
       public void print(){
        System.out.println("temp = " + temp) ;
        System.out.println("name = " + name) ;
       }
      }
      new Inner().print() ;
     }
    };
    public class InnerClassDemo06{
     public static void main(String args[]){
      new Outer().fun(30) ;
     }
    };

    来自 “ ITPUB博客 ” ,链接:http://blog.itpub.net/15127599/viewspace-664908/,如需转载,请注明出处,否则将追究法律责任。

    转载于:http://blog.itpub.net/15127599/viewspace-664908/

    展开全文
  • 10.6.2 实现单线程代码块 461 10.6.3 乐观锁定 463 10.6.4 基于行的锁定 464 10.6.5 逻辑工作单元 469 10.7 最佳实践 470 10.8 总结 471 第11章 数据访问策略 472 11.1 即席SQL 473 11.1.1 优点 474 11.1.2...
  • java类初始化过程

    2012-01-04 22:00:58
    /* 测试3个内容: 类加载顺序 子父类执行过程 对象初始化过程 ...从几次试验我们看到 ...当执行到类时,类被加载...而普通变量,普通代码块,构造方法,在每次实例化对象时都要初始化 子类对象要初始化时, 先初始化父
    /*
    测试3个内容:
    类加载顺序
    子父类执行过程
    对象初始化过程
    
    
    
    
    从几次试验我们看到
    当执行到类时,类被加载到内存,并初始化
    静态成员被加载到共享区
    不用实例化对象就可以调用静态资源
    
    
    静态成员变量,静态成员方法,静态代码块,只初始化一次
    
    
    而普通变量,普通代码块,构造方法,在每次实例化对象时都要初始化
    
    
    子类对象要初始化时,
    会先初始化父类静态成员和静态代码块,
    再初始化子类静态成员和静态代码块,
    然后是父类普通代码块,父类构造方法
    然后是子类普通代码块,子类构造函数
    
    
    
    
    当子类名直接调用继承自父类的静态成员时,子类不会初始化,而只初始化父类(因为这已经足够了)
    
    
    
    
    */
    
    
    
    class Fu  //父类
    {
      public static String staticField = "父类-静态变量";
      public static String extend = "父类-静态变量extend";  //让子类调用
      public String field = "父类-普通变量";
      public Fu() 
      {
          System.out.println("父类-构造方法");
      }
      
      static 
      {
          System.out.println("Fu_static: 父类-静态初始化块");
          System.out.println("Fu_static:"+staticField);     
      }
      
      {
          System.out.println("Fu_普通块:"+field);
          System.out.println("Fu_普通块:"+"父类-初始化块");
      }
    }
    
    
    
    
    class Zi extends Fu  //子类
    {
      public static String staticField = "子类 静态变量";
      
      public String field = "子类 普通变量";
    
    
      {
          System.out.println("Zi_普通块:"+field);
          System.out.println("Zi_普通块:"+"子类 初始化块");
      }
      
      public Zi() 
      {
          System.out.println("子类 子类构造方法");
      }
      
      static 
      {
          System.out.println("Zi_static:"+"子类 静态初始化块");
          System.out.println("Zi_static:"+staticField);
      }
    
    
    }
    
    
    
    
    class Demo            
    {
      public static void main(String args[])  throws Exception
      {
          System.out.println("main方法");
          //Thread.sleep(2000);
          //System.out.println("Zi.staticField:"+Zi.staticField);
          
          //Thread.sleep(2000);
          //System.out.println("...");
          //Fu fu = new Fu();
          
          Thread.sleep(2000);
          System.out.println("");
          
          Zi zi = new Zi();
          System.out.println("");
          Zi zi2 = new Zi();      
          //System.out.println(Zi.extend);  //子类名调用父类静态成员
      }
      
    }  

    from:

    http://xouou.iteye.com/blog/1333841


    展开全文
  • qq123 2018年09月07日 452 0测试3个内容:1.类加载顺序2.子父类执行过程3.对象初始化过程从几次试验...而普通变量,普通代码块,构造方法,在每次实例化对象时都要初始化6.子类对象要初始化时,先初始化父类静态成员...
  • 入门学习Linux常用必60个命令实例详解doc/txt

    千次下载 热门讨论 2011-06-09 00:08:45
    halt执行时,杀死应用进程,执行sync(将存于buffer中的资料强制写入硬盘中)系统调用,文件系统写操作完成后就停止内核。若系统的运行级别为0或6,则关闭系统;否则以shutdown指令(加上-h参数)来取代。  ...
  • javascript入门笔记

    2018-05-15 15:01:07
    代码块 :包含多条可执行的语句 2、函数的声明与调用 1、普通函数 语法: function 函数名(){ 语句块; } 调用:在JS中任何的合法位置处,都可以通过 函数名() 的方式进行调用 练习: 1、声明一个函数,...
  • php高级开发教程说明

    2008-11-27 11:39:22
    • 抽出单独代码块。 • 使用文件来将函数分类。 • 编写文档。 下面将讨论上述各主题。 1.3.2 使代码更易读 在阅读的时候,为了理解文章的含义,你的大脑必须分析从你的眼睛里获得的信息,识别 出重要的部分,然后...
  • 于是在程序中不断加打印语句,通过后台的DBWIN调试程序跟踪,最后终于定位为:每当执行到portdsl.c的DeviceDslMsgProc()函数中处理U口透传的 if ( SPC_STATE_OK == pSpcCB->bySpcState ) 语句时,主机复位。但是该...
  • CruiseYoung提供的带有详细...这章是本书的精华,而且也是理解Oracle的关键所在。第9章讨论redo和undo,解释了它们分别是什么,并指出如何避免各种可能出现的错误。第10章介绍了各种类型的表,其中最重要的是堆组织表...
  • C#微软培训教材(高清PDF)

    千次下载 热门讨论 2009-07-30 08:51:17
    18.2 在 C #代码中调用 C++和 VB 编写的组件 .240 18.3 版 本 控 制 .249 18.4 代 码 优 化 .252 18.5 小 结 .254 第五部分 附 录 .255 附录 A 关 键 字.255 附录 B 错 误 码.256 附录 C .Net 名字空间...
  • 【05-面向对象(下)】

    2018-07-03 21:42:31
    Lambda表达式需要返回值,而它的代码块中仅有一条省略了return的语句,Lambda表达式自动返回这条语句的 值。 Lambda表达式与函数式接口 •如果采用匿名内部类语法来创建函数式接口的实例,只要实现一...
  • C#微软培训资料

    2014-01-22 14:10:17
    18.2 在 C #代码中调用 C++和 VB 编写的组件 .240 18.3 版 本 控 制 .249 18.4 代 码 优 化 .252 18.5 小 结 .254 第五部分 附 录 .255 附录 A 关 键 字.255 附录 B 错 误 码.256 附录 C .Net 名字空间...
  • Toad 使用快速入门

    2008-11-27 15:22:14
     可以执行匿名,存储过程,从下方的窗口看到DBMS_OUTPUT的结果,如: 3. Stored Procedure Editor a) 打开存储过程编写器的个途径: 单击总菜单栏上的第三个按钮:   点击Database - > Procedure ...
  • 执行P操作意味着请求分配一个单位资源,因此S的值减1;当S时,表示已经没有可用资源,请求者必须等待别的进程释放该类资源,它才能运行下去。而执行一个V操作意味着释放一个单位资源,因此S的值加1;若S 0,表示...
  • Thinking.In.Java

    2012-03-21 22:35:53
    拥有这个资料后,通常可以更有效地执行特殊情况下的操作。本章将解释RTTI的用途、如何使用以及在适当的时候如何放弃它。此外,Java 1.1的“反射”特性也在这里得到介绍。 (12) 第12章:传递和返回对象 由于...
  • 8.3.2 非分布式PL/SQL代码块中的COMMIT 249 8.4 完整性约束和事务 250 8.4.1 IMMEDIATE约束 251 8.4.2 DEFERRABLE约束和级联更新 251 8.5 不好的事务习惯 255 8.5.1 在循环中提交 255 8.5.2 使用自动提交 261...
  • 杠精说,你可以用的鼠标,鼠标给你提供了宏的功能,但是你有权不使用。那么我也可以说,4000的显示器给了你144Hz以及2K甚至4K的显示分辨率,你也有权不使用,你可以改回60Hz和1080p,显卡也是一样。 出于...

空空如也

空空如也

1 2 3 4
收藏数 66
精华内容 26
关键字:

普通代码块会执行几次