JAVA代码块

最新推荐文章于 2024-07-15 22:27:12 发布
最新推荐文章于 2024-07-15 22:27:12 发布
阅读量425 收藏
点赞数
分类专栏： JAVA编程高级部分 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47267628/article/details/122790253
版权
代码块

基本介绍：代码化块又称为初始化块，属性类中的成员【即是类的一部分】，类似于方法，将逻辑语句封装在方法体中，通过{}包围起来

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

基本语法

[修饰符] {代码};

说明注意：

  1. 修饰符可选，要写的话，也只能写static
  2. 代码块分为两类，使用static修饰的叫静态代码块，没有static修饰的，叫普通代码块或非静态代码块
  3. 逻辑语句可以为任何逻辑语句（输入，输出，方法调用，循环，判断等）
  4. ;号可以写上，也可以省略

代码块作用的结论：（记住）

  1. 可以把相同的语句，放入到一个代码块中
  2. 当我们不管调用哪个构造器，创建对象，都会先调用代码块的内容
  3. 代码块调用的顺序优先于构造器

代码块的好处和案例演示：

  1. 相当于另外一个形式的构造器（对构造器的补充机制），可以做初始化的操作
  2. 场景：如果多个构造器中都有重复的语句，可以抽取到初始化块中，提高代码的重用性。
  3. 代码块的快速入门：CodeBlock01.java
package JAVA面向对象高级部分.static_.codeBlock;

public class CodeBlock01 {
    public static void main(String[] args) {
        Movie movie = new Movie("寒战2");
        System.out.println("--------------------");
        Movie movie1 = new Movie("无双", 125.168, "无双导演");
    }
}

class Movie{
    private String name;
    private double price;//时长
    private String director;

    /**
     * 代码块的作用：
     * 代码块是优先于构造器执行的
     * 不管用那个构造器初始化，都会调用非静态代码块
     */
    {
        System.out.println("电影屏幕打开。。。");
        System.out.println("电影广告。。。");
        System.out.println("电影开始播放。。。");
    }
    public Movie() {
//        System.out.println("电影屏幕打开。。。");
//        System.out.println("电影广告。。。");
//        System.out.println("电影开始播放。。。");
    }

    public Movie(String name) {
        this.name = name;
        System.out.println("Movie(String name) 构造器被调用。。。");
//        System.out.println("电影屏幕打开。。。");
//        System.out.println("电影广告。。。");
//        System.out.println("电影开始播放。。。");
    }

    public Movie(String name, double price, String director) {
        this.name = name;
        this.price = price;
        this.director = director;
        System.out.println("Movie(String name, double price, String director) 被调用。。。");
//        System.out.println("电影屏幕打开。。。");
//        System.out.println("电影广告。。。");
//        System.out.println("电影开始播放。。。");
    }
}

返回值：
    电影屏幕打开。。。
    电影广告。。。
    电影开始播放。。。
    Movie(String name) 构造器被调用。。。
    --------------------
    电影屏幕打开。。。
    电影广告。。。
    电影开始播放。。。
    Movie(String name, double price, String director) 被调用。。。

代码块的使用注意事项和细节说明（七点必须记住）

静态代码块是针对类的加载的，而普通代码块是针对创建对象初始化的（普通代码块是构造器的补充机制，可以认为是一个特殊的构造器）

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

2.类什么时候被加载（三种情况）【记住】

  1. 创建对象实例时(new)
  2. 创建子类对象实例，父类也会被加载
  3. 使用类的静态成员（成员方法和成员属性）

3.普通的代码块，在创建对象实例时，会被隐式的调用，被创建一次，就会调用一次。如果只是使用类的静态成员时，普通代码块并不会执行[意思是如果只使用静态成员时，不会调用普通代码块]

小结：（1）static代码块是类加载时，执行，只会执行一次

（2）普通代码块是在创建对象时调用的，创建一次，调用一次

