9.1【Java面向对象进阶】封装、包管理与static关键字：构建健壮程序的三大支柱

1. 包(Package)：Java项目的组织艺术

1.1 包的核心概念与价值

包是Java中组织类的容器机制，类似于文件系统中的文件夹结构。它解决了大型项目中类名冲突的问题，同时提高了代码的可读性和可维护性。

包的主要作用：

• 避免命名冲突：不同包中可以有相同类名的类

• 提高可读性：按功能模块组织代码结构

• 访问控制：配合访问修饰符实现权限管理

• 便于维护：模块化组织便于团队协作

1.2 包的导入与使用实战

方式一：全限定名使用（不推荐）

public class Test {
public static void main(String[] args) {
java.util.Date date = new java.util.Date();
System.out.println(date.getTime());
}
}

方式二：import语句导入（推荐）

import java.util.Date;

public class Test {
public static void main(String[] args) {
Date date = new Date(); // 直接使用类名
System.out.println(date.getTime());
}
}

方式三：导入整个包（谨慎使用）

import java.util.*; // 导入util包下所有类

public class Test {
public static void main(String[] args) {
Date date = new Date();
ArrayList<String> list = new ArrayList<>();
}
}

1.3 自定义包与IDEA实战

包命名规范：

• 使用公司域名的倒写形式：com.公司名.项目名.模块名

• 全部小写，使用点号分隔

• 要有明确的层次结构

在IDEA中创建包的步骤：

实际代码示例：

package com.bit.demo1;

public class Computer {
String brand; // 默认包访问权限

public void start() {
System.out.println(brand + "电脑开机");
}
}

1.4 常见系统包详解

包名

主要功能

重要类

2. 封装(Encapsulation)：面向对象的安全卫士

2.1 封装的核心思想

封装是面向对象三大特性之首，它像是一个"保护壳"，将数据和行为包装在一起，并控制外部的访问权限。

现实世界类比：

• 电脑：用户只需操作开关、键盘，不需要了解内部电路

• 汽车：驾驶员只需操作方向盘、油门，不需要懂发动机原理

• ATM机：用户只需插卡输入密码，不需要知道资金流转细节

2.2 封装的代码实现

未封装的Person类（存在问题）：

public class Person {
public String name;
public int age;

// 数据可以被任意修改，缺乏安全性
}

封装后的Person类（推荐）：

public class Person {
private String name;
private int age;

// 公开的接口方法
public String getName() {
return name;
}

public void setName(String name) {
if (name != null && !name.trim().isEmpty()) {
this.name = name;
}
}

public int getAge() {
return age;
}

public void setAge(int age) {
if (age >= 0 && age <= 150) { // 数据验证
this.age = age;
}
}
}

2.3 访问限定符深度解析

Java提供四种访问权限控制：

访问修饰符

同一类

同一包

不同包子类

不同包非子类

也就是：

public：哪里都能用

private：只在同一个类中能使用

default：也称为“包访问权限修饰符”，也就是不写，能在同一个包中使用

实际应用示例：

package com.bit.demo1;

public class BankAccount {
private double balance; // 完全私有，最安全
String accountNumber; // 包内可访问
protected String owner; // 子类可访问
public final String BANK_NAME = "BIT Bank"; // 完全公开
}

2.4 封装的三大优势

3. static关键字：类的共享资源管理器

3.1 static修饰成员变量

问题场景：多个学生共享同一个教室

public class Student {
private String name;
private int age;
public String classRoom = "1-101"; // 每个对象都存储一份，浪费！
}

解决方案：使用static

public class Student {
private String name;
private int age;
public static String classRoom = "1-101"; // 所有对象共享一份
}

静态变量的正确访问方式：

public class Test {
public static void main(String[] args) {
// 推荐：通过类名访问
System.out.println(Student.classRoom);

// 不推荐：通过对象访问（会产生误导）
Student stu = new Student();
System.out.println(stu.classRoom);
}
}

3.2 static修饰成员方法

静态方法的特点：

• 属于类，不属于具体对象

• 不能直接访问非静态成员

• 不能使用this关键字

实用示例：工具类

public class MathUtils {
// 静态常量
public static final double PI = 3.14159;

// 静态方法：计算圆面积
public static double calculateCircleArea(double radius) {
return PI * radius * radius;
}

// 静态方法：最大值比较
public static int max(int a, int b) {
return a > b ? a : b;
}
}

// 使用示例
double area = MathUtils.calculateCircleArea(5.0);
int maxValue = MathUtils.max(10, 20);

3.3 静态成员的生命周期

特性

实例变量

静态变量

4. 代码块：精细化的初始化控制

4.1 代码块的四种类型

4.1.1 普通代码块

public void someMethod() {
// 普通代码块：限制变量作用域
{
int x = 10;
System.out.println("x = " + x);
}
// System.out.println(x); // 编译错误：x超出作用域
}

4.1.2 构造代码块（实例代码块）

public class Student {
private String name;
private int age;

// 构造代码块：每次创建对象时执行
{
this.name = "默认姓名";
this.age = 18;
System.out.println("执行构造代码块");
}

public Student() {
System.out.println("执行无参构造方法");
}
}

4.1.3 静态代码块

public class DatabaseUtil {
private static String driver;
private static String url;

// 静态代码块：类加载时执行一次
static {
driver = "com.mysql.cj.jdbc.Driver";
url = "jdbc:mysql://localhost:3306/test";
System.out.println("静态代码块执行：数据库配置加载完成");
}
}

4.2 代码块执行顺序实战

public class ExecutionOrder {
// 静态变量
private static String staticField = "静态变量";

// 实例变量
private String instanceField = "实例变量";

// 静态代码块
static {
System.out.println("1. 静态代码块: " + staticField);
}

// 构造代码块
{
System.out.println("3. 构造代码块: " + instanceField);
}

// 构造方法
public ExecutionOrder() {
System.out.println("4. 构造方法执行");
}

public static void main(String[] args) {
System.out.println("2. main方法开始");
new ExecutionOrder();
}
}

执行结果：

1. 静态代码块: 静态变量 2. main方法开始 3. 构造代码块: 实例变量 4. 构造方法执行