目录
1. 封装
1.1 封装的概念
在 Java 中，面向对象程序三大特征：封装，继承，多态。而封装是面向对象编程（OOP）的核心概念之一，它的核心思想是将数据（属性）和操作数据的方法（行为）捆绑在一起，并隐藏对象的内部实现细节，仅对外公开可控的访问接口来和对象进行交互。简单来说就是套壳屏蔽细节啦~
并且封装通过限制对对象内部状态的直接访问，提高了代码的安全性、可维护性和灵活性。
1.2 访问限定符
Java 中的访问限定符用于控制类、成员变量、方法和构造方法的可见性，是实现封装的重要机制。共有四种访问修饰符：public、protected、默认、private。在这里博主先介绍public修饰符，再介绍private修饰符，剩下两个修饰符不做过多描述~
public（公开访问）
作用范围：所有类均可访问。
使用的场景：
对外暴露的接口或工具类（如
public class Main）。常量（如
public static final）。
public class Animal {
public String name; // 任何类都可以访问
}private（私有访问）
封装性：优先使用 private，通过公共方法控制访问。
作用范围：仅限于声明它的类内部。
使用场景：
封装类的内部状态（如私有字段）。
单例模式的私有构造方法。
public class Student {
private String id; // 仅本类可以访问
public String getId() { // 通过公共方法暴露出来
return id;
}
}1.3 包
1.3.1 包的概念
在 Java 中，包是一种用于组织类和接口的命名空间机制。它类似于文件系统中的文件夹，里面存有很多文件，主要目的是避免命名冲突、控制访问权限。
为了更好的管理，把多个类收集在一起成为一组，称为软件包。
包有一个很重要的作用：不同包中可以存在相同名称的类，避免类名的冲突。
1.3.2 导入包中的类
下面这一段代码是输出数组的内容，我们通过这段代码来进行导入包中的类的讲解：
// 导入Arrays类（位于java.util包中）
import java.util.Arrays;
public class Test3 { // 类名建议首字母大写
public static void main(String[] args) {
// 创建并初始化一个int数组
int[] array = {1, 2, 3};
// 使用Arrays类的静态方法toString()转换数组为字符串
// 注意：Arrays是类名，Array是Java中的数组关键字，不要混淆
System.out.println(Arrays.toString(array));// 输出 [1, 2, 3]
}
}- 导入包
使用 Arrays 类前需导入包：可以使用import语句导入包：
import java.util.Arrays; // 必须添加在代码开头Arrays.toString(array)
Arrays是 Java 提供的工具类（位于java.util包），用于操作数组。toString()是它的静态方法，功能是将数组元素转换为可读的字符串格式。
System.out.println(Arrays.toString(array)) 这行Java代码的作用是将数组 array 的内容转换为字符串并输出到控制台。
如果直接打印数组对象 System.out.println(array)，输出的是数组的哈希值（如 [I@1b6d3586），这时候没办法看到实际内容。
使用 Arrays.toString() 后，输出的是直观的数组元素[1, 2, 3]。
我们也可以使用import static导入包中的静态的方法和字段，后续代码中可以直接使用静态成员，无需通过类名调用。
// 使用静态导入：导入Arrays类中的toString方法
// 使得可以直接调用toString()而无需写类名Arrays
import static java.util.Arrays.toString;
public class test3 {
public static void main(String[] args) {
// 定义一个int数组
int[] array = {1, 2, 3};
// 直接调用静态导入的toString方法，等价于Arrays.toString(array)
System.out.println(toString(array));//输出[1, 2, 3]
}
}1.3.3 自定义包
选中src，右键点击 src 目录，点击New（新建），再点击Package（软件包），创名字（名字全小写），最后就创建好了包。
2. static成员
在之前的博客中我们举了学生类来进行相关知识点讲解，现在同样我们再用学生类举例：
上述三者都是成员变量。成员变量定义在方法的外部，类的内部。其中schoolName用static修饰之后，就不存在于对象当中了，而存在于方法区当中。
所有学生共享学校名称：每个学生对象都有自己的 name 和 age，但 schoolName 是所有学生共享的。修改一次，所有对象看到的都会变化。
直接通过类名访问：例如 Student.schoolName
2.1 static变量（类变量）
2.1.1 static修饰成员变量
用
static修饰的成员属于类本身（schoolName被static修饰）所有对象共享同一个static变量
示例中的
schoolName被所有Student对象共享静态成员变量访问方式：
类名.变量名（而非静态成员变量属于对象，访问方式是：引用.变量名）静态成员变量不依赖于对象，不用实例化都可以
2.2 static方法（类方法）
2.2.1 static修饰成员方法
- ②静态成员方法中，使用时也是不依赖于对象的
②静态成员方法无需实例化：可通过
类名.方法名()直接调用
changeSchool()通过类名调用（如Student.changeSchool("希望中学")），修改所有学生共享的schoolName- 在②静态成员方法里面，不能 直接 调用①非静态成员方法或成员变量，在
changeSchool()中尝试访问name或age会报错，因为static 方法中没有this引用
若是一定要在静态成员方法里调用的话，一定要通过对象的引用来调用！即：
完整代码如下：
public class Student {
// 实例变量 - 每个学生对象独有的属性
String name; // 学生姓名
int age; // 学生年龄
// static成员 - 属于类本身的属性（所有对象共享）
static String schoolName = "阳光中学"; // 学校名称（所有学生相同）
// 构造方法
public Student(String name, int age) {
this.name = name;
this.age = age;
}
// 实例方法 - 需要创建对象后才能调用
void showInfo() {
System.out.println(name + "，" + age + "岁，就读于" + schoolName);
}
// static方法 - 通过类名直接调用
static void changeSchool(String newName) {
schoolName = newName; // 修改所有学生共享的学校名称
}
}
// 测试类
public class Main {
public static void main(String[] args) {
// 访问static变量（不需要创建对象）
System.out.println("当前学校：" + Student.schoolName);
// 创建两个学生对象
Student s1 = new Student("张三", 15);
Student s2 = new Student("李四", 16);
// 调用实例方法
s1.showInfo(); // 张三，15岁，就读于阳光中学
s2.showInfo(); // 李四，16岁，就读于阳光中学
// 通过类名调用static方法修改学校名称
Student.changeSchool("希望中学");
System.out.println("\n修改后的学校信息：");
s1.showInfo(); // 张三，15岁，就读于希望中学
s2.showInfo(); // 李四，16岁，就读于希望中学
// 再次直接访问static变量
System.out.println("当前学校：" + Student.schoolName);
}
}2.3 static成员变量初始化
静态成员变量一般不会放在构造方法中初始化，构造方法里面初始化的是与对象相关的实例属性。
初始化方式分为两种：就地初始化和静态代码块初始化
就地初始化在定义时直接给出初始值：
static String schoolName = "阳光中学"; // 最常用的初始化方式静态初始化我们在后面进行介绍
3. 代码块
3.1 代码块概念以及分类
如图，使用{ }定义的一段代码称为代码块。 可以分为四类：
- 普通代码块 构造块 静态块 同步代码块
3.1.1 普通代码块（少用）
- 在方法内部用
{ }包裹的代码块
void showInfo() {
{ // 普通代码块开始
int temp = 10;
System.out.println("变量是：" + temp);
} // temp变量在这里被销毁
// System.out.println(temp); // 这里会报错，temp已经不可用啦
}3.1.2 构造代码块（实例代码块）
- 类中直接使用
{ }包裹的代码块（不加修饰符）。也叫做实例代码块，构造代码块一般用于初始化实例成员变量，这个代码块在方法的外面，类的里面。 - 每次创建对象时自动执行，且在构造方法之前
public class Student {
// 实例变量
String name;
int age;
// ---------- 构造代码块 ----------
{
// 这个代码块会在每次创建对象的时候执行
System.out.println("执行构造代码块");
age = 10; // 为所有学生设置默认年龄10
}
// -----------------------------
// 构造方法
public Student(String name, int age) {
System.out.println("执行构造方法");
this.name = name;
this.age = age; // 会覆盖构造代码块中的默认值
}
}3.1.3 静态代码块
- 使用
static { }包裹的代码块称为静态代码块。一般用于初始化静态成员变量。 - 类首次加载时执行，且仅仅执行一次
public class Student {
static String schoolName;
// 静态代码块
static {
System.out.println("静态代码块啦~");
schoolName = "希望中学";
}
}静态代码块只会执行一次，只要类被加载，就会被执行，而实例代码块一定是实例化对象的时候被执行。
若是三者都存在时，执行顺序：①静态代码块 ②实例代码块 ③不带参数的构造方法。
希望能帮到友友们的学习~
制作不易，更多内容加载中~感谢友友们的点赞收藏关注~~
如有问题欢迎批评指正，祝友友们生活愉快，学习工作顺顺利利！