（3）类加载3种情况，需要记住

注意：当两个类继承关系时，先执行父类的静态代码块，再执行子类的静态代码块，最后再执行父类的非静态代码块和子类的非静态代码块，非静态代码块是创建对象时才会被执行

package JAVA面向对象高级部分.static_.codeBlock;

public class CodeBlockDetail01 {
    public static void main(String[] args) {
//        A a = new A();
//        A a1 = new A();
        /**
         * 返回值是：
             我是静态代码块
             我是普通代码块
             我是普通代码块
         */

        System.out.println("-----------------");
       // C c = new C();
        /**返回值：
         * 我是B类的静态代码块
         * 我是C类的静态代码块
         * 我是B类的非静态代码块
         * 我是C类的非静态代码块
         */

        System.out.println("------------------");
        //注意是：非静态代码块是创建对象时，才会被执行
        //System.out.println(C.name);
        /**
         * 我是B类的静态代码块
         * 我是C类的静态代码块
         * 我是程序员！！！呵呵
         */

        System.out.println("----------------");
        System.out.println(D.number);
        /**
         * 返回值：
         * 我是D类的静态代码块
         * 168
         */
    }
}

/**
 * 第一个细节：
 * static代码块也叫静态代码块，作用就是对类进行初始化，而且它随着类加载而执行
 * 并且只会执行一次，如果是普通代码块，每创建一个对象就执行一次
 */
class A {
    //静态代码块,注意代码块只能用static修饰，只会加载一次，随着类加载而加载
    static {
        System.out.println("我是静态代码块");
    }
    //非静态代码块（普通代码块），每创建一个对象就执行一次
    {
        System.out.println("我是普通代码块");
    }
}

/**
 * 类什么时候被加载【必须记住】
 * 1.创建对象实例时（new）
 * 2.创建子类对象实例，父类也会被加载
 * 3.使用类的静态成员时（静态属性或静态方法）
 */

class B {
    //静态代码块
    static {
        System.out.println("我是B类的静态代码块");
    }
    //非静态代码块（普通代码块）
    {
        System.out.println("我是B类的非静态代码块");
    }
}

class C extends B {
    public static String name = "我是程序员！！！呵呵";

    //C类静态代码块
    static {
        System.out.println("我是C类的静态代码块");
    }

    //C类非静态代码块
    {
        System.out.println("我是C类的非静态代码块");
    }
}

/**
 * 普通的代码块，在创建对象实例时，会被隐式的调用，被创建一次，就会调用一次，
 * 如果只是使用类的静态成员时，普通代码块是不会被执行的，普通代码块是针对创建对象的
 */

class D {
    public static int number = 168;

    //静态代码块，在加载类信息时，就会被调用一次，并且只会调用一次
    static {
        System.out.println("我是D类的静态代码块");
    }

    //非静态代码块，如果不创建对象时，是不会调用非静态代码块的，并且创建一次调用一次
    {
        System.out.println("我是D类的非静态代码块");
    }
}

说明使用类的静态成员【成员方法和属性】时，都会使类的加载

代码块细节说明2（记住）

4.创建一个对象时，在一个类调用顺序是：（重点记住）

  1. 调用静态代码块和静态属性的初始化（注意：静态代码块和静态属性初始化调用的优先级一样，如果有多个静态代码块和多个静态变量初始化，则按他们的定义顺序调用）
  2. 调用普通代码块和普通属性的初始化（注意：普通代码块和普通属性初始化调用的优先级一样，如果有多个普通代码块和多个普通属性初始化，则按他们的定义顺序调用）、
  3. 调用构造器
package JAVA面向对象高级部分.static_.codeBlock;

