Java学习之代码块

news2024/9/25 13:15:31

目录

一、代码块的基本介绍

二、基本语法

注意事项

三、代码块的好处和案例演示

 四、注意事项和使用细节

第一点

第二点

第三点

案例演示

第四点

第五点

第六点

第七点

五、练习题

第一题

第二题

考察知识点

结论

结果

一、代码块的基本介绍


        代码化块又称为初始化块,属于类中的成员[即 是类的一部分]，类似于方法，将逻辑语句封装在方法体中，通过{}包围起来。
        但和方法不同，没有方法名，没有返回，没有参数，只有方法体，而且不用通过对象或类显式调用，而是加载类时，或创建对象时隐式调用


二、基本语法


[修饰符]{

        代码

};


注意事项


1)修饰符 可选，要写的话，也只能写 static

2)代码块分为两类，使用static 修饰的叫静态代码块，没有static修饰的，叫普通代码块/非静态代码块

3) 逻辑语句可以为任何逻辑语句 (输入、输出、方法调用、循环、判断等)
4)； 号可以写上，也可以省略。

三、代码块的好处和案例演示

1)相当于另外一种形式的构造器(对构造器的补充机制)，可以做初始化的操作

2)场景: 如果多个构造器中都有重复的语句，可以抽取到初始化块中，提高代码的重用性

package com.hspedu.codeblock_;

public class CodeBlock01 {
    public static void main(String[] args) {
        Movie movie1 = new Movie("你好李焕英");
        System.out.println("==========");
        Movie movie2 = new Movie("你好李焕英", 50);
        System.out.println("==========");
        Movie movie3 = new Movie("你好李焕英", 50, "贾玲");
    }
}
class Movie {
    private String name;
    private double price;
    private String director;

    //三个构造器构成了重载
    //观察可得：下面的三个构造器都有相同的语句，这样看起来比较冗余
    //这时我们可以把相同的语句放入到一个代码块中即可
    //不管调用哪个构造器，创建对象，都会先调用代码块的内容
    //代码块的调用顺序优先于构造器

    {
        System.out.println("电影屏幕打开...");
        System.out.println("广告开始...");
        System.out.println("电影正式开始...");
    }
    public Movie(String name) {
        System.out.println("Movie(String name)被调用");
        this.name = name;
    }

    public Movie(String name, double price) {
        System.out.println("Movie(String name, double price)被调用");
        this.name = name;
        this.price = price;
    }

    public Movie(String name, double price, String director) {
        System.out.println("Movie(String name, double price, String director)被调用");
        this.name = name;
        this.price = price;
        this.director = director;
    }
}

创建三个对象，分别调用三个构造器，但是在调用构造器之前都会首先调用代码块

 四、注意事项和使用细节

第一点

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

如果将上述代码块改成static代码块，那么运行结果就会不同

第二点

承接第一点，类什么时候被加载[重要背!]
一、创建对象实例时(new)

二、创建子类对象实例，父类也会被加载

三、使用类的静态成员时(静态属性，静态方法)

类加载只和static代码块的执行有关，和普通代码块没有任何关系


第三点

普通的代码块，在创建对象实例时，会被隐式的调用，被创建一次，就会调用一次 。见CodeBlock01.java

如果只是使用类的静态成员时，普通代码块并不会执行（普通代码块是构造器的补充，如果构造器被调用才会导致普通代码块被调用）

案例演示

package com.hspedu.codeblock_;

public class CodeBlockDetail01 {
    public static void main(String[] args) {
        //类加载的时候就会隐式调用代码块，
        // 类加载的三种情况：1)创建对象实例
        //AA aa = new AA();

        //2)创建子类对象实例，父类也会被加载
        System.out.println("=========");
        BB bb = new BB();//创建子类BB类实例，父类AA类也会被加载，而且是先父后子

        //调用类的静态成员时，也会加载类
        //调用子类的静态成员时，父类也会被加载
        //在加载子类的时候，必须要先加载父类
        System.out.println("=========");
        System.out.println(CC.age);
        CC.m1();//static代码块只会执行一次，在调用类变量时就已经执行过一次，这里不会再执行了

        //如果只是使用类的静态成员时，普通代码块并不会执行
        System.out.println("=========");
        System.out.println(EE.n1);//没有创建对象实例，所以只会调用静态代码块1
        EE ee = new EE();//创建对象实例，调用普通代码块2，和类是否加载没有任何关系

    }
}
class EE {
    public static int n1 = 20;
    static {
        System.out.println("EE 的静态代码块1被执行...");
    }
   {
        System.out.println("EE 的普通代码块2被执行...");
    }
}

