Java封裝(Encapsulation)實(shí)踐
封裝是面向?qū)ο缶幊蹋∣OP）中的一個(gè)核心概念，它涉及將數(shù)據(jù)（變量）和操作這些數(shù)據(jù)的方法（函數(shù)）捆綁成一個(gè)單一的單元或類。
封裝的主要目的是限制對對象某些組件的直接訪問，從而保護(hù)數(shù)據(jù)的完整性，確保數(shù)據(jù)只能通過受控的方式進(jìn)行訪問和修改。
什么是封裝？
封裝是將數(shù)據(jù)和操作數(shù)據(jù)的方法打包成一個(gè)單一單元的過程。
通過使用訪問修飾符（如 private、public 或 protected），封裝確保對象的內(nèi)部狀態(tài)只能通過類中的方法進(jìn)行更改。
這有助于提高數(shù)據(jù)的安全性和代碼的可維護(hù)性。
Java 中的封裝
在 Java 中，封裝指的是將類的數(shù)據(jù)成員（變量）和方法（代碼）集成到一個(gè)單一單元中。類的變量被隱藏起來，只能通過類中的方法進(jìn)行訪問。
具體來說，封裝涉及以下幾點(diǎn)：
- 隱藏?cái)?shù)據(jù)：將類的變量聲明為
private，防止外部直接訪問。 - 提供訪問方法：通過
public的 getter 和 setter 方法來控制對私有變量的訪問。 - 數(shù)據(jù)驗(yàn)證：在 setter 方法中添加驗(yàn)證邏輯，確保數(shù)據(jù)的有效性。
封裝的語法
<Access_Modifier> class <Class_Name> {
private <Data_Members>;
private <Data_Methods>;
// Getter and Setter methods
}
示例
下面是一個(gè)簡單的示例，展示了如何在 Java 中實(shí)現(xiàn)封裝：
package dc;
public class Main {
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;
// Getter for name
public String getName() {
return name;
}
// Setter for name
public void setName(String newName) {
name = newName;
}
// Getter for age
public int getAge() {
return age;
}
// Setter for age with validation
public void setAge(int newAge) {
if (newAge > 0) { // Ensure a valid age
age = newAge;
} else {
System.out.println("Please enter a valid age.");
}
}
// Getter for empID
public int getEmpID() {
return empID;
}
// Setter for empID
public void setEmpID(int newEmpID) {
empID = newEmpID;
}
}
實(shí)現(xiàn) Java 封裝的關(guān)鍵點(diǎn)
- 私有字段：
name、age和empID被聲明為private，不允許外部直接訪問。 - 公共方法：
getName()、setName()、getAge()、setAge()、getEmpID()和setEmpID()提供了對私有字段的受控訪問。 - 數(shù)據(jù)驗(yàn)證：在
setAge()和setEmpID()方法中添加了驗(yàn)證邏輯，確保輸入的數(shù)據(jù)是有效的。
封裝（Encapsulation）的優(yōu)勢和劣勢
優(yōu)勢
- 數(shù)據(jù)保護(hù)：
封裝通過限制對對象數(shù)據(jù)的直接訪問，確保數(shù)據(jù)只能通過受控的方法進(jìn)行修改，從而保護(hù)數(shù)據(jù)的完整性。
- 增強(qiáng)安全性：
通過隱藏內(nèi)部實(shí)現(xiàn)細(xì)節(jié)，封裝提高了安全性，防止未經(jīng)授權(quán)的訪問敏感數(shù)據(jù)。
- 簡化維護(hù)：
封裝的代碼更容易維護(hù)，因?yàn)閮?nèi)部實(shí)現(xiàn)的變化不會(huì)影響其他部分的代碼。
- 增加靈活性：
可以在不改變外部API的情況下修改內(nèi)部組件，允許靈活地改進(jìn)或更新內(nèi)部邏輯。
- 代碼復(fù)用性：
封裝促進(jìn)了模塊化代碼的使用，使得代碼可以在程序的不同部分或未來的項(xiàng)目中重用。
- 更好的數(shù)據(jù)控制：
使用getter和setter方法可以應(yīng)用驗(yàn)證和約束，確保數(shù)據(jù)的正確性。
- 減少復(fù)雜性：
封裝隱藏了復(fù)雜的實(shí)現(xiàn)細(xì)節(jié)，使得開發(fā)者可以更輕松地處理對象，而無需了解內(nèi)部工作原理。
- 防止意外交互：
封裝防止了對象狀態(tài)的意外或不當(dāng)修改，確保所有更改都是受控和有意的。
- 增強(qiáng)可讀性：
封裝的代碼通常更具可讀性和可理解性，因?yàn)樗峁┝饲逦臄?shù)據(jù)交互接口。
劣勢
- 增加代碼量：
封裝可能需要額外的方法（如getter和setter），這會(huì)增加代碼量，使其更加冗長。
- 性能下降：
通過方法間接訪問數(shù)據(jù)可能會(huì)引入輕微的性能開銷，與直接訪問相比。
- 更復(fù)雜的代碼結(jié)構(gòu)：
封裝有時(shí)會(huì)使代碼結(jié)構(gòu)變得更加復(fù)雜，尤其是在簡單直接訪問就足夠的情況下。
- 維護(hù)開銷：
管理封裝的方法（尤其是復(fù)雜的驗(yàn)證邏輯）需要仔細(xì)的維護(hù)，這可能會(huì)更加耗時(shí)。
- 用戶靈活性受限：
類的使用者可能需要更多的靈活性來訪問數(shù)據(jù)，而封裝只提供了預(yù)定義的方法，即使在某些情況下直接訪問會(huì)更簡單或更高效。
Java 封裝示例
示例 1：基本數(shù)據(jù)封裝
在這個(gè)示例中，我們通過將 Student 類的數(shù)據(jù)字段（如 name 和 age）聲明為 private，并通過提供公共的 getter 和 setter 方法來實(shí)現(xiàn)受控訪問。
// Encapsulated Student class
class Student {
// Private fields (data encapsulation)
private String name;
private int age;
// Getter for name
public String getName() {
return name;
}
// Setter for name
public void setName(String name) {
this.name = name;
}
// Getter for age
public int getAge() {
return age;
}
// Setter for age with validation
public void setAge(int age) {
if (age > 0) {
this.age = age;
} else {
System.out.println("Invalid age");
}
}
}
public class Main {
public static void main(String[] args) {
// Create Student object
Student student = new Student();
// Set data using setters
student.setName("Alice");
student.setAge(21);
// Get data using getters
System.out.println("Student Name: " + student.getName());
System.out.println("Student Age: " + student.getAge());
}
}
輸出：
Student Name: Alice Student Age: 21
示例 2：帶有驗(yàn)證的數(shù)據(jù)封裝
在這個(gè)示例中，BankAccount 類封裝了 balance 字段，并提供了詳細(xì)的驗(yàn)證邏輯，以防止設(shè)置無效值。
// Encapsulated BankAccount class
class BankAccount {
// Private field to store balance
private double balance;
// Getter for balance
public double getBalance() {
return balance;
}
// Setter for balance with validation (cannot be negative)
public void setBalance(double balance) {
if (balance >= 0) {
this.balance = balance;
} else {
System.out.println("Invalid balance. Balance cannot be negative.");
}
}
// Method to deposit money
public void deposit(double amount) {
if (amount > 0) {
balance += amount;
} else {
System.out.println("Deposit amount must be positive.");
}
}
// Method to withdraw money
public void withdraw(double amount) {
if (amount > 0 && amount <= balance) {
balance -= amount;
} else {
System.out.println("Invalid withdraw amount or insufficient balance.");
}
}
}
public class Main {
public static void main(String[] args) {
// Create BankAccount object
BankAccount account = new BankAccount();
// Set initial balance
account.setBalance(1000.00);
// Perform deposit and withdraw operations
account.deposit(500.00);
account.withdraw(300.00);
// Get the final balance
System.out.println("Final Balance: " + account.getBalance());
}
}
輸出：
Final Balance: 1200.0
示例 3：帶有多個(gè)字段的封裝
在這個(gè)示例中，Employee 類封裝了多個(gè)字段（如 name、salary 和 department），并確保這些字段只能通過 getter 和 setter 方法進(jìn)行訪問或修改。
// Encapsulated Employee class
class Employee {
// Private fields
private String name;
private double salary;
private String department;
// Getter for name
public String getName() {
return name;
}
// Setter for name
public void setName(String name) {
this.name = name;
}
// Getter for salary
public double getSalary() {
return salary;
}
// Setter for salary with validation
public void setSalary(double salary) {
if (salary > 0) {
this.salary = salary;
} else {
System.out.println("Invalid salary.");
}
}
// Getter for department
public String getDepartment() {
return department;
}
// Setter for department
public void setDepartment(String department) {
this.department = department;
}
}
public class Main {
public static void main(String[] args) {
// Create Employee object
Employee employee = new Employee();
// Set employee details using setters
employee.setName("John Smith");
employee.setSalary(70000);
employee.setDepartment("Engineering");
// Get and display employee details using getters
System.out.println("Employee Name: " + employee.getName());
System.out.println("Employee Salary: " + employee.getSalary());
System.out.println("Employee Department: " + employee.getDepartment());
}
}
輸出：
Employee Name: John Smith Employee Salary: 70000.0 Employee Department: Engineering
數(shù)據(jù)隱藏(Data Hiding)與封裝(Encapsulation)在Java中的應(yīng)用
數(shù)據(jù)隱藏（Data Hiding）
數(shù)據(jù)隱藏是一種避免訪問數(shù)據(jù)成員、數(shù)據(jù)方法及其邏輯實(shí)現(xiàn)的過程。這可以通過使用訪問修飾符來實(shí)現(xiàn)。Java 中有四種訪問修飾符：
- 默認(rèn)（Default）
默認(rèn)訪問修飾符是最基本的數(shù)據(jù)隱藏形式。
如果一個(gè)類沒有指定訪問修飾符，編譯器會(huì)將其設(shè)為默認(rèn)。
默認(rèn)訪問權(quán)限類似于公共（public）訪問權(quán)限，但僅限于同一個(gè)包內(nèi)的類訪問。
- 公共（Public）
示例：
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();
}
}
輸出：
I have a vehicle. It has 4 tires.
公共訪問修飾符提供類的訪問權(quán)限，使得該類可以從程序的任何地方訪問。
- 私有（Private）
示例：
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());
}
}
輸出：
Student rank is 1022
私有訪問修飾符限制數(shù)據(jù)成員和數(shù)據(jù)方法只能在類內(nèi)部訪問。
- 受保護(hù)（Protected）
示例：
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();
}
}
輸出：
Hello, I am a Computer Science and Engineering Technology Student
受保護(hù)訪問修飾符保護(hù)類的方法和成員，類似于私有訪問修飾符，但訪問范圍擴(kuò)展到整個(gè)包，而不僅僅是類本身。
數(shù)據(jù)隱藏與封裝的區(qū)別
| 數(shù)據(jù)隱藏 | 封裝 |
|---|---|
| 數(shù)據(jù)隱藏可以視為父過程 | 封裝是數(shù)據(jù)隱藏的一個(gè)子過程 |
| 訪問修飾符通常是私有的 | 訪問修飾符可以是私有的或公共的 |
| 數(shù)據(jù)隱藏關(guān)注的是隱藏方法的實(shí)現(xiàn) | 封裝關(guān)注的是將方法與數(shù)據(jù)成員結(jié)合在一起 |
| 主要目的是隱藏?cái)?shù)據(jù)及其實(shí)現(xiàn) | 主要目的是將數(shù)據(jù)和方法組合起來 |
常見問題解答 (FAQs)
封裝（Encapsulation）與抽象（Abstraction）有何區(qū)別？
- 封裝：封裝隱藏了對象的內(nèi)部狀態(tài)和實(shí)現(xiàn)細(xì)節(jié)，通過方法只暴露必要的部分。它主要保護(hù)數(shù)據(jù)，確保數(shù)據(jù)的安全性和完整性。
- 抽象：抽象通過關(guān)注系統(tǒng)的核心特征來簡化復(fù)雜的系統(tǒng)，同時(shí)隱藏不必要的細(xì)節(jié)。它主要用于簡化復(fù)雜性，使系統(tǒng)更易于理解和管理。
封裝的類型有哪些？
封裝通常分為兩種類型：
- 數(shù)據(jù)封裝：隱藏類的數(shù)據(jù)（屬性）。
- 功能封裝：通過接口隱藏類的功能（方法），以控制數(shù)據(jù)的訪問和修改方式。
現(xiàn)實(shí)生活中抽象和封裝的例子是什么？
- 抽象：你通過方向盤和踏板與汽車互動(dòng)，而不需要了解發(fā)動(dòng)機(jī)的內(nèi)部機(jī)械原理。
- 封裝：發(fā)動(dòng)機(jī)的內(nèi)部組件被隱藏和保護(hù)，確保你不能直接修改它們，只能通過特定的控制（如油門踏板）來間接操作。
封裝的類型有哪些？
封裝的主要類型包括：
- 私有封裝（Private Encapsulation）：數(shù)據(jù)完全對外部訪問隱藏，只有內(nèi)部方法可以修改它。
- 受保護(hù)封裝（Protected Encapsulation）：數(shù)據(jù)在類及其子類中可訪問，但對程序的其他部分不可見。
為什么要使用封裝？
封裝有以下幾個(gè)主要好處：
- 增強(qiáng)數(shù)據(jù)安全：通過限制對數(shù)據(jù)的直接訪問，防止未經(jīng)授權(quán)或意外的修改。
- 維護(hù)數(shù)據(jù)完整性：確保數(shù)據(jù)的一致性和正確性，通過 getter 和 setter 方法控制對數(shù)據(jù)的訪問。
- 提高模塊化：將類的內(nèi)部實(shí)現(xiàn)與外部接口分離，使代碼更易于維護(hù)和擴(kuò)展。
- 簡化維護(hù)：通過封裝，可以更容易地對類的內(nèi)部實(shí)現(xiàn)進(jìn)行修改，而不影響外部代碼的運(yùn)行。
總結(jié)
封裝作為面向?qū)ο缶幊痰囊粋€(gè)原則，描述了將數(shù)據(jù)和與數(shù)據(jù)交互的方法組合成一個(gè)單一單元的過程。
它常用于隱藏敏感數(shù)據(jù)，限制外部對特定屬性的訪問，同時(shí)允許通過公共 getter 和 setter 方法訪問這些屬性。
封裝提供了隱藏?cái)?shù)據(jù)的基本屬性，保護(hù)用戶數(shù)據(jù)。
以下是本文的重點(diǎn)內(nèi)容總結(jié)：
什么是封裝？
封裝（Encapsulation）是面向?qū)ο缶幊蹋∣OP）的四大基本原則之一，其他三個(gè)原則分別是繼承（Inheritance）、多態(tài)（Polymorphism）和抽象（Abstraction）。
封裝的主要目的是將數(shù)據(jù)（屬性）和操作數(shù)據(jù)的方法（行為）綁定在一起，形成一個(gè)獨(dú)立的單元（即類），并通過訪問控制來保護(hù)數(shù)據(jù)的完整性和安全性。
封裝的目的
- 數(shù)據(jù)保護(hù)：通過限制對類內(nèi)部數(shù)據(jù)的直接訪問，防止外部代碼對數(shù)據(jù)的非法修改，從而保證數(shù)據(jù)的安全性和完整性。
- 代碼組織：將相關(guān)的數(shù)據(jù)和方法組織在一起，形成一個(gè)邏輯單元，使代碼更加清晰和模塊化。
- 代碼復(fù)用：封裝好的類可以被多個(gè)程序或模塊重用，提高代碼的可重用性和可維護(hù)性。
- 簡化接口：通過封裝，可以隱藏類的內(nèi)部實(shí)現(xiàn)細(xì)節(jié)，只暴露必要的接口給外部使用，簡化了外部調(diào)用者的使用難度。
實(shí)現(xiàn)封裝的方式
在 Java 中，封裝主要通過以下幾種方式實(shí)現(xiàn)：
訪問修飾符：
- private：最嚴(yán)格的訪問級(jí)別，只能在定義該成員的類內(nèi)部訪問。
- protected：可以在同一包內(nèi)或子類中訪問。
- default（無修飾符）：只能在同一包內(nèi)訪問。
- public：最寬松的訪問級(jí)別，可以在任何地方訪問。
Getter 和 Setter 方法：
- Getter 方法：用于獲取類的私有屬性值。
- Setter 方法：用于設(shè)置類的私有屬性值。
- 通過這些方法，可以在設(shè)置和獲取屬性值時(shí)添加額外的驗(yàn)證邏輯，確保數(shù)據(jù)的合法性。
封裝的好處
- 數(shù)據(jù)安全：通過私有化屬性，防止外部直接修改數(shù)據(jù)，確保數(shù)據(jù)的安全性。
- 數(shù)據(jù)完整性：通過在 setter 方法中添加驗(yàn)證邏輯，確保數(shù)據(jù)的合法性和一致性。
- 代碼復(fù)用：封裝好的類可以被多個(gè)程序或模塊重用，提高代碼的可重用性。
- 模塊化：將相關(guān)的數(shù)據(jù)和方法組織在一起，形成一個(gè)邏輯單元，使代碼更加清晰和模塊化。
- 簡化接口：通過封裝，可以隱藏類的內(nèi)部實(shí)現(xiàn)細(xì)節(jié)，只暴露必要的接口給外部使用，簡化了外部調(diào)用者的使用難度。
結(jié)論
封裝是 Java 中實(shí)現(xiàn)數(shù)據(jù)保護(hù)和代碼組織的重要手段。
通過合理使用訪問修飾符和 getter/setter 方法，可以有效地保護(hù)類的內(nèi)部數(shù)據(jù)，確保數(shù)據(jù)的安全性和完整性，同時(shí)提高代碼的可重用性和可維護(hù)性。
封裝是面向?qū)ο缶幊痰暮诵母拍钪?，對于編寫高質(zhì)量的軟件系統(tǒng)至關(guān)重要。
以上為個(gè)人經(jīng)驗(yàn)，希望能給大家一個(gè)參考，也希望大家多多支持腳本之家。
相關(guān)文章
Java8新特性之接口中的默認(rèn)方法和靜態(tài)方法詳解
今天帶大家學(xué)習(xí)的是Java8新特性的相關(guān)知識(shí),文章圍繞著Java接口中的默認(rèn)方法和靜態(tài)方法展開,文中有非常詳細(xì)的的代碼示例,需要的朋友可以參考下2021-06-06
springboot項(xiàng)目數(shù)據(jù)庫配置類DatabaseConfig示例詳解
這篇文章主要介紹了springboot項(xiàng)目數(shù)據(jù)庫配置類DatabaseConfig實(shí)現(xiàn)代碼,本文通過示例代碼給大家介紹的非常詳細(xì)，對大家的學(xué)習(xí)或工作具有一定的參考借鑒價(jià)值，需要的朋友可以參考下2023-08-08
這篇文章主要為大家詳細(xì)介紹了如何使用Java8實(shí)現(xiàn)模板方法模式的改造，文中的示例代碼講解詳細(xì)，對我們深入了解java8有一定的幫助，感興趣的可以了了解一下2023-01-01
IntelliJ IDEA 2020 安裝和常用配置(推薦)
這篇文章主要介紹了IntelliJ IDEA 2020 安裝和常用配置(推薦)，文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2020-08-08
hibernate測試時(shí)遇到的幾個(gè)異常及解決方法匯總
今天小編就為大家分享一篇關(guān)于hibernate測試時(shí)遇到的幾個(gè)異常及解決方法匯總，小編覺得內(nèi)容挺不錯(cuò)的，現(xiàn)在分享給大家，具有很好的參考價(jià)值，需要的朋友一起跟隨小編來看看吧2019-03-03
Zuul1與Spring Cloud Gateway的區(qū)別及說明
Zuul1基于Servlet阻塞IO,穩(wěn)定但高并發(fā)易耗盡線程；SpringCloudGateway采用非阻塞IO和Netty,性能更優(yōu)、內(nèi)置限流,適合高并發(fā)場景,兩者均支持SpringCloud集成,但Zuul1有更多生產(chǎn)落地案例2025-07-07
spring scheduled單線程和多線程使用過程中的大坑
本文主要介紹了spring scheduled單線程和多線程使用過程中的大坑，文中通過示例代碼介紹的非常詳細(xì)，具有一定的參考價(jià)值，感興趣的小伙伴們可以參考一下2022-01-01
對象存儲(chǔ)服務(wù)OSS是一種海量、安全、低成本、高可靠的云存儲(chǔ)服務(wù)，適合存放任意類型的文件，這篇文章主要介紹了SpringBoot集成MinIO的示例代碼,需要的朋友可以參考下2023-06-06
springBoot下實(shí)現(xiàn)java自動(dòng)創(chuàng)建數(shù)據(jù)庫表
這篇文章主要介紹了springBoot下實(shí)現(xiàn)java自動(dòng)創(chuàng)建數(shù)據(jù)庫表的操作，具有很好的參考價(jià)值，希望對大家有所幫助。如有錯(cuò)誤或未考慮完全的地方，望不吝賜教2021-07-07
java中sleep方法和wait方法的五個(gè)區(qū)別
這篇文章主要介紹了java中sleep方法和wait方法的五個(gè)區(qū)別，sleep?方法和?wait?方法都是用來將線程進(jìn)入休眠狀態(tài)，但是又有一些區(qū)別，下面我們就一起來看看吧2022-05-05