java中的代码块

已于 2024-01-16 11:25:52 修改
阅读量766 收藏 23
点赞数 25
文章标签： java 前端 开发语言
于 2024-01-15 21:21:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lmd187/article/details/135602678
版权

基本介绍：

概念：

代码块又称为初始化块，属于类中的成员[即是类的一部分]，类似于方法（可以看作只有方法体的方法），讲逻辑语句封装在方法体 中，通过{ }包围起来。

但和方法不同，没有方法名，没有返回值，没有参数，只有方法体，而且不用通过对象或者类显式调用，而是加载类时，或创建对象时隐式调用。

基本语法：

[修饰符]{
    代码
};

细节：

1）修饰符可写可不写，如果写必须是static；

2）代码块分为两类，使用static修饰的叫做静态代码块，没有static修饰的叫做普通代码块；

3）逻辑语句可以为任何逻辑语句（输入、输出、方法调用、循环、判断等）；

4）；号可以写也可以省略，建议写上。

代码块的好处：

1）相当于另外一种形式的构造器（普通代码块对构造器的补充机制），可以做初始化操作；

2）如果多个构造器存在重复语句，可以抽取到初始化块中，提高代码的重用性；

3）举例说明：

public class Test{
 
    public static void main(String[] args){
        Student tom = new Student("tom");
        Student jack = new Student("jack",18);
        Student smith = new Student("smith,22,10001);
    }
}
class Student{
    //私有属性
    private String name;
    private int age;
    private long id;
    //代码块
    {
        System.out.println("即将对学生点名！");
        System.out.println("即将核对学生年龄！");
        System.out.println("即将核对学生学号！");
    }
    //构造器    
    public Student(String name){
        this.name = name;
        System.out.println("调用了Student类的Student(String name)构造器");
    }
    public Student(String name , int age){
        this.name = name;
        this.age = age;
        System.out.println("调用了Student类的Student(String name , int age)构造器");
    }
    public Student(String name , int age , long id){
        this.name = name;
        this.age = age;
        this.id = id;
        System.out.println("调用了Student类的Student(String name , int age , long id)构造器");
    }
}

输出结果：

即将对学生点名！

即将核对学生年龄！

即将核对学生学号！

调用了Student类的Student(String name)构造器

即将对学生点名！

即将核对学生年龄！

即将核对学生学号！

调用了Student类的Student(String name ， int age)构造器

即将对学生点名！

即将核对学生年龄！

即将核对学生学号！

调用了Student类的Student(String name ， int age ， long id)构造器
 

代码块使用注意事项和细节


1）static代码块也叫静态代码块，作用就是对类进行初始化，而且它随着类的加载而执行，并且只会执行一次。如果是普通代码块，随着创建一个对象执行。
        静态代码块随类加载而生，普通代码块随对象创建而生

2）类什么时候被加载[重要]：

①创建对象实例时（Student student = new Student();）；
②创建子类对象实例，父类也会被加载；
③使用类的静态成员时（静态属性、静态方法）
package com.pero.codeblock;
 
/**
 * 类加载的三种情况
 * @version 1.0
 * @author Pero
 */
 
public class Test01 {
    public static void main(String[] args) {
        //类被加载的情况举例
        //1.创建对象实例时
        //Person person = new Person();
        //2.创建子类对象实例，父类也会被加载，父类先被加载，子类后被加载
        //Student student = new Student();
        //3.使用类的静态成员时（静态属性、静态方法）
        System.out.println(Teacher.age);
    }
}
class Person {
    //静态代码块
    static {
        System.out.println("Person类的静态代码块1被执行");
    };
}
 
class Student extends Person{
    //静态代码块
    static {
        System.out.println("Student类的静态代码块1被执行");
    };
}
 
class Teacher{
    public static int age = 26;
 
    //静态代码块
    static {
        System.out.println("Teacher类的静态代码块1被执行");
    }
}
3）普通代码块，在创建对象实例时，会被隐式调用。被创建一次，就会调用一次。（可以将普通代码块看作构造器的补充，构造器被调用，他就会被调用）
package com.pero.codeblock;
 
/**
 * 类加载的三种情况
 * @version 1.0
 * @author Pero
 */
 
public class Test01 {
    public static void main(String[] args) {
        //类被加载的情况举例
        //1.创建对象实例时
        //Person person = new Person();
        //2.创建子类对象实例，父类也会被加载，父类先被加载，子类后被加载
        //Student student = new Student();
        //3.使用类的静态成员时（静态属性、静态方法）
        //System.out.println(Teacher.age);
 
        //类加载时，静态代码块只执行一次
        //普通代码块在创建对象实例时，会被隐式调用，创建一次就调用一次
        //如果只是使用类的静态成员时，普通代码块不会被执行
        Teacher teacher1 = new Teacher();
        Teacher teacher2 = new Teacher();
        System.out.println(Teacher.age);
 
    }
}
class Person {
    //静态代码块
    static {
        System.out.println("Person类的静态代码块1被执行");
    };
}
 
class Student extends Person{
    //静态代码块
    static {
        System.out.println("Student类的静态代码块1被执行");
    };
}
 
class Teacher{
    public static int age = 26;
 