class DD {
    static {
        System.out.println("DD 的静态代码块1被执行...");
    }
}
class CC extends DD{
    public static int age = 4;
    public static void m1(){
        System.out.println("静态方法m1()被调用...");
    }
    static {
        System.out.println("CC 的静态代码块1被执行...");
    }

}

class AA {
    //静态代码块
    static {
        System.out.println("AA 的静态代码块1被执行...");
    }
}
class BB extends AA{
    static {
        System.out.println("BB 的静态代码块1被执行...");
    }
}

小结

1.static代码块是类加载时执行的，只会执行一次

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

3.类加载的3种情况，需要记住


第四点

创建一个对象时，在一个类 调用顺序是:(重点，难点)

1.调用静态代码块和静态属性初始化(注意: 静态代码块和静态属性初始化调用的优先级一样，如果有多个静态代码块和多个静态变量初始化，则按他们定义的顺序调用)
2.调用普通代码块和普通属性的初始化(注意: 普通代码块和普通属性初始化调用的优先级一样，如果有多个普通代码块和多个普通属性初始化，则按定义顺序调用)

3.调用构造方法

package com.hspedu.codeblock_;

public class CodeBlockDetail02 {
    public static void main(String[] args) {
        //创建对象实例时，会优先调用静态代码块和静态属性初始化
        //谁写在前面就先执行谁
        A a = new A();//输出：1)A 的静态代码块01 2) getN1被调用...3)getN2被调用...4)A 的普通代码块01
    }
}
class A {

    static {//静态代码块
        System.out.println("A 的静态代码块01");
    }


    //静态属性初始化
    private static int n1 = getN1();
    private int n2 = getN2();


    public static int getN1(){
        System.out.println("getN1被调用...");
        return 100;
    }

    public static int getN2(){
        System.out.println("getN2被调用...");
        return 200;
    }

    {//普通代码块
        System.out.println("A 的普通代码块01");
    }
}

第五点

1.构造器 的最前面其实隐含了 super()和 调用普通代码块

2.在类加载时，就执行静态相关的代码块、完成静态属性初始化，因此是优先于普通代码块和构造器执行的 

package com.hspedu.codeblock_;

public class CodeBlockDetail03 {
    public static void main(String[] args) {
        //创建新的子类对象实例后，按照上述规则会依次输出以下四句
        //1)A01 的普通代码块1被调用
        //2)父类A01 构造器被调用
        //3)B01 的普通代码块1被调用
        //4)子类B01 构造器被调用
        B01 b01 = new B01();

    }

}
class A01{

    {
        System.out.println("父类A01 的普通代码块1被调用");
    }

    public A01(){
        //隐藏了super()和普通代码块
        super();//父类：Object类
        //普通代码块
        System.out.println("父类A01 构造器被调用");
    }
}

class B01 extends A01{

    {
        System.out.println("子类B01 的普通代码块1被调用");
    }

    public B01() {
        //隐藏了super()和普通代码块
        super();
        //普通代码块
        System.out.println("子类B01 构造器被调用");
    }
}

第六点

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

1.父类的静态代码块和静态属性(优先级一样，按定义顺序执行)

2.子类的静态代码块和静态属性(优先级一样，按定义顺序执行)

3.父类的普通代码块和普通属性初始化(优先级一样，按定义顺序执行)

4.父类的构造方法

5.子类的普通代码块和普通属性初始化(优先级一样，按定义顺序执行)

6.子类的构造方法

总结：

1.在类加载的时候，就会执行静态代码块、完成属性初始化，所以静态>非静态

2.创建对象实例的时候，会调用构造器，按照继承关系（细节五）

package com.hspedu.codeblock_;

public class CodeBlockDetail05 {
    public static void main(String[] args) {
        //1.类的加载
        //1.1 先加载父类A02; 1.2 加载子类 B02, 先执行静态相关的部分
        // 2.创建对象

        //new C03();
        new B03();
    }
}

