Java封装详解：隐藏细节，提升代码质量

陈姥姥

已于 2025-03-26 11:48:44 修改

阅读量1.6k

点赞数 48

文章标签： java 开发语言

于 2025-03-21 02:28:26 首次发布

本文链接：https://blog.csdn.net/iov_a/article/details/146410217

版权

2. default（包级私有）：同包可见

3. protected：同包 + 子类可见

一、封装是什么？从生活到代码的直观理解

封装（Encapsulation） 是面向对象编程的三大核心特性之一（其他两个是继承和多态）。它的核心思想可以用一个生活化的例子来理解：

电脑的使用：当我们操作电脑时，只需要通过电源键、键盘、鼠标和屏幕与它交互，而无需关心CPU内部的电路如何工作、内存如何分配数据。电脑厂商通过“封装”内部复杂的硬件细节，仅对外暴露简单的接口（如USB接口、电源键），让用户能够安全、方便地使用电脑。

在Java中，封装的正式定义是： 将数据（属性）和操作数据的方法（行为）绑定在一个类中，并隐藏对象的内部实现细节，仅通过公开的接口与外界交互。

 Java访问修饰符详解：private、default、protected、public 在Java中，访问修饰符用于控制类、方法、变量的可见性范围，是实现封装的核心工具。通过合理使用这些修饰符，可以精确控制代码的访问权限，提升安全性和可维护性。以下从同类、同包、子类、不同包四个维度，详细分析四种访问修饰符的具体表现。

二、访问修饰符总览

修饰符	同类	同包	子类（不同包）	不同包（非子类）
`private`	✓	✗	✗	✗
`default`	✓	✓	✗	✗
`protected`	✓	✓	✓	✗
`public`	✓	✓	✓	✓

一、具体场景分析

1. `private`：仅同类可见

作用范围：只能在定义该成员的类内部访问。
典型应用：隐藏敏感数据或内部实现细节。

示例：

public class Student {
    private String name;  // 仅本类可访问

    public void setName(String name) {
        this.name = name;  // 合法：同类中访问private成员
    }
}

public class Test {
    public static void main(String[] args) {
        Student stu = new Student();
        // stu.name = "Tom";  // 报错：private成员不可直接访问
        stu.setName("Tom");   // 合法：通过公有方法间接修改
    }
}

2. `default`（包级私有，默认没有权限修饰符）：同包可见

作用范围：同一包内的类可以访问，不同包的类（包括子类）不可访问。
典型应用：用于包内协作，但限制外部包访问。

示例：

// 包 com.bit.demo1
package com.bit.demo1;

public class Computer {
    String brand;  // 默认权限（同包可见）
}

// 同一包内的类
public class TestComputer {
    public static void main(String[] args) {
        Computer computer = new Computer();
        computer.brand = "HP";  // 合法：同包内可访问
    }
}

// 不同包的类（com.bit.demo2）
package com.bit.demo2;
import com.bit.demo1.Computer;

public class Test {
    public static void main(String[] args) {
        Computer computer = new Computer();
        // computer.brand = "Dell";  // 报错：不同包无法访问default成员
    }
}

3. `protected`：同包 + 子类可见

作用范围：同一包内的类，或不同包中的子类可以访问。
典型应用：允许子类继承父类的特定成员，同时限制外部包的非子类访问。

示例：

// 包 com.bit.demo1
package com.bit.demo1;

public class Animal {
    protected String species;  // 允许子类访问
}

// 同一包内的类
public class Zoo {
    public void showSpecies(Animal animal) {
        System.out.println(animal.species);  // 合法：同包内可访问
    }
}

// 不同包中的子类（com.bit.demo2）
package com.bit.demo2;
import com.bit.demo1.Animal;

public class Dog extends Animal {
    public void printSpecies() {
        species = "Canine";  // 合法：子类中可访问protected成员
        System.out.println(species);
    }
}

// 不同包中的非子类（com.bit.demo2）
public class Test {
    public static void main(String[] args) {
        Animal animal = new Animal();
        // animal.species = "Unknown";  // 报错：非子类不可访问
    }
}

4. `public`：全局可见

作用范围：所有类均可访问，无任何限制。
典型应用：公开API接口或工具类方法。

示例：

// 包 com.bit.utils
package com.bit.utils;

public class MathUtils {
    public static final double PI = 3.14159;  // 全局可访问
}

// 不同包的类（com.bit.demo2）
package com.bit.demo2;
import com.bit.utils.MathUtils;

public class Test {
    public static void main(String[] args) {
        System.out.println(MathUtils.PI);  // 合法：public成员全局可见
    }
}

二、常见问题与解决方案

1. 包冲突问题

场景：导入不同包的同名类（如java.util.Date和java.sql.Date）。

解决方案：使用全限定类名。

import java.util.*;
import java.sql.*;

public class Test {
    public static void main(String[] args) {
        java.util.Date date = new java.util.Date();  // 明确指定包名
    }
}

2. 子类继承问题

允许子类直接访问继承的 protected 成员（通过子类自身实例或直接使用成员名）。
禁止通过父类实例跨包访问 protected 成员，即使当前类是父类的子类。

问题2具体场景分析

1. 父类与子类在不同包中

父类：com.bit.demo1.Parent

package com.bit.demo1;
public class Parent {
    protected String familyName = "Smith";
}

子类：com.bit.demo2.Child

package com.bit.demo2;
import com.bit.demo1.Parent;

public class Child extends Parent {
    public void showName() {
        System.out.println(familyName);  // 合法：直接访问继承的成员  
        Parent parent = new Parent();
        // System.out.println(parent.familyName);  // ❌ 编译报错：即使 Child 是子类，也无法通过父类实例访问
    }
}

说明：
子类Child通过继承拥有familyName，可以直接使用成员名访问。

说明：
虽然Child是Parent的子类，但通过父类实例（parent）访问protected成员是非法的。只有通过继承（直接使用成员名）或子类自身实例才能访问。

2. 不同包中的其他类（非子类）

测试类：com.bit.demo2.Test

package com.bit.demo2;
import com.bit.demo1.Parent;

public class Test {
    public static void main(String[] args) {
        Parent parent = new Parent();
        // System.out.println(parent.familyName);  // 编译报错：非子类无法访问父类的protected成员，哪怕是子类也不能通过父类实例来访问
        System.out.println(familyName); //编译报错：非子类无法访问父类的protected成员
    }
}

说明：非子类（无论是否同包）完全无法访问父类的 protected 成员。

三、总结

private：最严格的封装，仅同类可见。
default：包内协作的默认选择，限制外部包访问。
protected：兼顾继承需求，允许子类跨包访问。
public：完全开放，适用于全局接口或常量。

通过合理使用访问修饰符，可以构建高内聚、低耦合的代码结构，提升程序的健壮性和可维护性。