包与访问修饰符

包组织类结构，访问修饰符控制访问权限。

包的概念

什么是包

包是类的命名空间，用于组织和管理类。

// 包声明（文件首行）
package com.example.service;

public class UserService {
    // ...
}

包的作用

• 组织类结构（分类管理）
• 避免类名冲突
• 提供访问保护
• 便于查找使用

包的定义

定义包

在源文件首行声明包名。

// 文件：UserService.java
package com.example.service;

public class UserService {
    // 类的全限定名：com.example.service.UserService
}

包命名规范

• 使用小写字母
• 使用公司域名反写开头
• 按功能模块分层

// 标准包命名
com.company.project.module

// 示例
com.example.user        // 用户模块
com.example.order       // 订单模块
com.example.util        // 工具类
com.example.controller  // 控制器
com.example.service     // 服务层
com.example.dao         // 数据访问层

目录结构对应

包名与目录结构一一对应。

项目目录
└── src
    └── com
        └── example
            └── service
                └── UserService.java  // package com.example.service

包的导入

import导入类

使用其他包的类需要导入。

package com.example.test;

// 导入单个类
import com.example.service.UserService;
import java.util.List;

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

public class Test {
    UserService service = new UserService();  // 使用导入的类
    List<String> list = new ArrayList<>();
}

同名类处理

import java.util.Date;
// import java.sql.Date;  // 冲突，不能同时导入

// 使用全限定名解决冲突
java.util.Date date1 = new java.util.Date();
java.sql.Date date2 = new java.sql.Date(System.currentTimeMillis());

静态导入

import static java.lang.Math.PI;
import static java.lang.Math.*;

public class Test {
    double value = PI;      // 直接使用
    double result = sqrt(9); // 直接使用
}

自动导入

以下包自动导入，无需import：

• java.lang包（String、System、Math等）
• 当前包下的类

Java常用包

访问修饰符

四种访问修饰符

private私有

只能在本类内访问。

public class Person {
    private String name;     // 私有属性
    private int age;
    
    private void secret() {  // 私有方法
        System.out.println("私有方法");
    }
    
    // 本类内部可访问
    public void show() {
        System.out.println(name);  // 正确
        secret();                   // 正确
    }
}

// 外部无法访问
Person p = new Person();
// p.name = "张三";    // 错误
// p.secret();         // 错误

默认（包私有）

无修饰符，同包内可访问。

// com.example包
package com.example;

public class Person {
    String name;  // 默认修饰符
    
    void method() { }  // 默认方法
}

// 同包类可访问
package com.example;

public class Test {
    Person p = new Person();
    p.name = "张三";  // 正确：同包
    p.method();       // 正确
}

// 不同包无法访问
package com.other;

public class Other {
    Person p = new Person();
    // p.name = "李四";  // 错误：不同包
}

protected受保护

同包和子类可访问。

package com.example;

public class Animal {
    protected String name;  // 受保护属性
}

// 同包可访问
package com.example;

public class Test {
    Animal a = new Animal();
    a.name = "旺财";  // 正确：同包
}

// 子类可访问（不同包）
package com.pet;

import com.example.Animal;

public class Dog extends Animal {
    public void setName() {
        this.name = "旺财";  // 正确：子类访问
    }
}

// 非子类不同包不可访问
package com.pet;

public class Cat {
    Animal a = new Animal();
    // a.name = "喵";  // 错误：不是子类
}

public公共

任意位置可访问。

package com.example;

public class Person {
    public String name;     // 公共属性
    public int age;
    
    public void speak() {   // 公共方法
        System.out.println(name);
    }
}

// 任意位置可访问
package com.other;

import com.example.Person;

public class Other {
    Person p = new Person();
    p.name = "张三";  // 正确
    p.speak();        // 正确
}

访问修饰符选择

选择原则

• 属性：通常用private（封装）
• 方法：按需选择public/protected/默认
• 类：通常public（对外使用）
• 工具方法：public静态

public class Student {
    // 属性私有（封装）
    private String name;
    private int age;
    
    // 公共getter/setter
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    
    // 公共业务方法
    public void study() { }
    
    // 私有内部方法
    private void validate() { }
    
    // protected供子类使用
    protected void beforeStudy() { }
}

封装原则

• 最小暴露原则：只暴露必要接口
• 属性私有化，提供public方法访问
• 内部实现用private/默认

类的访问修饰符

类修饰符

类只能使用public或默认修饰符。

// public类：任意位置可访问
public class PublicClass { }

// 默认类：同包可访问
class DefaultClass { }

// 错误：类不能用private/protected
private class ErrorClass { }     // 编译错误
protected class ErrorClass { }   // 编译错误

内部类修饰符

内部类可用所有修饰符。

public class Outer {
    private class PrivateInner { }   // 私有内部类
    protected class ProtectedInner { }
    public class PublicInner { }
    class DefaultInner { }
}

访问修饰符对比表

可访问范围对比

访问范围从小到大：

private → 默认 → protected → public

private:    仅本类
默认:       本类 + 同包
protected:  本类 + 同包 + 子类
public:     任意位置

使用场景

要点总结

• 包用于组织类，避免命名冲突
• 包声明在文件首行：package 包名
• 包名小写，域名反写开头
• import导入其他包的类
• java.lang包自动导入
• 包名与目录结构对应
• private仅本类可访问
• 默认同包可访问
• protected同包+子类可访问
• public任意位置可访问
• 属性通常private，方法按需选择
• 类只能用public或默认修饰