class A03 { //父类
    private static int n1 = getVal01();

    static {
        System.out.println("A03 的一个静态代码块..");//第二个输出
    }

    {
        System.out.println("A03 的第一个普通代码块..");//第五个输出
    }

    public int n3 = getVal02();//普通属性的初始化

    public static int getVal01() {
        System.out.println("getVal01");第一个输出
        return 10;
    }

    public int getVal02() {
        System.out.println("getVal02");//第六个输出
        return 10;
    }

    public A03() {//构造器
        //隐藏
        //super()
        //普通代码和普通属性的初始化......
        System.out.println("A03 的构造器");//第七个输出
    }
}


class B03 extends A03 { //子类，继承了父类A03
    private static int n3 = getVal03();//第三个输出

    static {
        System.out.println("B03 的一个静态代码块..");//第四个输出
    }

    public int n5 = getVal04();

    {
        System.out.println("B03 的第一个普通代码块..");//第九个输出
    }

    public static int getVal03() {
        System.out.println("getVal03");//(3)
        return 10;
    }

    public int getVal04() {
        System.out.println("getVal04");//第八个输出
        return 10;
    }

    //一定要慢慢的去品..
    public B03() {//构造器
        //隐藏了
        //super()
        //普通代码块和普通属性的初始化
        System.out.println("B03 的构造器");//第十个输出
        // TODO Auto-generated constructor stub
    }
}

第七点

静态代码块只能调用静态成员，普通代码块可以调用任意成员

package com.hspedu.codeblock_;

public class CodeBlockDetail06 {
    public static void main(String[] args) {
        new A04();
    }
}
class A04 {
    private static int n1 = 10;
    private int n2 = 20;

    private static void m1(){
        System.out.println("静态方法m1()被调用");
    }

    private void m2(){
        System.out.println("普通方法m2()被调用");
    }

    //静态代码块只能调用静态成员
    static {
        System.out.println(n1);
        m1();
        //System.out.println(n2);错误，静态只能调用静态
        //m2();错误，理由同上

    }

    //普通代码块可以调用任意成员
    {
        System.out.println(n1);
        m1();
        System.out.println(n2);
        m2();
    }
}

五、练习题

第一题

package com.hspedu.codeblock_;

public class CodeBlockExercise01 {
    public static void main(String[] args) {
        //调用静态属性，首先进行类加载，类加载的时候会执行静态属性初始化和静态代码块
        //静态属性初始化 :total = 0，
        //静态代码块: total = 100; 输出"in static block";
        //再次调用total，但是static代码块只能执行一次，所以只会输出100
        System.out.println("total = " + Person.total);
        System.out.println("total = " + Person.total);

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

第二题

考察知识点

类的属性可以是基本数据类型，也可以是医用数据类型（对象、数组） 

创建对象时首先会进行类的加载，所以会首先执行静态代码块、完成静态属性初始化（按照位置）

然后执行普通代码块和普通属性（按照位置），最后调用构造器

结论

1）完成静态属性初始化，即：

static Sample sam = new Sample("静态成员sam初始化");

2）调用

Sample(String s) {//有参构造器
    System.out.println(s);
}

3）输出：静态成员sam初始化

4)执行静态代码块

static {//静态代码块
    System.out.println("static块执行");//
    if(sam == null)
        System.out.println("sam is null");
}

  输出：static块执行

5) 完成普通属性初始化

Sample sam1 = new Sample("sam1成员初始化");//

输出：sam1成员初始化

6)执行构造器

Test(){//构造器
    System.out.println("Test默认构造函数被调用");//
}

输出：Test默认构造函数被调用

package com.hspedu.codeblock_;

public class CodeBlockExercise02 {
    public static void main(String[] args) {
        Test a = new Test();//无参构造器
    }
}
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默认构造函数被调用");//
    }
}

结果

 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/151258.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【论文导读】Deep Stable Learning for Out-Of-Distribution Generalization

【论文导读】Deep Stable Learning for Out-Of-Distribution Generalization

