Java 封装

封装 是面向对象概念四个基本特征之一 。另外三个是继承、多态和抽象。

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

在Java中实现封装

在Java中实现封装 

  • 将类的变量声明为私有。

  • 提供公共的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;
   }
} 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29

public setXXX() 和 getXXX() 方法是 实例变量的访问点EncapTest 类。通常，这些方法称为 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());
   }
}

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;
   }
} 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41

输出

Name : James Age : 20

    封装的好处

    • 可以制作类的字段只读或只写。

    • 类可以完全控制其字段中存储的内容。

    Java封装:只读类

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

    示例:创建只读类

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

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

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

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

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

    //获取并打印值
    System.out.println("Name of the person is: " + per.getName());
    System.out.println("Age of the person is: " + per.getAge());
  }
} 
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

    输出

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

    Java 封装:只写类

    A write-only 类只能有 setter 方法来设置属性的值，不应该有任何 getter 方法。

    示例:创建 Write-Only 类

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

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

  // 设置方法
  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 per = new Person();

    //设置值
    per.setName("Robert");
    per.setAge(21);
  }
} 
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23

    Java 封装:更多示例

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

    此示例创建一个名为"Person"的完全封装的类。该类具有私有类属性、setter 和 getter 方法。

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

  // 设置方法
  public void setName(String name) {
    this.name = name;
  }
  public void setAge(int age) {
    this.age = age;
  }

  // Getter 方法
  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());

  }
} 
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42

    输出

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

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

    此示例创建一个完全封装的类名为"Employee"。该类具有私有类属性、setter 和 getter 方法。

    //"员工"类
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 方法
  public String getEmpName() {
    return emp_name;
  }

  public String getEmpId() {
    return emp_id;
  }

  public double getSalary() {
    return net_salary;
  }

  // 设置方法
  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"的Main类
public class Main {
  public static void main(String args[]) {
    // Employee 类的对象
    // 第一个对象 - 使用构造函数设置值
    Employee emp = new Employee("Robert", "EMP001", 75450.00);

    //打印数据
    System.out.println("Employee (Intial 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());
  }
} 
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60

    输出

    Employee (Intial Values):
EMP001 , Robert , 75450.0
Employee (Updated Values):
EMP002 , Riyan , 90500.0 
    • 1
    • 2
    • 3