代码块_代码块执行顺序 - CSDN
精华内容
参与话题
  • Java几种代码块的定义与常见问题

    千次阅读 2018-10-16 17:16:36
    代码块的简单用法与常见问题 代码块,通俗的说就是用一对“{}”括起来的一段代码,代码块可以根据位置分为以下几类: 局部代码块:局部代码块就是指直接在方法或是语句中定义的代码块,请看如下范例: package ...

    Java几种代码块的定义与常见问题

    代码块,通俗的说就是用一对“{}”括起来的一段代码,代码块可以根据位置分为以下几类:

    局部代码块:局部代码块就是指直接在方法或是语句中定义的代码块,请看如下范例:

    package org.qty.demo1;
    
    public class Demo1 {
        public static void main(String[] args) {
            {
                int i= 10;
                System.out.println(i+",我是局部代码块");
            }
            int i = 20;
            System.out.println(i);
        }
    }
    

    结果打印:
    10,我是局部代码块
    20

    以上就是利用了局部代码块对主方法进行了“分隔”,局部代码块起到了限定的作用,即使变量重名,在这里变量i的作用域只限定于局部代码块之内,而不会影响代码块以外,所以局部代码块主要作用是分隔。

    构造代码块:构造代码块就是指定义在成员位置的代码块,或者说就是直接写在类中的代码块。
    观察如下范例:

    class A{
        String name;      //成员属性
        {                          
            System.out.println("我是构造代码块");        //与构造方法同级
        }
        public A(){      //构造方法
            System.out.println("我是A类的构造方法");
        }
    }
    public class Demo {       
        public static void main(String[] args) {
            A a1 = new A();
            A a2 = new A();
        }
    }
    

    结果打印:
    我是构造代码块
    我是A类的构造方法
    我是构造代码块
    我是A类的构造方法

    在类中可以看到代码块是定义在成员位置的,与构造方法、成员属性同级,这就是构造块,也就是直接定义在类中的代码块。
    从结果很容易可以看出以下两点:

    1. 在实例化A类对象a1、a2时,构造块的执行顺序是大于构造方法的(这里和构造块写前写后没关系,将构造块写在构造方法后面也是一样的结果)
    2. 每当实例化一次A类对象时,都会在执行构造方法之前优先执行构造代码块。

    静态代码块:静态代码块就是指用static关键字修饰的代码块。
    观察如下范例:

    class A{
        String name;    //成员属性
        {
            System.out.println("我是构造代码块");
        }
        static {
            System.out.println("我是静态代码块");
        }
        public A(){      //构造方法
            System.out.println("我是A类的构造方法");
        }
    }
    public class Demo {
        public static void main(String[] args) {
            A a = new A();
            A b = new A();
            A c = new A();
        }
    }
    

    输出打印:
    我是静态代码块
    我是构造代码块
    我是A类的构造方法
    我是构造代码块
    我是A类的构造方法
    我是构造代码块
    我是A类的构造方法

    从结果能看出,执行顺序:静态代码块>构造代码块>构造方法,这从static关键字的含义也能得知,因为static修饰过后的量会随着class文件一同加载,属于优先级最高的。
    说到执行顺序再来看一个范例:

    class A {
        public A() {
            System.out.println("class A");
        }
        {
            System.out.println("I'm A class");
        }
        static {
            System.out.println("class A static");
        }
    }
    class B extends A {
        public B() {
            System.out.println("class B");
        }
        {
            System.out.println("I'm B class");
        }
        static {
            System.out.println("class B static");
        }
    }
    public class Demo {
        public static void main(String[] args) {
            B b = new B();
        }
    }
    

    结果打印:
    class A static
    class B static
    I’m A class
    class A
    I’m B class
    class B

    当实例化子类对象时,首先要加载父类的class文件进内存,静态代码块由于有static修饰,所以是随着类的创建而执行,所以父类静态代码块最先被执行,子类class文件再被加载,同理静态代码块被先执行;实例化子类对象要先调用父类的构造方法,而调用父类构造方法前会先执行父类的构造代码块,因此就有如下顺序:

    父类静态代码块——>子类静态代码块——>父类构造块——>父类构造方法——>子类构造块——>子类构造方法

    展开全文
  • 1什么是代码块?? 答:代码块:在Java中用{}括起来的内容. 2:代码块的分类! (1)局部代码块 在类的局部位置 作用:限定当前变量的声明周期 *变量x在类中只使用一次, 用一个局部代码块,是为了在代码块...

    1什么是代码块??
    答:代码块:在Java中用{}括起来的内容.
    2:代码块的分类!

    (1)局部代码块
    在类的局部位置 作用:限定当前变量的声明周期
    *变量x在类中只使用一次, 用一个局部代码块,是为了在代码块结束后,内存自动释放,减少内存的使用
    是顺序执行的,只是在执行结束后,立即消失。*

    main(..){
    {
    int x;
    x = 10;
    System.out.println(x) ;
    }
    }
    (2)构造代码块
    在类的成员位置
    特点:每次在执行构造方法之前,如果当前类中有构造代码块,优先执行构造代码块,然后在执行构造方法!
    作用:可以多个构造方法中共性代码可以放到构造代码中,对象初始化
    //构造块:直接在类中定义且没有加static关键字的代码块称为{}构造代码块。构造代码块在创建对象时被调用,每次创建对象都会被调用,并且构造代码块的执行次序优先于类构造函数。

    public class Demo1{
    {
    System.out.println(“第一代码块”);
    }

    public Demo1(){
    System.out.println(“构造方法”);
    }

    {
    System.out.println(“第二构造块”);
    }
    public static void main(String[] args){
    new Demo1();
    new Demo1();
    new Demo1();

    }
    }

    /*
    *
    执行结果:
    第一代码块
    第二构造块
    构造方法
    第一代码块
    第二构造块
    构造方法
    第一代码块
    第二构造块
    构造方法
    */
    (3) 静态代码块
    静态代码块:在java中使用static关键字声明的代码块。静态块用于初始化类,为类的属性初始化。每个静态代码块只会执行一次。由于JVM在加载类时会执行静态代码块,所以静态代码块先于主方法执行。
    //如果类中包含多个静态代码块,那么将按照”先定义的代码先执行,后定义的代码后执行”。
    //注意:1 静态代码块不能存在于任何方法体内。2 静态代码块不能直接访问静态实例变量和实例方法,需要通过类的实例对象来访问。
    在类的成员位置:
    static{

    }
    特点:只执行一次,被static修饰的,都和类有关系!
    class Code{
    {
    System.out.println(“Code的构造块”);
    }

    static{
    System.out.println(“Code的静态代码块”);
    }

    public Code(){
    System.out.println(“Code的构造方法”);
    }
    }

    public class Code1{
    {
    System.out.println(“Code1的构造块”);
    }

    static{
    System.out.println(“Code1的静态代码块”);
    }

    public Code1(){
    System.out.println(“Code1的构造方法”);
    }

    public static void main(String[] args){
    System.out.println(“Code1的主方法”);
    new Code();
    new Code();
    new Code1();
    new Code1();
    }
    }
    /*
    Code1的静态代码块
    Code1的主方法
    Code的静态代码块
    Code的构造块
    Code的构造方法
    Code的构造块
    Code的构造方法
    Code1的构造块
    Code1的构造方法
    Code1的构造块
    Code1的构造方法
    */
    3:关于构造代码块,静态代码块,构造方法之间的优先级?
    静态代码块>构造代码块>构造方法

    展开全文
  • 详解java中的四种代码块

    千次阅读 2018-03-09 16:52:07
    详解java中的四种代码块 转载 2017-12-07 作者:krisll 我要评论 这篇文章主要介绍了详解java中的四种代码块,具有一定借鉴价值,需要的朋友可以参考下。 在java中用{}括起来的...

    详解java中的四种代码块

    转载  2017-12-07   作者:krisll    我要评论

    这篇文章主要介绍了详解java中的四种代码块,具有一定借鉴价值,需要的朋友可以参考下。

    在java中用{}括起来的称为代码块,代码块可分为以下四种:

    一.简介

    1.普通代码块:

    类中方法的方法体

    2.构造代码块

    构造块会在创建对象时被调用,每次创建时都会被调用,优先于类构造函数执行。

    3.静态代码块:

    用static{}包裹起来的代码片段,只会执行一次。静态代码块优先于构造块执行。

    4.同步代码块:

    使用synchronized(){}包裹起来的代码块,在多线程环境下,对共享数据的读写操作是需要互斥进行的,否则会导致数据的不一致性。同步代码块需要写在方法中。

    二.静态代码块和构造代码块的异同点

    相同点:都是JVM加载类后且在构造函数执行之前执行,在类中可定义多个,一般在代码块中对一些static变量进行赋值。

    不同点:静态代码块在非静态代码块之前执行。静态代码块只在第一次new时执行一次,之后不在执行。而非静态代码块每new一次就执行一次。

    三.示例

    普通代码块:在方法或语句中出现的{}就称为普通代码块。普通代码块和一般语句的执行顺序由他们在代码中出现的次序决定,先出现先执行。

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    public class Test {
      public static void main(String[] args) {
        {
          int x = 3;
          System.out.println("普通代码块内的变量x=" + x);
        }
        int x = 1;
        System.out.println("主方法内的变量x=" + x);
        {
          int y = 7;
          System.out.println("普通代码块内的变量y=" + y);
        }
      }
    }
    /*
     * 运行结果  普通代码块内的变量x=3
     *      主方法内的变量x=1
     *      普通代码块内的变量y=7
     */

    构造代码块:直接在类中定义且没有加static关键字的代码块称为{}构造代码块。构造代码块在创建对象时被调用,每次创建对象都会被调用,并且构造代码块的执行次序优先于类构造函数。如果存在多个构造代码块,执行顺序由他们在代码中出现的次序决定,先出现先执行。

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    public class Test1 {
        {
            System.out.println("第一构造块");
        }
        public Test1(int i) {
            System.out.println("第" + i + "次调用" + "构造方法");
        }
        {
            System.out.println("第二构造块");
        }
        public static void main(String[] args) {
            new Test1(0);
            new Test1(1);
            new Test1(2);
        }
    }
    /*
     * 执行结果 第一构造块
     *      第二构造块
     *      第0次调用构造方法
     *      第一构造块
     *      第二构造块
     *      第1次调用构造方法
     *      第一构造块
     *      第二构造块
     *      第2次调用构造方法
     */

    静态代码块:在java中使用static关键字声明的代码块。静态块用于初始化类,为类的属性初始化。每个静态代码块只会执行一次。由于JVM在加载类时会执行静态代码块,所以静态代码块先于主方法执行。

    如果类中包含多个静态代码块,那么将按照"先定义的代码先执行,后定义的代码后执行"。

    注意:

    1.静态代码块不能存在于任何方法体内。

    2.静态代码块不能直接访问实例变量和实例方法,需要通过类的实例对象来访问。

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    public class Test3 {
        public static String STATIC_FIELD = "静态属性";
        // 静态块
        static {
            System.out.println(STATIC_FIELD);
            System.out.println("静态代码块1");
        }
        public String field = "非静态属性";
        // 非静态块
        {
            System.out.println(field);
            System.out.println("非静态代码块2");
        }
        public InitOderTest() {
            System.out.println("无参构造函数");
        }
        public static void main(String[] args) {
            InitOderTest test = new InitOderTest();
        }
        // 非静态块
        {
            System.out.println(field);
            System.out.println("非静态代码块1");
        }
        // 静态块
        static {
            System.out.println(STATIC_FIELD);
            System.out.println("静态代码块2");
        }
    }
    /*
     * 运行结果 静态属性
     *      静态代码块1
     *      静态属性
     *      静态代码块2
     *      非静态属性
     *      非静态代码块2
     *      非静态属性
     *      非静态代码块1
     *      无参构造函数
     */

    以下代码演示了创建一个对象并调用方法各个代码块之间的优先关系:

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    public class Person {
        static{
            System.out.println("1.我是静态块,优先于构造块执行!并且只有创建第一个对象的时候执行一次!");
        }
        {
            System.out.println("2.我是构造块,优先于构造方法执行!每创建一个对象执行一次!");
        }
        public Person() {
            System.out.println("3.我是构造方法,每创建一个对象执行一次");
        }
        public void function1(){
            System.out.println("我是非静态方法中的普通代码块,方法被调用时执行!");
        }
        public static void function2(){
            System.out.println("我是静态方法中的普通代码块,方法被调用时执行,晚于静态块执行!");
        }
    }

    测试类:

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    public class HelloWrold {
        public static void main(String[] args) {
            new Person().function1();
            new Person().function1();
            System.out.println("=================");
            Person.function2();
            Person.function2();
        }
    }

    运行结果:

    我们可以看出:静态块总是最先执行的,并且只有在创建该类的第一个实例的时候才会执行一次;第二执行的是构造块;第三执行的是构造方法。

    总结

    以上就是本文关于详解java中的四种代码块的全部内容,希望对大家有所帮助。感兴趣的朋友可以继续参阅本站其他相关专题,如有不足之处,欢迎留言指出。感谢朋友们对本站的支持!

    展开全文
  • 代码块

    2018-07-24 23:50:05
    什么是代码块:在类或者在方法中,直接使用"{}"括起来的一段代码,表示一块代码区域。  代码块里变量属于局部变量,只在自己所在区域(前后的{})内有效。  根据代码块定义的位置的不同,我们又分成三种形式...

    什么是代码块:在类或者在方法中,直接使用"{}"括起来的一段代码,表示一块代码区域。

     代码块里变量属于局部变量,只在自己所在区域(前后的{})内有效。 

    根据代码块定义的位置的不同,我们又分成三种形式:

     1):局部代码块:直接定义在方法内部的代码块:         

    一般的,我们是不会直接使用局部代码块的,只不过我们会结合if,while,for,try等关键字联合,表示一块代码区域. 

    2):初始化代码块(构造代码块):直接定义在类中.    

     每次创建对象的时候都会执行初始化代码块:         每次创建对象都会调用构造器,在调用构造器之前,会先执行本类中的初始化代码块.        通过反编译之后,我们发现,初始化代码也作为构造器的最初的语句.        我们一般不使用初始化代码块的,难看,即使要做初始化操作,我们一般在构造器中做即可,如果做初始化操作的代码比较多,此时构造器的结构比较混乱,此时专门定义一个方法做初始化操作,再在构造器中调用即可.

     3):静态代码块:

    使用static修饰的初始化代码块.      在主方法执行之前执行静态代码块,而且只执行一次.      main方法是程序的入口,为什么静态代码块优先于main方法执行.      --->:静态成员随着字节码的加载也加载进JVM,此时main方法还没执行,因为方法需要JVM调用.             先把字节码加载进JVM,  而后JVM再调用main方法.     一般的,我们用来做初始化操作,加载资源,加载配置文件等.

     

     

     

     

    package dijiutian;

    class root{

        static{

            System.out.println("fsdfsdf");

        }

        {

            System.out.println("root.....");

        }

        public root() {

            // TODO Auto-generated constructor stub

            System.out.println("root.....||||");

        }

    }

    class mid extends root{

        {

            System.out.println("123455");

        }

        static {

            System.out.println("6789954646545");

        }

        public mid() {

            // TODO Auto-generated constructor stub

            System.out.println("56+879+*++784fiueutrfyw");

        }

    }

    public class mokuaihua {

        public static void main(String[] args) {

            // TODO Auto-generated method stub

             new mid();

        }

    }

     

     

    结果如下

    fsdfsdf

    6789954646545

    root.....

    root.....||||

    123455

    56+879+*++784fiueutrfyw

    展开全文
  • 代码块的概述和分类

    2018-03-20 10:51:03
    构造方法作用: Java使用构造...与构造器作用非常类似的是构造代码块,它也可以对Java对象进行初始化操作。 2.代码块是Java类里的第四种成员(成员变量、成员方法、构造方法)。 3.一个类里可以有多个构造代码块,...
  • java中静态代码块详解

    万次阅读 多人点赞 2019-04-17 18:05:42
    今天在项目中看到这行代码,静态代码块,很久没用静态代码块了,今天来复习一下, 依旧按照为什么?是什么?怎么用?的思想,去学习。 【为什么?】 先说说代码中为什么要使用这种写法吧, 还记得静态代码块的...
  • C语言代码块

    千次阅读 2019-01-20 16:02:49
    求某某范围内的闰年 #include<stdio.h&...{
  • Static静态代码块以及各代码块之间的执行顺序

    千次阅读 多人点赞 2019-10-24 20:05:01
    文章目录代码块的分类1、静态代码块(也叫静态块、静态初始化块)2、构造代码块(也叫构造初始化块)3、代码块(又叫普通代码块、初始化块)执行顺序的代码测试继承中各代码块的执行顺序 代码块的分类 基本上代码...
  • 静态代码块---学会这个就够了

    万次阅读 多人点赞 2020-02-04 00:43:59
    所谓的代码块就是一段独立的代码空间,那什么是静态代码块呢?说白了,静态代码块就是用static修饰的代码块,关于静态代码块的概念不多说,不过你需要知道它的一个特点,那就是 随着类的加载而执行,而且只执行一次...
  • IDEA-自定义常用代码块

    万次阅读 2020-03-26 14:53:39
    前言.如何设置 设置使用的地方 1.设置类注释模板代码 /** * @author: lujie * @create: $date$ ...2.JUC-lock锁代码块 lock.lock(); try { } catch (Exception e) { e.printStackTrace(); } finall...
  • * 代码块:在Java中,使用{}括起来的代码成为代码块 * 根据其位置和声明的不同,可以分为 * 局部代码块:局部位置,用于限定变量的生命周期 * 构造代码块:在类中的成员位置,用{}括起来的代码。每次调用构造...
  • 静态代码块是以static修饰的代码块,反之没有用static修饰的代码块为非静态代码块,如下所示: 静态代码块: static{ 若干代码 } 非静态代码块: { 若干代码 } 它们之间的区别主要如下: 静态代码块在...
  • 静态代码块:最早执行,类被载入内存时执行,只执行一次。没有名字、参数和返回值,有关键字static。构造代码块:执行时间比静态代码块晚,比构造函数早,和构造函数一样,只在对象初始化的时候运行。没有名字、参数...
  • java构造代码块详解

    万次阅读 多人点赞 2017-02-06 15:58:53
    简介首先说一下,Java中有哪些代码块.普通代码块就是在方法后面使用"{}"括起来的代码片段,不能单独执行,必须调下其方法名才可以执行. 静态代码块在类中使用static修饰,并使用"{}"括起来的代码片段,用于静态变量的初始...
  • //Java中静态代码块,普通代码块,构造代码块区别及代码示例 //执行顺序:(优先级从高到低)静态代码块>mian方法>构造代码块>构造方法。 //其中静态代码块只执行一次。构造代码块在每次创建对象是都会执行。 1 普通...
  • * 加了static的是静态代码块,在类中写了一对{}是构造代码块,在方法中写了一对{}是普通代码块, * java中还有一种代码块是同步代码块,常用在多线程中, synchronized关键字, * 同步代码块格式是:synchronized(同步...
  • Java提高篇——静态代码块、构造代码块、构造函数以及Java类初始化顺序阅读目录构造函数构造代码块静态代码块Java类初始化顺序静态代码块:用staitc声明,jvm加载类时执行,仅执行一次构造代码块:类中直接用{}定义...
  • 闲暇之余,总结并撸码测试了一下静态代码块、构造代码块、构造方法的执行顺序及需要注意的问题 当然,首先大家得知道静态代码块是跟着类的加载而加载的,而构造代码块和构造方法是随着对象的加载而加载的,相比这个...
  • Java笔记——Java代码块的执行顺序

    千次阅读 2018-09-07 02:12:06
    Java代码块的执行顺序 Java程序中代码块的执行顺序对于学习Java的人来说是必不可少需要掌握的。 代码块 在Java中,使用{}括起来的代码被称为代码块。 根据其位置和声明的不同,可以分为: 局部代码块 构造...
  • vs code设置自定义代码块的方法

    万次阅读 2018-08-05 23:43:28
    2. 然后再选择你需要将此代码块作用在哪种类型的文件。 3. 然后需要配置一个json文件,下图是一个模版 记得在外面包一层 “{}" ,然后每一个代码块就写一个类似该模版的对象,中间用 "," 隔开...
1 2 3 4 5 ... 20
收藏数 1,573,284
精华内容 629,313
关键字:

代码块