DWR用到复杂数据集中。 看了一半发现一个博客将的也不错 放在这里Deep Stable Learning for Out-Of-Distribution Generalization_六点先生的博客-CSDN博客_随机傅里叶特征 目标任务： 一般假设（训练数据的已知异质性（如领域标签&#xff0…
阅读更多...
FGH75T65SHD-F155 场截止沟槽 IGBT单管 应用于太阳能逆变器、UPS等多种应用

FGH75T65SHD-F155 场截止沟槽 IGBT单管 应用于太阳能逆变器、UPS等多种应用

FGH75T65SHD-F155采用新型场截止 IGBT 技术，为太阳能逆变器、UPS、焊接机、电信、ESS 和 PFC 等低导通和开关损耗至关重要的应用提供最佳性能。 ONsemi安森美IGBT单管系列： FGH40N60SMD FGH60N60SMD FGH75T65SHD-F155 NGTB40N120FL2WG 特性&#x…
阅读更多...
架构设计---用户加密处理

架构设计---用户加密处理

前言： 在互联网各种安全问题中，最能引发话题，刺激大众神经的就是用户的泄密问题，数据库被拖库导致所有的数据泄露，这种系统安全问题涉及的因素可能有很多，大部分和开发软件的程序员没有关系，但…
阅读更多...
【PyTorch深度学习实践】03_反向传播

【PyTorch深度学习实践】03_反向传播

文章目录1.计算图2.反向传播2.1 链式求导法则2.2 反向传播过程3.Pytorch中前馈和反馈的计算3.1 Tensor3.2 代码演示对于简单的模型，梯度变换可以用解析式表达进行手算，但是复杂模型（很多w，b）的损失函数需要挨个写解析式…
阅读更多...
【黑马】瑞吉外卖-Day03、04笔记

【黑马】瑞吉外卖-Day03、04笔记

瑞吉外卖Day03、04 公共字段自动填充 使用MybatisPlus实现 问题分析 代码实现 Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。 实现步骤…
阅读更多...
【学习】life long learning

【学习】life long learning

文章目录life long learningLLL的难点评估二、LLL的三个解法1、Selective Synaptic Plasticity选择性突触可塑性为什么会有灾难性遗忘呢？GEM2、Additional Neural Resource Allocation额外的神经资源分配packNet&CPG3、memory replyCurriculum Learninglife lon…
阅读更多...
SAP 字段仍作为视图字段在视图中使用 | 更改表结构重新生成 CDS View「实例」

SAP 字段仍作为视图字段在视图中使用 | 更改表结构重新生成 CDS View「实例」

错误信息 Field ZPDAUSER-ZUSERID is still being used as a view field in view ZV_PDA_USER视图 ZPDAUSER-ZUSERID 仍作为视图字段在视图 ZV_PDA_USER 使用 错误原因 当前表被 CDS View 引用，由 CDS View 生成的「视图」已占用当前表的相关字段然而生成的视图又…
阅读更多...
实战5：基于 Pytorch 搭建 Faster-R-CNN 实现飞机目标检测（代码+数据）

实战5：基于 Pytorch 搭建 Faster-R-CNN 实现飞机目标检测（代码+数据）

任务描述： 通过一个飞机检测的案例来对目标检测的基本概念进行介绍并且实现一个简单的目标检测方法。数据集：使用从COCO数据集抽取的飞机数据集mini-airplane，数据集中的数据均为正常的图片。https://download.csdn.net/download/qq_38735017/87374251运行环境：操作系统：l…
阅读更多...
Day4 基于XML的Spring应用

Day4 基于XML的Spring应用

总结java依赖注入的方式set方法注入List、map和properties的注入通过构造方法注入ref是reference的缩写，需要引用其他bean的id，value用于注入普通属性值。自定义标签和其他标签的引用自定义标签beansbeanimportalias其他标签用于引用其他命名空间1 bean的…
阅读更多...
sqli-labs 第八关 多命通关攻略（Python3 自动化实现布尔盲注）

sqli-labs 第八关 多命通关攻略（Python3 自动化实现布尔盲注）

sqli-labs 第八关 多命通关攻略（Python3 自动化实现布尔盲注）描述判断注入类型正常输入不正常输入错误输入爆破方式的可行性铺垫函数 IF()关于 MySQL 数据类型之间转换的小小礼物（仅部分）函数 ASCII()ASCII 表（可显示字…
阅读更多...
火山引擎 DataTester：5 个优化思路，构建高性能 A/B 实验平台

