Java 封装

封装是面向对象编程（OOP）中的四个基本概念之一，其他三个分别是继承、多态性和抽象。

Java 中的封装是一种机制，用于将数据（变量）以及作用于这些数据的代码（方法）一起作为一个单元进行包装。在封装中，一个类的变量将对其他类隐藏，并且只能通过其当前类的方法来访问。因此，这也被称为数据隐藏。

在 Java 中实现封装

为了在 Java 中实现封装：

将类的变量声明为 private。
提供公共的 setter 和 getter 方法来修改和查看变量值。

Java 封装示例

以下是一个展示如何在 Java 中实现封装的示例：

// 文件名：EncapTest.java
public class EncapTest {
    private String name;
    private String idNum;
    private int age;

    public int getAge() {
        return age;
    }

    public String getName() {
        return name;
    }

    public String getIdNum() {
        return idNum;
    }

    public void setAge(int newAge) {
        age = newAge;
    }

    public void setName(String newName) {
        name = newName;
    }

    public void setIdNum(String newId) {
        idNum = newId;
    }
}

EncapTest 类的公共 setXXX() 和 getXXX() 方法是其实例变量的访问点。通常，这些方法被称为 getter 和 setter。因此，任何想要访问这些变量的类都应该通过这些 getter 和 setter 来访问它们。

以下是使用 EncapTest 类的实例变量的程序：

// 文件名：RunEncap.java
public class RunEncap {

    public static void main(String[] args) {
        EncapTest encap = new EncapTest();
        encap.setName("James");
        encap.setAge(20);
        encap.setIdNum("12343ms");

        System.out.print("Name : " + encap.getName() + " Age : " + encap.getAge());
    }
}

输出：

Name : James Age : 20

封装的好处

类的字段可以被设置为只读或只写。
类可以完全控制存储在其字段中的内容。

Java 封装：只读类

一个只读类只有 getter 方法来获取属性的值，而不应有任何 setter 方法。

示例：创建只读类

在这个例子中，定义了一个名为 Person 的类，它有两个 getter 方法 getName() 和 getAge()。这些方法可以用来获取类中声明为私有的属性的值。

// 类 "Person"
class Person {
    private String name = "Robert";
    private int age = 21;

    // Getter methods
    public String getName() {
        return this.name;
    }

    public int getAge() {
        return this.age;
    }
}

public class Main {
    public static void main(String[] args) {
        // 对 `Person` 类的对象
        Person per = new Person();

        // 获取并打印值
        System.out.println("Name of the person is: " + per.getName());
        System.out.println("Age of the person is: " + per.getAge());
    }
}

输出：

Name of the person is: Robert
Age of the person is: 21

Java 封装：只写类

一个只写类只有 setter 方法来设置属性的值，而不应有任何 getter 方法。

示例：创建只写类

在这个例子中，定义了一个名为 Person 的类，它有两个 setter 方法 setName() 和 setAge()。这些方法可以用来设置类中声明为私有的属性的值。

// 类 "Person"
class Person {
    private String name;
    private int age;

    // Setter Methods
    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

public class Main {
    public static void main(String[] args) {
        // 对 `Person` 类的对象
        Person per = new Person();

        // 设置值
        per.setName("Robert");
        per.setAge(21);
    }
}

更多封装示例

示例 1：Person 类（完全封装）

这个例子创建了一个名为 "Person" 的完全封装的类。这个类有私有类属性、setter 和 getter 方法。

// 类 "Person"
class Person {
    private String name;
    private int age;

    // Setter Methods
    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    // Getter methods
    public String getName() {
        return this.name;
    }

    public int getAge() {
        return this.age;
    }
}

// 主类用于测试封装的 "Person" 类
public class Main {
    public static void main(String[] args) {
        // 对 `Person` 类的对象
        Person per1 = new Person();
        Person per2 = new Person();

        // 设置值
        per1.setName("Robert");
        per1.setAge(21);

        per2.setName("Riyan");
        per2.setAge(22);

        // 打印值
        System.out.println("Person 1: Name : " + per1.getName() + " Age : " + per1.getAge());
        System.out.println("Person 2: Name : " + per2.getName() + " Age : " + per2.getAge());
    }
}

输出：

Person 1: Name : Robert Age : 21
Person 2: Name : Riyan Age : 22

示例 2：Employee 类（完全封装）

这个例子创建了一个名为 "Employee" 的完全封装的类。这个类有私有类属性、setter 和 getter 方法。

// 类 "Employee"
class Employee {
    private String emp_name;
    private String emp_id;
    private double net_salary;

    // 构造器
    public Employee(String emp_name, String emp_id, double net_salary) {
        this.emp_name = emp_name;
        this.emp_id = emp_id;
        this.net_salary = net_salary;
    }

    // Getter methods
    public String getEmpName() {
        return emp_name;
    }

    public String getEmpId() {
        return emp_id;
    }

    public double getSalary() {
        return net_salary;
    }

    // Setter methods
    public void setEmpName(String emp_name) {
        this.emp_name = emp_name;
    }

    public void setEmpId(String emp_id) {
        this.emp_id = emp_id;
    }

    public void setSalary(double net_salary) {
        this.net_salary = net_salary;
    }
}

// 主类用于测试封装的 "Employee" 类
public class Main {
    public static void main(String[] args) {
        // 对 `Employee` 类的对象
        // 第一个对象 - 使用构造器设置值
        Employee emp = new Employee("Robert", "EMP001", 75450.00);

        // 打印数据
        System.out.println("Employee (Initial Values):");
        System.out.println(emp.getEmpId() + " , " + emp.getEmpName() + " , " + emp.getSalary());

        // 使用 setter 方法更新值
        emp.setEmpName("Riyan");
        emp.setEmpId("EMP002");
        emp.setSalary(90500.00);

        // 打印数据
        System.out.println("Employee (Updated Values):");
        System.out.println(emp.getEmpId() + " , " + emp.getEmpName() + " , " + emp.getSalary());
    }
}

输出：

Employee (Initial Values):
EMP001 , Robert , 75450.0
Employee (Updated Values):
EMP002 , Riyan , 90500.0