    //静态代码块
    static {
        System.out.println("Teacher类的静态代码块1被执行");
    }
    //普通代码块
    {
        System.out.println("Teacher类的普通代码块1被执行");
    };
}
4）创建一个对象时，在一个类调用顺序是：

①调用静态代码块和静态属性初始化（注意：    静态代码块和静态属性  初始化调用的优先级一样，如果有多个静态代码块和多个静态变量初始化，按照定义顺序（谁写前面先调用谁）调用）；
②调用普通代码块和普通属性的初始化（注意：普通话代码块和普通属性初始化调用的优先级一样，如果有多个普通代码块和多个普通属性初始化，按照定义顺序调用）；
③调用构造方法；
 
package com.pero.codeblock;
 
/**
 * 创建一个对象时，在一个类调用顺序是：
 * ①调用静态代码块和静态属性初始化（注意：静态代码块和静态属性初始化调用的优先级一样，
 * 如果有多个静态代码块和多个静态变量初始化，按照定义顺序调用）；
 * ②调用普通代码块和普通属性的初始化（注意：普通话代码块和普通属性初始化调用的优先级一样，
 * 如果有多个普通代码块和多个普通属性初始化，按照定义顺序调用）；
 * ③调用构造方法；
 *
 * @version 1.1
 * @author Pero
 */
 
public class Test02 {
    public static void main(String[] args) {
        Model01 model01 = new Model01();
        //（1）Model01静态属性被执行，getNumber1被调用
        // (2)Model01的静态代码块1被执行
        // (3)Model01普通属性被执行，getNumber2被调用
        // (4)Model01的普通代码块1被执行
        // (5)Model01构造器被执行
    }
}
class Model01{
 
    //普通属性的初始化
    private int number2 = getNumber2();
 
    //静态属性的初始化
    private static int number1 = getNumber1();
 
    //无参构造器
    public Model01(){
        System.out.println("Model01的构造器被执行");
    }
 
    //普通代码块
    {
        System.out.println("Model01的普通代码块1被执行");
    };
 
    //静态代码块
    static {
        System.out.println("Model01的静态代码块1被执行");
    };
 
    //静态方法
    public static int getNumber1(){
        System.out.println("静态方法getNumber1()方法被调用");
        return 100;
    }
    //普通方法
    public int getNumber2(){
        System.out.println("普通方法getNumber2()方法被调用");
        return 200;
    }
 
 
}
5）构造器的前面隐含了super()和普通代码块的执行，静态相关的代码块和属性的初始化在类加载时就已经执行完毕，因此是优先于普通代码块和属性的初始化及构造器的执行； 
package com.pero.codeblock;
 
/**
 * 构造器的前面隐含了super()和普通代码块的执行，
 * 静态相关的代码块和属性的初始化在类加载时就已经执行完毕，
 * 因此是优先于普通代码块和属性的初始化及构造器的执行；
 *
 * @version 1.3
 * @author Pero
 */
public class Test03 {
    public static void main(String[] args) {
        new T02();
        // (1)T01的普通代码块被执行
        // (2)T01构造器被调用
        // (3)T02的普通代码块被调用
        //（4）T02的构造器被调用
    }
}
class T01{
    //父类是Object类
    {
        System.out.println("T01的普通代码块被执行");
    };
    public T01(){
        System.out.println("T01的无参构造器被调用");
    }
}
class T02 extends T01{
    //普通代码块
    {
        System.out.println("T02的普通代码块被执行");
    };
    public T02(){
        //super();
        //调用本类的普通代码块
        System.out.println("T01的无参构造器被调用");
    }
}

先加载后构造，加载静态，构造普通

父静态(按顺序) -> 子静态(按顺序) -> 父普通(按顺序) -> 父构造 -> 子普通(按顺序) -> 子构造
 

6）创建一个子类时（继承关系），父类与子类的静态代码块，静态属性初始化，普通代码块，普通属性初始化，构造方法的调用顺序；

①父类的静态代码块和静态属性（优先级一样，按定义顺序执行）；
②子类的静态代码块和静态属性（优先级一样，按定义顺序执行）；
③父类的普通代码块和普通属性初始化（优先级一样，按定义顺序执行）；
④父类构造方法；
⑤子类的普通代码块和普通属性初始化（优先级一样，按定义顺序执行）；
⑥子类的构造方法；
 
package com.pero.codeblock;
 
/**
 * 创建一个子类时（继承关系），父类与子类的静态代码块，静态属性初始化，普通代码块，
 * 普通属性初始化，构造方法的调用顺序；
 * ①父类的静态代码块和静态属性（优先级一样，按定义顺序执行）；
 * ②子类的静态代码块和静态属性（优先级一样，按定义顺序执行）；
 * ③父类的普通代码块和普通属性初始化（优先级一样，按定义顺序执行）；
 * ④父类构造方法；
 * ⑤子类的普通代码块和普通属性初始化（优先级一样，按定义顺序执行）；
 * ⑥子类的构造方法；
 */
 
public class Test04 {
    public static void main(String[] args) {
        //（1）进行类的加载
        // 1.1先加载父类Animal类（执行静态代码块和属性）；
        // 1.2再加载子类Dog类（执行静态代码块和属性）；
        //（2）创建对象
        // 从子类的构造器开始
        // 2.1.1 super()
        // 2.1.2 父类的普通代码块和普通属性
        // 2.1.3 父类的构造方法
        // 2.2.1 子类的普通代码块和普通属性
        // 2.2.2 子类的构造方法
        new Dog();
    }
}
class Animal{
 
