封装

封装是面向对象编程的核心特性之一。

封装概念

什么是封装

封装是将对象的属性隐藏起来，通过公共方法控制访问。

// 未封装：属性公开，不安全
public class Person {
    public String name;
    public int age;  // 可随意修改，可能设置负数
}

// 已封装：属性私有，通过方法控制
public class Person {
    private String name;
    private int age;
    
    public void setAge(int age) {
        if (age > 0) {  // 数据校验
            this.age = age;
        }
    }
}

封装的作用

• 隐藏实现细节
• 保护数据安全
• 提供可控访问方式
• 提高代码可维护性

访问修饰符

四种访问修饰符

private私有

public class Student {
    private String name;     // 只能在本类访问
    private int age;
    private double score;
    
    // 本类内部可以访问
    public void show() {
        System.out.println(name);  // 可以访问
    }
}

// 外部不能直接访问
Student s = new Student();
s.name = "张三";  // 编译错误：私有属性

public公共

public class Student {
    public String name;  // 任何地方可访问
    
    public void study() {  // 公共方法
        System.out.println("学习");
    }
}

Student s = new Student();
s.name = "张三";  // 可以访问
s.study();       // 可以调用

封装实现步骤

标准封装模式

1. 属性使用private修饰
2. 提供公共getter方法获取属性
3. 提供公共setter方法设置属性
4. 在setter中添加数据校验

public class Student {
    // 1. 属性私有化
    private String name;
    private int age;
    private double score;
    
    // 2. getter方法（获取）
    public String getName() {
        return name;
    }
    
    public int getAge() {
        return age;
    }
    
    public double getScore() {
        return score;
    }
    
    // 3. setter方法（设置）+ 数据校验
    public void setName(String name) {
        this.name = name;
    }
    
    public void setAge(int age) {
        if (age > 0 && age < 150) {  // 数据校验
            this.age = age;
        } else {
            System.out.println("年龄不合法");
        }
    }
    
    public void setScore(double score) {
        if (score >= 0 && score <= 100) {
            this.score = score;
        } else {
            System.out.println("分数不合法");
        }
    }
}

使用封装类

通过方法访问

Student student = new Student();

// 设置属性（通过setter）
student.setName("张三");
student.setAge(20);
student.setScore(85.5);

// 获取属性（通过getter）
String name = student.getName();
int age = student.getAge();
double score = student.getScore();

// 校验生效
student.setAge(-10);   // 输出：年龄不合法
student.setScore(150); // 输出：分数不合法

setter/getter命名规范

• getter：get + 属性名（首字母大写）
• setter：set + 属性名（首字母大写）
• boolean类型getter可用is前缀

public class User {
    private boolean active;
    
    // boolean getter可以用is
    public boolean isActive() {
        return active;
    }
    
    public void setActive(boolean active) {
        this.active = active;
    }
}

封装优势

数据安全

public class Account {
    private double balance;
    
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }
    
    public void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
        }
    }
    
    public double getBalance() {
        return balance;
    }
}

// 余额不能直接修改，只能通过存款/取款操作

隐藏实现细节

public class Calculator {
    private int result;  // 内部状态不公开
    
    public void add(int a, int b) {
        result = a + b;  // 内部实现隐藏
    }
    
    public int getResult() {
        return result;
    }
}

// 用户只需调用add()，不需关心内部实现

便于修改维护

public class Person {
    private String name;
    
    // 修改实现，不影响调用方
    public String getName() {
        return name == null ? "" : name;  // 增加空值处理
    }
}

// 调用方代码无需修改
Person p = new Person();
String name = p.getName();  // 自动获得空值处理

封装原则

封装设计原则

• 属性尽可能private
• 方法按需选择修饰符
• 只暴露必要的接口
• 内部实现细节隐藏

public class Order {
    // 私有属性
    private String orderId;
    private double amount;
    private OrderStatus status;
    
    // 公共方法（必要接口）
    public void pay() { ... }
    public void cancel() { ... }
    public String getOrderId() { ... }
    
    // 私有方法（内部逻辑）
    private void updateStatus() { ... }
    private void notifyUser() { ... }
}

IDE快速生成

使用IDE生成getter/setter

大多数IDE（如IntelliJ IDEA、Eclipse）可自动生成：

// IDEA: Alt + Insert → Getter and Setter
// Eclipse: Source → Generate Getters and Setters

public class Product {
    private int id;
    private String name;
    private double price;
    
    // 自动生成getter/setter
    public int getId() { return id; }
    public void setId(int id) { this.id = id; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public double getPrice() { return price; }
    public void setPrice(double price) { this.price = price; }
}

要点总结

• 封装是隐藏属性、暴露方法的编程思想
• private修饰符实现属性私有化
• getter方法获取属性值
• setter方法设置属性值（可加校验）
• setter/getter命名：set/get + 属性名大写
• boolean getter可用is前缀
• 封装保护数据安全、隐藏实现细节
• 便于修改内部实现、不影响调用方
• 属性尽可能private，方法按需选择
• IDE可自动生成getter/setter方法