public class CodeBlockDetail02 {
    public static void main(String[] args) {
        //System.out.println(A1.number);
        /**
         * 返回值是：
         * 我是getNumber()的静态方法
         * 我是A1的静态代码块
         * 100
         */
        A1 a1 = new A1();
        /**
         * 返回值：
         * 我是getNumber()的静态方法
         * 我是A1的静态代码块
         * 我是getSum()非静态方法
         * 我是A1类的非静态代码块
         * 我是A1的构造器，初始化最后！！！
         */

    }
}

class A1 {
    //非静态属性初始化
    public int sum = getSum();

    //静态属性的初始化
    public static int number = getNumber();

    //非静态属性初始化
    public int getSum(){
        System.out.println("我是getSum()非静态方法");
        return 200;
    }

    //非静态代码块
    {
        System.out.println("我是A1类的非静态代码块");
    }

    //静态代码块
    static {
        System.out.println("我是A1的静态代码块");
    }

    public static int getNumber(){
        System.out.println("我是getNumber()的静态方法");
        return 100;
    }
    public A1(){
        System.out.println("我是A1的构造器，初始化最后！！！");
    }
}

细节3：(记住)

构造器前面隐含的super关键和调用普通代码块（顺序是super关键字到普通代码块）,创建对象的入口是构造器，构造器前面隐含的super和普通代码块决定了执行的顺序

构造器的最前面其实隐含了super()和调用普通代码块，静态相关的代码块，属性初始化，在类加载时，就执行完毕，因此是优先于构造器和普通代码块执行的CodeBlockDetail03.java

package JAVA面向对象高级部分.static_.codeBlock;

public class CodeBlockDetail03 {
    public static void main(String[] args) {
        Cat cat = new Cat();//创建对象的入口是从构造器的
        /**
         * 返回值：
         * 我是Animal类的非静态代码块
         * 我是Animal类的无参构造器
         * 我是Cat类的非静态代码块
         * 我是Cat类的无参构造器
         */
    }
}

/**
 * 构造器的最前面其实隐含了super()和调用本类普通代码块，静态相关的代码块，
 * 属性初始化，在类加载时，就执行完毕了，因此是优先于构造器和普通代码块的执行
 */
class Animal {
    {
        System.out.println("我是Animal类的非静态代码块");
    }
    //Animal类的无参构造器
    public Animal(){
        //这里隐含了
        super();//调用父类的无参构造器
        //这里还隐含了调用本类的非静态代码块
        System.out.println("我是Animal类的无参构造器");
    }
}

class Cat extends Animal{
    {
        System.out.println("我是Cat类的非静态代码块");
    }

    public Cat(){
        //这里隐含了
        super();//调用父类的无参构造器
        //这是还隐含了调用本类的非静态代码块
        System.out.println("我是Cat类的非静态代码块");
    }
}

细节4（记住）（必须理解下面的代码）

创建一个子类对象时（继承关系），他们的静态代码块，静态属性初始化，普通代码块，普通属性初始化，构造方法的调用顺序如下：

  1. 父类的静态代码块和静态属性（优先级一样，按定义顺序执行）:注意没有初始化静态方法因为静态是需要调用才会执行
  2. 子类的静态代码块和静态属性（优先级一新，按定义顺序执行）:注意没有初始化静态方法因为静态是需要调用才会执行
  3. 父类的普通代码块和普通属性初始化（优先级一样，按定义顺序执行）:注意没有初始化静态方法因为静态是需要调用才会执行
  4. 父类的构造器
  5. 子类的普通代码块和普通属性初始化（优先级一样，按定义顺序执行）:注意没有初始化静态方法因为静态是需要调用才会执行
  6. 子类的构造器

继承关系的执行顺序：（1）父类的静态代码块和静态属性的初始化，子类的静态代码块和静态属性的初始化（2）父类普通代码块和普通属性的初始化到父类的构造器 （3）子类普通代码块和普通属性初始化到子类的构造器

父子静态 --》 父类普通 --》父类构造器 --》子类普通 --》子类构造器

小结：在继承关系下，创建对象分两个大步：