    private static int a1 = getA1();//(1)
 
    static {
        System.out.println("Animal类的静态代码块1");//(2)
    };
 
    {
        System.out.println("Animal类的普通代码块1");//(5)
    };
 
    public int a2 = getA2();//(6)
 
    public static int getA1(){
        System.out.println("Animal类的getA1静态方法");//(1)
        return 100;
    }
 
    public int getA2(){
        System.out.println("Animal类的getA2普通方法");//(6)
        return 200;
    }
 
    public Animal(){
        //super();
        //普通代码块和属性的初始化
        System.out.println("Animal类的无参构造器");//(7)
    }
}
class Dog extends Animal{
 
    private static int a3 = getA3();//(3)
 
    static {
        System.out.println("Dog类的静态代码块1");//(4)
    };
 
    public int a4 = getA4();//(8)
 
    {
        System.out.println("Dog类的普通代码块1");//(9)
    }
 
    public static int getA3(){
        System.out.println("Dog类的getA3静态方法");//(3)
        return 300;
    }
 
    public int getA4(){
        System.out.println("Dog类的getA4普通方法");//(8)
        return 400;
    }
 
    public Dog(){
        //super();
        //普通代码块和属性的初始化
        System.out.println("Dog类的无参构造器");//(10)
    }
}
7）静态代码块只能调用静态成员（静态属性和静态方法），普通代码块可以调用任意成员。
 
class Cat{
    private int n1 = 100;
    private static int n2 = 200;
 
    private void m1(){
        System.out.println("Cat类的普通方法m1()");
    }
    private static void m2(){
        System.out.println("Cat类的静态方法m2()");
    }
 
    //静态代码块
    static {
        //System.out.println(n1);错误
        System.out.println(n2);
        //m1();错误
        m2();
    };
    
    //普通代码块
    {
        System.out.println(n1);
        System.out.println(n2);
        m1();
        m2();
    };
}

练习

第一次Person.total加载类信息  执行上面的 静态属性和静态代码块  输出 in static block  然后输出100

 第一次Person.total，无需加载类信息，直接输出100

输出1）静态成员sam初始化  2）static块被执行 3）sam1成员初始化  4)Test默认构造器函数被调用  