火山引擎 DataTester：5 个优化思路，构建高性能 A/B 实验平台

导读：DataTester 是由火山引擎推出的 A/B 测试平台，覆盖推荐、广告、搜索、UI、产品功能等业务应用场景，提供从 A/B 实验设计、实验创建、指标计算、统计分析到最终评估上线等贯穿整个 A/B 实验生命周期的服务。DataTester 经过了字节跳动业务…
阅读更多...
vivo 故障定位平台的探索与实践

vivo 故障定位平台的探索与实践

作者：vivo 互联网服务器团队- Liu Xin、Yu Dan 本文基于故障定位项目的实践，围绕根因定位算法的原理进行展开介绍。鉴于算法有一定的复杂度，本文通过图文的方式进行说明，希望即使是不懂技术的同学也能理解。 一、背景介绍 1.1 程…
阅读更多...
2023最新连锁店软件排名，国内十大连锁店管理软件新鲜出炉！

2023最新连锁店软件排名，国内十大连锁店管理软件新鲜出炉！

普通的数据工具、人工管理难以满足连锁店老板们的需求，正所谓“有需求就有市场”，随着连锁店、加盟店如雨后春笋般在城市里出现，连锁店软件也越来越多。究竟哪一款连锁店管理软件，才能满足老板们的需求？小编收集了国内…
阅读更多...
9/365 java 数组 内存

9/365 java 数组 内存

1.数组 声明： int[] a;//首选 int a[];//一般不用 创建： int[] a new int[10]; // 需指定数组大小 初始化： 静态初始化： int[] a {8,9,10}; String[] s {new String("hello"), new String("world")…
阅读更多...
南邮研究生考试历年真题知识点总结

南邮研究生考试历年真题知识点总结

下边的知识点是我在做南京邮电大学考研历年真题时遇到自己不会的题时整理出来的。第九部分是做mooc课后习题时整理出来的，希望对各位同学有所帮助。 md文档网址：https://gitee.com/infiniteStars/wang-dao-408-notes/blob/master/考研笔记/南邮数据结构知…
阅读更多...
内存函数：学习笔记7

内存函数：学习笔记7

目录 一.前言 二. memcpy模拟实现 三. memmove模拟实现 四.memcmp模拟实现 一.前言 计算机内存的实质就是以字节为编号单元的二进制序列集合，操作内存时我们应具有这样的视角。 二. memcpy模拟实现 库函数memcpy函数首部：void *memcpy( void *dest, …
阅读更多...
量子计算机“九章”

量子计算机“九章”

1.中国量子计算机“九章”实现量子霸权 2020年12月，中国科学技术大学宣布该校成功构建光子量子计算原型机“九章”。“九章”是中国科学技术大学潘建伟团队、中科院上海微系统所和国家并行计算机工程技术研究中心合作完成。“九章”的名字是来源于中国历史上最重要…
阅读更多...
算法设计与分析-分支限界法习题

算法设计与分析-分支限界法习题

7-1 布线问题印刷电路板将布线区域划分成 nm 个方格阵列，要求确定连接方格阵列中的方格a 点到方格b 的最短布线方案。在布线时，电路只能沿直线布线，为了避免线路相交，已布了线的方格做了封锁标记，其他线路不允许穿过被…
阅读更多...
大数据开发之利剑 -- TDengine

大数据开发之利剑 -- TDengine

前言 在大数据技术全球爆炸的时代，以及大数据在各行各业的实际应用，大数据的快速发展就像计算机和互联网一样，很可能成为新一轮的技术革命。数据处理、机器学习、AI等新兴技术诞生，会改变数据世界的许多算法和理论基础&#xff0c…
阅读更多...
DAY-1 | Java数据结构之链表：删除无头单链表中等于给定值 val 的所有节点

DAY-1 | Java数据结构之链表：删除无头单链表中等于给定值 val 的所有节点

目录 一、题干 🔗力扣203. 移除链表元素 二、题解 1、思路 2、完整代码 一、题干 🔗力扣203. 移除链表元素 二、题解 1、思路 题干的意思是，要删除链表中所有指定的元素。最暴力的方法是，依次遍历链表中的各个节点&#x…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023