Encapsulation is a fundamental principle of object-oriented programming that combines data and methods within a class while hiding internal implementation details to enhance security and maintainability. It promotes data hiding, information protection, and abstraction, allowing for flexible, reusable code that is easier to test and debug. Accessors (getters) and mutators (setters) are used to control access and modification of private data members, ensuring the integrity of an object's state.

1. ENCAPSULATION

2. Introduction
 Encapsulation is one of the four fundamental principles of object-
oriented programming (OOP), along with inheritance,
polymorphism, and abstraction. It is a concept that bundles data
and methods (or functions) that operate on the data within a single
unit called a class. The key idea behind encapsulation is to hide the
internal implementation details of an object and expose only the
necessary interfaces to interact with it. In Java, encapsulation is
achieved through access modifiers and getter and setter methods.
 Encapsulation helps in creating robust and maintainable code by
preventing direct access to the object's internal state and ensuring
that all interactions with the object are performed through well-
defined methods.

3. Encapsulation Principles and Benefits
 Principles of Encapsulation
1. Data Hiding: The internal state of an object (data members) is hidden
from the outside world, and access is restricted to specific methods
(getters and setters). This prevents unauthorized or accidental
modification of the object's state.
2. Information Protection: Encapsulation ensures that the object's data
can only be accessed and modified in a controlled manner, following
the rules defined by the class. This protects the integrity of the object
and maintains the consistency of its state.
3. Abstraction: Encapsulation allows the class to present a simple and
easy-to-understand interface to the outside world, abstracting away
the complexities of its internal implementation. This simplifies the
usage of the class for other parts of the program.

4. Benefits of Encapsulation
1. Security: By hiding the internal details of an object, encapsulation
prevents unauthorized access and modification, making the code more
secure.
2. Code Flexibility: Encapsulation allows the internal implementation of a
class to change without affecting other parts of the program that use the
class. This promotes code flexibility and easier maintenance.
3. Code Reusability: Encapsulation enables the creation of reusable
components, as other parts of the program can interact with the class
through its well-defined interface.
4. Testing and Debugging: Encapsulation makes it easier to test and debug
the code since the class's internal state is well-controlled and accessed
through methods.

5. Accessors (Getters) and Mutators (Setters)
 Getters (Accessors)
Getters are methods used to access the values
of private data members of a class from
outside the class. They are defined with the
public access modifier and typically follow a
naming convention like getVariableName().
Getters do not modify the data; instead, they
return the value of the data member.

6. Example of a getter method:
class Person {
private String name;
public String getName() {
return name;
}
}

7. Setters (Mutators)
 Setters are methods used to modify the
values of private data members of a class
from outside the class. They are defined
with the public access modifier and
typically follow a naming convention like
setVariableName(newValue). Setters
allow controlled modification of the
object's state and can include validation
logic.

8. Example of a setter method:
class Person {
private int age;
public void setAge(int newAge) {
if (newAge >= 0) {
age = newAge;
}
}
}

9. Data Hiding and Information Protection
 Encapsulation ensures that the internal state of an
object is hidden from the outside world, protecting it
from unauthorized access or modification. This is
achieved by declaring the data members of the
class as private, preventing direct access from other
classes.

10. Example of data hiding using encapsulation: (THIS IS
CLASS)
class BankAccount {
private double balance;
public double getBalance()
{
return balance;
}
public void deposit(double
amount) {
if (amount > 0) {
balance += amount;
}
}
public void
withdraw(double amount) {
if (amount > 0 && amount
<= balance) {
balance -= amount;
}
}
}

11. Example: Main Class
public class Main {
public static void
main(String[] args) {
BankAccount account = new
BankAccount();
System.out.println("Initial
balance: " +
account.getBalance());
account.deposit(1000);
System.out.println("After
deposit: " +
account.getBalance());
account.withdraw(500);
System.out.println("After
withdrawal: " +
account.getBalance());
}
}

12. Example explanation
 In this example, the balance data member is
declared as private, and the methods getBalance(),
deposit(), and withdraw() provide controlled access
to modify and retrieve the balance

13. Encapsulation in Class Design
 When designing classes, it is essential to consider encapsulation to create well-
organized and maintainable code. Here are some guidelines to follow:
1. Identify Relevant Data: Determine the data members that are essential for the
class's functionality and declare them as private.
2. Provide Getters and Setters: Create appropriate getter and setter methods to
access and modify the private data members. This allows controlled access to
the data.
3. Minimize Exposure: Limit the number of public methods and data members to
minimize the class's exposure to the outside world. This prevents unnecessary
dependencies and reduces the risk of unintended changes to the internal state.
4. Encapsulate Complex Logic: If a class has complex logic, encapsulate it within
the class, and provide simple, high-level methods as the interface.
5. Validate Input: Implement validation logic in the setters to ensure that only
valid data is allowed, maintaining the integrity of the object.