TJU@第一炼丹师
关注
  • 25
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java学习之代码块
wjkqq0921的博客
01-09 1254
代码块、类加载、静态、非静态、继承、构造器、创建对象实例
Java~~静态代码块
weixin_57858263的博客
04-11 9351
第七章：关于静态代码块 1.可以使用static关键字来定义“静态代码块”： （1）语法格式： static{ java语句； } （2）静态代码块在类加载时执行，并且只执行一次。 （3）静态代码块在一个类中可以编写多个，并且遵循自上而下的顺序依次执行。 （4）静态代码块的作用是什么？怎么用？用在哪儿？什么时候用？ -----这当然和具体的需求有关，例如项目中要求在类加载的时刻/时机执行代码完成日志的记录。那么这段记录日志的代码就...
Java中的代码块
m0_67683346的博客
05-12 6340
初识代码块
java静态代码块
qq_52091004的博客
07-12 1242
回顾java静态代码块
创建一个对象时，在一个类当中 静态代码块 和普通代码块构造方法 的顺序？
qq_48508278的博客
03-26 316
一:前言须知 普通代码块，在创建对象实例的时候，会被调用，每创建一次，就调用一次 静态代码块，在类加载的时候执行，并且只会执行一次 类加载的时机: 创建对象实例的时候（new） 创建子类实例的时候,父类也会被加载 使用类的静态成员时(静态属性,静态方法) 二:顺序 先执行静态属性 == 静态代码块（这两个按在代码中的顺序） 再执行普通代码 == 普通属性 再执行构造方法 public class text03 { public static void main(String[] args
举例说明Java中代码块的执行顺序
09-03
主要介绍了举例说明Java中代码块的执行顺序,包括静态属性和非静态属性以及构造函数等相关的执行先后,需要的朋友可以参考下
Java静态代码块作用及执行顺序解析
08-19
主要介绍了Java静态代码块作用及执行顺序解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Java 普通代码块静态代码块执行顺序(实例讲解)
08-29
下面小编就为大家带来一篇Java 普通代码块静态代码块执行顺序(实例讲解)。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Java静态代码块加载驱动代码实例
08-18
主要介绍了Java静态代码块加载驱动代码实例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
java代码块测试.zip
02-03
包含两个用于JUnit测试的jar包，复制进Java项目文件即可使用@Test功能
java提高篇（十一）-----代码块
pi9nc的专栏
01-21 839
java提高篇（十一）-----代码块 分类： 程序设计-----java提高篇2013-11-07 21:21 289人阅读 评论(0) 收藏 举报 目录(?)[+]        在编程过程中我们可能会遇到如下这种形式的程序： [java] view plaincopyprint? public 
【Java】代码块（这可能是你看过的最全的代码块解析了）
xiaoliii0401的博客
07-17 634
适合初学Java或学后复习者观看，七大条注意事项非常详细，重点已突出标记，学过的人来看也能学到新的东西。
【java学习—九】类的成员之四：初始化块（1）
最新发布
weixin_44883789的博客
10-25 228
在程序运行过程中，非静态代码块每次new对象都又重新执行，静态代码块只执行一次。在实际开发中，static静态代码用在初始化类的静态属性（static类型属性）。②显式初始化、多个初始化块依次被执行（同级别下按先后顺序执行）不可以对非静态的属性初始化。即：不可以调用非静态的属性和方法。问题：现在想把name改成李四，但是不想动Person的代码。每次创建对象的时候，都是执行一次。静态代码块的执行要先于非静态代码块。非静态代码块每new一次就执行一次。可以调用静态和非静态的变量或方法。静态代码块只执行一次。
【Java学习笔记】 37 - 代码块
qq_41891655的博客
10-23 71
代码化块又称初始化块，属于类中的成员（即是类的一部分）类似于方法，将逻辑语句封装在方法体中，通过{}包围起来但和方法不同，没有方法名，没有返回，没有参数，只有方法体，而且不用通过对象或类显式调用，而是加载类时或创建对象时隐式调用。
面向对象-----学习笔记（static/final/代码块）
qq_42383299的博客
08-21 502
static/final/代码块等内容总结
java 静态代码块
木南飘香
05-27 5362
                      （一）java 静态代码块 静态方法区别 一般情况下,如果有些代码必须在项目启动的时候就执行的时候,需要使用静态代码块,这种代码是主动执行的;需要在项目启动的时候就初始化,在不创建对象的情况下,其他程序来调用的时候,需要使用静态方法,这种代码是被动执行的.静态方法在类加载的时候 就已经加载 可以用类名直接调用 比如main方法就必须是静态的，这是程序入口
代码块详解
听海的博客
05-23 1332
什么是代码块？ 在类或者方法中，直接使用{}括起来的一段代码，表示一块代码区域，代码块里变量属于局部变量，只在自已所在的区域内（前后的{}）有效。 根据代码块定义的位置不同，我们又分为三种形式： 局部代码块：直接定义在方法内部的代码块。一般的，我们不会直接使用局部代码块的，只不过我们会结合if，while，try等关键字联合，表示一块代码区域。 局部代码块
java中代码块知识点
05-05
Java 中的代码块是指一段被大括号包裹的代码，并且代码块可以嵌套。 Java 中的代码块分为以下几种类型： 1. 类初始化块：用 static 关键字修饰，每个类只会被执行一次，用于对类进行初始化操作。 2. 对象初始化块...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值