第一大步是：先加载父类和子类信息

  1. 先加载父类的静态代码块和静态属性初始化:注意没有初始化静态方法因为静态方法是需要调用才会执行
  2. 再加载子类的静态代码块和静态属性初始化:注意没有初始化静态方法因为静态方法是需要调用才会执行

第二大步是：再创建子类对象，创建对象的入口是从构造器开始，构造器前面默认调用 父类（使用super关键字）代码块和普通属性的初始化

  1. 父类的普通代码块和普通属性初始化:注意没有初始化静态方法因为静态是需要调用才会执行
  2. 父类的构造器
  3. 子类的普通代码块和普通属性初始化:注意没有初始化静态方法因为静态是需要调用才会执行
  4. 子类的构造器

静态方法是调用时才会被执行的

细节5：

静态代码块只能直接调用静态成员（静态属性和静态方法），普通代码块可以调用任意成员

package JAVA面向对象高级部分.static_.codeBlock;

public class CodeBlockDetail04 {
    public static void main(String[] args) {
        //1.先进行父类的加载
        //2.再创建对象，是从子类的构造器开始的
        new Student();
        /**
         * 返回值
         * 我是Person类一个getVal01方法
         * 我是Person类一个静态代码块
         * 我是Student类的getVal03方法
         * 我是Student类的静态代码块
         * 我是Person类一个getVal02方法
         * 我是Person类一个普通代码块
         * 我是Person类的无参构造器
         * 我是Student类的getVal04方法
         * 我是Student类的非静态代码块
         * 我是Student类的无参构造器
         */
    }
}

class Person {
    //注意是静态方法是调用才会被执行的
    private static int n1 = getVal01();
    public int n2 = getVal02();

    static {
        System.out.println("我是Person类一个静态代码块");//(2)
    }

    {
        System.out.println("我是Person类一个普通代码块");//(6)
    }

    public static int getVal01(){
        System.out.println("我是Person类一个getVal01方法");//(1)
        return 10;
    }

    public int getVal02(){
        System.out.println("我是Person类一个getVal02方法");//(5)
        return 20;
    }
    //构造器
    public Person(){
        //1.隐含了super()
        //2.隐含了普通代码和普通属性的初始化
        System.out.println("我是Person类的无参构造器");//(7)
    }
}

class Student extends Person {
    private static int n3 = getVal03();
    public int n4 = getVal04();

    static {
        System.out.println("我是Student类的静态代码块");//(4)
    }

    {
        System.out.println("我是Student类的非静态代码块");//(9)
    }

    public static int getVal03(){
        System.out.println("我是Student类的getVal03方法");//(3)
        return 30;
    }

    public int getVal04(){
        System.out.println("我是Student类的getVal04方法");//(8)
        return 40;
    }

    public Student(){
        //1.这里隐含了super()语句
        //2.还普通代码块和普通属性的初始化
        System.out.println("我是Student类的无参构造器");
    }
}

练习：

class Person {
	public static int total;
	static {
		total = 100;
		System.out.println("in static block!");
	}
}

public cals　Test{
	public static void main(String[] args){
		System.out.println("total="+Person.total);
		System.out.println("total="+Person.total);
	}
}

/**
 *返回值：
 * in static block!
 * total=100
 * total=100
 */

练习2

class Sample{
	Sample(String s){
		System.out.println(s);
	}
	Sample(){
		System.out.println("Sample默认构造器函数被调用");
	}
}

class Test{
	Sample sam1 = new Sample("sam1成员初始化");
	static Sample sam = new Sample("静态成员sam初始化");
	static {
		System.out.println("static块执行");
		if(sam == null)
		System.out.println("sam is null");
    }
		Test(){
			System.out.println("Test默认构造器被调用");
		}
}

public static void main(String[] str[]){
	Test a = new Test();
}

