Java中的块作用域block_block: () -> unit在java如何定义-CSDN博客

本文链接：https://blog.csdn.net/qiaoge66/article/details/115337500

本文详细介绍了Java中的块作用域，包括构造块、静态块和局部代码块的执行时机及应用场景。同时，文章还探讨了Java的包机制、封装原理及其优点，以及Java继承中的super关键字和this关键字的区别。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

block 块

{} ->块自成作用域

{}:方法中|语句块中->局部代码块|普通语句块执行时机 : 跟随方法的调用
{}:类中方法外部->构造块执行时机 : 创建对象new的时候
static{}:类中方法外->静态块执行时机 : 类第一次加载完成之后初始化执行

注意:

构造块代码先于构造器代码之前执行
当存在多个构造块,从上到下一次执行
多个静态块,从上到下一次执行
静态块在类第一次加载完成之后执行,并且只执行一次

应用场景:

静态块: 内容的初始化,根据静态块的特点,类加载后只执行一次
为静态变量内容初始化
构造块:
成员变量内容做初始化
局部代码块:
可以把具有相同作用的代码放在一个{}中,具有语义化的特点,也代表一个作用域

顺序: 静态块–main–构造块–构造器

public class BlockDemo01 {
    //类中方法外
    static int i ;
    int x = 15;

    //构造器
    public BlockDemo01(){
        System.out.println("空构造");
    }

    //构造块
    {
        System.out.println("我是构造块1哈哈哈哈");
    }
    {
        System.out.println("我是构造块2哈哈哈哈");
        //System.out.println(this.x);
    }
    {
        System.out.println("我是构造块3哈哈哈哈");
    }

    //静态块
    static{
        i = 10;
        System.out.println("静态块1");
    }
    static{
        System.out.println("静态块2");
        //System.out.println(new BlockDemo01().x);
    }


    public static void main(String[] args) {
        System.out.println("main");
        //局部
        int i =1;

        // 局部代码块|普通语句块W
        {
            i =5;
            System.out.println(i);
        }
        System.out.println(i);
        System.out.println(BlockDemo01.i);

        new BlockDemo01();
        new BlockDemo01();
    }

}

在这里插入图片描述

Java中的包机制

包机制

从最简单的实例说起，下面是使用eclipse新建的一个工程，在工程中新建了一个包，在包中新建了一个类，在类中写了一行代码，一运行，看到打印出了hello world。这是一个再简单不过的例子了，你也能很容易的实现你想要的效果，然而你真的理解这份程序是怎样运行的吗？以及Java的文件目录结构是怎样的？这就是IDE带来的弊端。

package com.xxxx.package03;

import java.util.*;

//导入静态内容
import static java.lang.Math.PI;
//导入静态方法不要添加(),因为方法名()这叫方法的调用,执行方法中的代码
import static java.lang.Math.random;
/*
    包机制:
        为管理众多java文件

    位置:
        出现 在当前java文件的第一行
        package,import,class: 1)package 2)import 3)class

     导包:
        指明使用java类位置

     不需要导包的类:
        1.同包下的类
        2.java.lang包下的内容不需要导包

     导包的方式:
        1.使用类型的时候指定类型的权限定名  包名.类名
            只在当前这一次有效
        2.import 包名.类名; 导包
            定义在类的上面
            导入一次,当前类中都可以使用
        3.模糊匹配   *
            降低编译效率
        4.静态导入
            import static 包名.类名.静态内容;

     包命名:
        公司域名倒着写+工能名字|模块名字
        全部小写,层级之间使用.进行连接

     注意:
        不要与jdk定义相同名字 的包名与类名

 */
public class ImportDemo01 {
    public static void main(String[] args) {
        //包名.类名: 权限定名
        java.util.Scanner sc = new java.util.Scanner(System.in);

        Scanner sc2 = new Scanner(System.in);

        List ls = new ArrayList();

        //静态变量
        System.out.println(PI);
        System.out.println(PI);
        System.out.println(PI);
        System.out.println(PI);
        System.out.println(PI);

        //静态方法
        System.out.println(random());
        System.out.println(random());
        System.out.println(random());
        System.out.println(random());
        System.out.println(random());
    }
}

java封装

在面向对象程式设计方法中，封装（英语：Encapsulation）是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。
封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。
要访问该类的代码和数据，必须通过严格的接口控制。
封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。
适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性。

封装的优点

良好的封装能够减少耦合。
类内部的结构可以自由修改。
可以对成员变量进行更精确的控制。
隐藏信息，实现细节。

java 的封装

