欢迎来到百战百胜！我们致力于为广大IT从业者、学生和爱好者提供全面、实用的资源和服务。加入我们的聊天群，这里有专业大佬为你提供有价值的建议和指导！
Java中的封装是一种强大的机制，用于将类的数据成员和数据方法存储在一起。它以安全字段的形式完成，只有同一类的成员才能访问。
Java中的封装是将数据(变量)和作用于它们的代码(方法)集成为一个单元的过程。通过封装类的变量，其他类无法访问它们，只有类的方法可以访问它们。
Java中的封装是什么？
Java中的封装指的是将数据(变量)和代码(方法)集成到单个单元中。在封装中，类的变量对其他类是隐藏的，并且只能由找到它们的类的方法访问。
Java中的封装是一个面向对象的过程，它将类的数据成员和数据方法组合到用户定义的类中。将此类声明为私有类非常重要。
接下来，我们将了解在Java中实现封装时要遵循的原则。
Syntax:
<Access_Modifier> class <Class_Name> {
private <Data_Members>;
private <Data_Methods>;
}
为了加深对封装过程的理解，让我们来看看下面的示例程序。
Example:
package dc;
public class c
{
public static void main (String[] args)
{
Employee e = new Employee();
e.setName("Robert");
e.setAge(33);
e.setEmpID(1253);
System.out.println("Employee's name: " + e.getName());
System.out.println("Employee's age: " + e.getAge());
System.out.println("Employee's ID: " + e.getEmpID());
}
}
package dc;
public class Employee {
private String Name;
private int EmpID;
private int Age;
public int getAge() {
return Age;
}
public String getName() {
return Name;
}
public int getEmpID() {
return EmpID;
}
public void setAge(int newAge) {
Age = newAge;
}
public void setName(String newName) {
Name = newName;
}
public void setRoll(int newEmpID) {
EmpID = newEmpID;
}
public void setEmpID(int EmpID) {
}
}
Java中的封装需求
封装将编码过程改进到了一个全新的水平。出于各种原因，我们需要用Java进行封装。它们如下所述。
Better Control
封装提供了对类内的数据成员和数据方法的最终控制。
Getter and Setter
标准的IDE提供了对‘getter和setter’方法的内置支持，这加快了编程速度。
Security
封装防止任何外部类访问数据成员和数据方法。封装过程提高了封装数据的安全性。
Flexibility
对代码的一部分所做的更改可以成功实现，而不会影响代码的任何其他部分。
Java中的数据隐藏
数据隐藏是为避免访问数据成员和数据方法及其逻辑实现而执行的过程。数据隐藏可以通过使用访问说明符来完成。我们有四个访问说明符，如下所示。
Default
默认为数据隐藏的第一行。如果Java中的任何类没有使用访问说明符，那么编译器将设置'default'作为访问说明符。default的访问规范与public访问规范非常相似。
Public
公共访问说明符为类提供访问规范，以便可以从程序中的任何位置访问该类。
Example:
package Simplilearn;
class vehicle {
public int tires;
public void display() {
System.out.println("I have a vehicle.");
System.out.println("It has " + tires + " tires.");
}
}
public class Display {
public static void main(String[] args) {
vehicle veh = new vehicle();
veh.tires = 4;
veh.display();
}
}
Private
私有访问说明符提供对数据成员的访问，而数据方法仅限于类本身。
Example:
package Simplilearn;
class Student {
private int rank;
public int getRank() {
return rank;
}
public void setRank(int rank) {
this.rank = rank;
}
}
public class school {
public static void main(String[] args) {
Student s = new Student();
s.setRank(1022);
System.out.println("Student rank is " + s.getRank());
}
}
Protected
受保护访问说明符保护类方法和成员，类似于私有访问说明符。主要区别在于，访问仅限于整个包，不同于仅具有私有访问说明符的类。
Example:
package Simplilearn;
class human {
protected String stream;
protected void display() {
System.out.println("Hello, I am a " + stream + " Student");
}
}
public class Student extends human {
public static void main(String[] args) {
Student s = new Student();
s.stream = "Computer Science and Engineering Technology";
s.display();
}
}
Java中的数据隐藏与封装
Getter和Setter方法
Getter和setter技术通常在面向对象的编程语言中被引用。属性可以使用getter方法检索，也可以使用setter方法更改，如名称所示。您的实现方法将确定是否可以读取和更新属性。此外，您还可以选择属性是只读的还是完全隐藏的。
### Example 1
下面是一个演示如何在Java中实现封装的示例
/* File name : 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;
}
}
公共的setXXX()和getXXX()方法提供对EncapTest类的实例变量的访问。
术语“getters”和“setters”通常用来描述这些技术。因此，每个需要访问变量的类都应该使用这些getter和setter。
可以使用以下程序访问encap测试类的变量 –
/* File name : 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());
}
}
CoffeeMachine示例
封装，或“信息隐藏”，指的是隐藏对象内部过程的细节的做法。它只不过是一种简单的数据掩蔽技术。
在开发CoffeeMachine类时，实现了封装方法。CoffeeMachine对象的当前状态记录在属性CoffeeMap、beans、grinder和brewingUnit中。
方法brewCoffee、brewEspresso、brewFilterCoffee和addBeans可用于对这些属性执行各种操作。
#### Code:
import java.util.HashMap;
import java.util.Map;
public class CoffeeMachine {
private Map configMap;
private Map beans;
private Grinder grinder;
private BrewingUnit brewingUnit;
public CoffeeMachine(Map beans) {
this.beans = beans;
this.grinder = new Grinder();
this.brewingUnit = new BrewingUnit();
this.configMap = new HashMap();
this.configMap.put(CoffeeSelection.ESPRESSO, new Configuration(8, 28));
this.configMap.put(CoffeeSelection.FILTER_COFFEE, new Configuration(30, 480));
}
public Coffee brewCoffee(CoffeeSelection selection) throws CoffeeException {
switch (selection) {
case FILTER_COFFEE:
return brewFilterCoffee();
case ESPRESSO:
return brewEspresso();
default:
throw new CoffeeException("CoffeeSelection [" + selection + "] not supported!");
}
}
private Coffee brewEspresso() {
Configuration config = configMap.get(CoffeeSelection.ESPRESSO);
// grind the coffee beans
GroundCoffee groundCoffee = this.grinder.grind(
this.beans.get(CoffeeSelection.ESPRESSO), config.getQuantityCoffee());
// brew an espresso
return this.brewingUnit.brew(CoffeeSelection.ESPRESSO,
groundCoffee, config.getQuantityWater());
}
private Coffee brewFilterCoffee() {
Configuration config = configMap.get(CoffeeSelection.FILTER_COFFEE);
// grind the coffee beans
GroundCoffee groundCoffee = this.grinder.grind(
this.beans.get(CoffeeSelection.FILTER_COFFEE), config.getQuantityCoffee());
// brew a filter coffee
return this.brewingUnit.brew(CoffeeSelection.FILTER_COFFEE,
groundCoffee, config.getQuantityWater());
}
public void addBeans(CoffeeSelection sel, CoffeeBean newBeans) throws CoffeeException {
CoffeeBean existingBeans = this.beans.get(sel);
if (existingBeans != null) {
if (existingBeans.getName().equals(newBeans.getName())) {
existingBeans.setQuantity(existingBeans.getQuantity() + newBeans.getQuantity());
} else {
throw new CoffeeException("Only one kind of beans supported for each CoffeeSelection.");
}
} else {
this.beans.put(sel, newBeans);
}
}
}
咖啡自动售货机封装了内部流程和配料(数据)。
Java中封装的好处
在Java中实现封装过程已被证明在实时编程时是非常有效和有益的。以下是封装的显著优势。
类可以完全控制其数据成员和数据方法。
该类将其数据成员和方法保持为只读。
数据隐藏可防止用户在代码中执行复杂的实现。
根据程序员的要求，类的变量可以是只读的或只写的。
Java中的封装提供了代码可重用性的选项。
使用封装将有助于快速更改现有代码。
对使用封装设计的代码进行单元测试是基本的。
标准IDE支持getter和setter；这使得编码变得更快。
至此，我们现在已经到了“用Java进行封装”这篇文章的末尾。我们希望您喜欢学习Java中封装的基本概念。
结论
作为面向对象的编程原则，Java封装描述了将数据和与此数据交互的方法分组到单个单元中。
它经常被用作隐藏敏感数据的手段。您可以使用这些方法指定可以读取或更新的属性，并在使用它们更改属性之前验证新值。
为了保护用户数据，封装提供了隐藏数据的基本属性。OOP最佳实践（如封装）在与APM解决方案（如Retrace）配合使用时非常有用，以进行错误检测。