/**
 * 返回值：
 *  静态成员sam初始化
 * static块执行了
 * sam1成员初始化
 * Test默认构造函数被调用

对象创建步骤：

  1. 加载类的信息（类信息的加载会倒致静态代码块和静态属性的初始化，加载类信息的三种方式：1.创建对象 2.创建子类对象（父类的类信息也会加载）3.静态属性或静态方法的调用）
  2. 在堆中开辟空间，并对属性初始化（构造器的调用会调用super语句和普通代码块的执行）
  3. 将堆中的地址赋给方法区中的引用
昱晟168
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
markdown java代码块 语法_MarkDown 语法详解
weixin_30913041的博客
02-16 4843
MarkDown 语法详解Markdown是一种纯文本格式的标记语言。通过简单的标记语法，它可以使普通文本内容具有一定的格式。相比WYSIWYG编辑器优点：1、因为是纯文本，所以只要支持Markdown的地方都能获得一样的编辑效果，可以让作者摆脱排版的困扰，专心写作。 2、操作简单。比如:WYSIWYG编辑时标记个标题，先选中内容，再点击导航栏的标题按钮，选择几级标题。要三个步骤。而Markdow...
Java代码块与代码加载顺序原理详解
08-25
Java代码块与代码加载顺序原理详解 Java代码块是Java语言中的一种基本结构单元，用于组织代码，控制变量的生命周期和作用域。本文将详细介绍Java代码块的类型、特点、使用方法和加载顺序原理。 一、代码块的类型 ...
Java代码块
qq_46084827的博客
06-26 4320
代码块是类的成分之一：成员变量，方法，构造器，代码块，内部类。在Java中，使用 { } 括起来的代码被称为代码块（Code block） 1.1 代码块的分类根据其位置和声明的不同，可以分为： 局部代码块：用于限定变量生命周期，及早释放，提高内存利用率。 静态代码块：主要用于对静态属性进行初始化。 实例（构造）代码块：调用构造方法都会执行，并且在构造方法前执行。 同步代码块：一种多线程保护机制。在方法中出现，可以限定变量生命周期，及早释放，提高内存利用率。 2.1 示例代码
java代码块
j218255的博客
04-22 2311
java类的五大成员分别是属性、方法、构造器(构造函数)、代码块、内部类本篇文件将向大家介绍其中之一的代码块。
java 代码块的作用_4种Java代码块的作用讲解
weixin_28864249的博客
02-12 1981
4种Java代码块的作用讲解时间：2017-06-28来源：华清远见JAVA学院今天华清Java学院小编要和大家分享的是Java代码块的作用，代码块是一种常见的代码形式，他用大括号“{｝”将多行代码封装在一起，形成一个独立的代码区，这就构成了代码块。代码块的格式如下：java中的代码块按其位置划分为四种：Java代码块一：局部代码块位置：局部位置(方法内部)作用：限定变量的生命周期，尽早...
java 代码块(局部代码块、实例代码块、静态代码块、同步代码块)
冰茶不冰的博客
01-06 8254
1 引言 代码块是类的成分之一：成员变量，方法，构造器，代码块，内部类。 在Java中，使用 { } 括起来的代码被称为代码块（Code block） 1.1 代码块的分类 根据其位置和声明的不同，可以分为： 局部代码块：用于限定变量生命周期，及早释放，提高内存利用率。 静态代码块：主要用于对静态属性进行初始化。 实例（构造）代码块：调用构造方法都会执行，并且在构造方法前执行。 同步代码块：一种多线程保护机制。 2 局部代码块 在方法中出现，可以限定变量生命周期，及早释放，提高内存利用率。 2.1 示例
Java 代码块详解
WYSCODER的博客
02-26 2314
下午了，一起喝杯Java吧，了解代码块和类加载中代码的执行顺序。
java 代码块_详解java中的四种代码块
weixin_30030437的博客
02-12 1871
在java中用{}括起来的称为代码块，代码块可分为以下四种：一.简介1.普通代码块：类中方法的方法体2.构造代码块：构造块会在创建对象时被调用，每次创建时都会被调用，优先于类构造函数执行。3.静态代码块：用static{}包裹起来的代码片段，只会执行一次。静态代码块优先于构造块执行。4.同步代码块：使用synchronized(){}包裹起来的代码块，在多线程环境下，对共享数据的读写操作是需要互斥...
Java类的内部代码块大全
weixin_45203607的博客
10-03 1646
Java-代码块大全 1.普通代码块： 类中方法的方法体 public void show(){ name="h2"; System.out.println("普通代码块"); } 2.构造代码块： 构造代码块使用{ } 会在每次创建对象时被调用， 优先于类的构造函数执行。 { name="hu1"; System.out.println("构造代码块"); } 3.静态代码块： 用static{}包裹起来的代
Java代码块（代码块与静态代码块使用细节及调用顺序）
m0_59442510的博客
09-14 4295
代码块又称为初始化块，属于类中的成员【即 是类的一部分】，类似于类的方法，将逻辑语句封装在方法体中，通过{}包围起来。但和方法不同，没有方法名，没有返回值，没有参数，只有方法体，而且不用通过对象或类显式调用，而是加载类时，或创建类时隐式调用。相当于另外一种形式的构造器（对构造器的补充机制），可以做初始化的操作。场景：如果多个构造器中都有重复的语句，可以将重复部分抽取到代码块中，提高代码的重用性。
Java中的代码块
m0_67683346的博客
05-12 6407
初识代码块
java 代码块与静态代码块加载顺序
08-29
Java 代码块与静态代码块加载顺序详解 Java 代码块与静态代码块加载顺序是 Java 语言中一个重要的概念，理解这两个概念对于编写高效、可靠的 Java 代码至关重要。本文将详细介绍 Java 代码块与静态代码块加载顺序的...
java代码块测试.zip
02-03
Java代码块测试是软件开发过程中一个重要的环节，它主要用于验证代码的功能是否按预期工作。JUnit是Java编程语言中最常用的单元测试框架，它为开发者提供了一种简洁、高效的测试工具，可以编写可重复运行的测试用例...
java 代码块折叠插件
11-07
Java 代码块折叠插件是一种增强IDE（集成开发环境）功能的工具，它允许程序员更加高效地管理和阅读源代码。在编程过程中，特别是在处理大型项目时，代码的组织和可读性至关重要。代码块折叠功能使得开发者能够隐藏...
最长见的java代码块
03-15
//获取文件名 File in = new File("文件地址"); String fileName = in.getName(); String name = fileName.substring(fileName.lastIndexOf(".")+1); 等等
《JavaSE》---6.＜基础语法（Java三大程序控制结构）＞
m0_73456341的博客
07-14 825
本篇博客主要讲解Java基础语法中的三大结构，一种顺序结构、两大分支结构i（if-else、swich-case）、四大循环结构（while、do while、fot、foreach）
Spring Security 授权
persistence_PSH的博客
07-14 900
在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。通过 RBAC 获取到用户的具体权限后，再通过 Security 的 用户-权限-资源 来进行权限控制。HttpSecurity 权限配置。
【Go系列】 Sync并发控制
u013379032的博客
07-14 1021
在上一篇文章中，我们介绍了goroutine和channel，理论上，通过channel可以实现并发控制，但是其他语言的开发者可能更习惯一些原子操作的库。当然Go语言也会提供这样的库，所以我们今天了解一下sync库。
day04：Redis和店铺营业状态设置
最新发布
m0_69266818的博客
07-15 827
介绍了Redis命令和用java操作redis还有营业额状态接口的书写
java 代码块
05-24
Java 代码块是一段包含 Java 语句的代码片段，用于实现特定的功能或定义变量。Java 代码块分为两种类型：静态代码块和实例代码块。 静态代码块： 静态代码块是在类加载时执行的，只会执行一次。主要用于初始化静态...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值