封装（Encapsulation）是面向对象方法的重要原则，就是把对象的属性和操作（或服务）结合为一个独立的整体，并尽可能隐藏对象的内部实现细节。

java继承

继承概念

继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为

package com.xxxx.extend05;
/*
    继承:  子承父业

    目的:
        为了提高代码的复用性

    子类|派生类: 继承父类的类
    父类|基类|超类: 被继承的类

    类: 抽取对象的共性
    父类: 抽取子类的共性定义在父类中

    继承的实现:
        子类 extends 父类

    特点:
        子类一旦继承父类,就有权使用父类中的成员
        子类中定义子类独有的内容
        extends 孩子是夫妇的延续,也是扩展
        一个父类可以存在多个子类
        单继承机制,一个子类只能存在一个父类
        接口可以多实现(了解)

    单继承的优点:
        简单
    单继承的缺点:
        不够灵活,不便于 程序的后期维护

    面向对象设计原则之一:
        开闭原则
            对修改关闭
            对扩展开放

    定义: 一个猫猫类   一个狗狗类
        根据子类的共性,定义父类
        通过子父类之间继承关系实现
        测试使用
 */
public class ExtendsDemo01 {
    public static void main(String[] args) {
        Teacher t = new Teacher();
        t.name = "马云";
        t.age = 60;
        t.subject = "英语";
        t.teach();
        t.sleep();

    }
}

//人  -->父类
class Person{
    public String name;
    public int age;

    public void sleep(){
        System.out.println("休息");
    }
}

//教师类 ->子类
class Teacher extends Person{
    public String subject; //学科
    public Teacher(){}

    //教学
    public void teach(){
        System.out.println("教书育人!!!");
    }

}

//学生类 ->子类
class Student extends Person{
    public int grade; //成绩等级


    public Student(){}

    //学习
    public void study(){
        System.out.println("学习");
    }

}

super关键字和 this 之间的区别:

this 指代对象,当前对象new
构造器的首行调用本类中的其他构造器
区分局部与成员同名问题

super 指代父类对象(子类内存中的父类对象)
在子类的构造器首行,调用父类构造器
super(实参)
如果没有显示调用父类的指定构造器,默认在子类构造器的首行调用父类的空构造 super()
this()与super()在构造器的首行调用其他构造器时候不能同时存在
区分子父类中同名成员的问题
默认就近原则
指代父类的成员,需要通过父类对象调用父类成员 super.
如果不存在同名问题,当成员变量|方法,如果找到父类成员,默认省略super. ,如果找到子类成员,默认省略this.

在存在子父类继承的前提下:
创建子类对象: 先父类后子类
先创建父类对象,再创建子类对象

this与super都不能使用在静态环境中!!!

package com.xxxx.super06;
/*
    super关键字 和 this 之间的区别:
        this 指代对象,当前对象new
            构造器的首行调用本类中的其他构造器
            区分局部与成员同名问题

        super 指代父类对象(子类内存中的父类对象)
            在子类的构造器首行,调用父类构造器
                super(实参)
                如果没有显示调用父类的指定构造器,默认在子类构造器的首行调用父类的空构造  super()
                this()与super()在构造器的首行调用其他构造器时候不能同时存在
            区分子父类中同名成员的问题
                默认就近原则
                指代父类的成员,需要通过父类对象调用父类成员  super.
                如果不存在同名问题,当成员变量|方法,如果找到父类成员,默认省略super. ,如果找到子类成员,默认省略this.

    在存在子父类继承的前提下:
        创建子类对象: 先父类后子类
            先创建父类对象,再创建子类对象

    this与super都不能使用在静态环境中!!!!
 */
public class SuperDemo01 {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.test();
    }

}


class Fu{
    public String name = "小头爸爸";
    public int age = 18;

    /*public Fu(){
        System.out.println("我是父类空构造");
    }*/

    public Fu(int a){
        System.out.println("我是父类带参构造"+a);
    }
}

class Zi extends Fu{
    public String name = "大头儿子";

    //this调用当前类中的其他构造器
    public Zi(){
        this(1);
        System.out.println("我是子类空构造");
    }

    //子类构造器的首行super()调用父类中指定构造器
    public Zi(int i){
        super(10);
        System.out.println("带参构造器"+i);
    }

    public void test(){
        String name = "hahaha";
        System.out.println(name);  //就近原则
        System.out.println(this.name);  //大头儿子  当前类中的成员
        System.out.println(super.name);  //小头爸爸  通过父类对象调用父类成员

        System.out.println(age);  //相当于省略了super.
    }
}