What is java encapsulation in javatpoint with example

What is java encapsulation in javatpoint with example

I'd be happy to explain Java Encapsulation with an example in JavatPoint style!

What is Encapsulation?

Encapsulation is one of the four pillars of Object-Oriented Programming (OOP) in Java, along with Inheritance, Polymorphism, and Abstraction. It is a mechanism that binds together the data (variables) and the methods that manipulate those data, making them non-accessible from outside the class. This concept helps to hide the internal implementation details of an object from the outside world.

Why do we need Encapsulation?

Encapsulation provides several benefits:

How does Encapsulation work in Java?

In Java, encapsulation is achieved by using access modifiers (public, private, protected) to control access to variables and methods within a class. Here are some rules:

Example: A Bank Account Class

Let's consider a simple example of a BankAccount class that demonstrates encapsulation in Java:

public class BankAccount {
// Encapsulated variables
private double balance;
private String accountNumber;
// Constructor to initialize the account
public BankAccount(double initialBalance, String accountNumber) {
this.balance = initialBalance;
this.accountNumber = accountNumber;
}
// Methods for manipulating and accessing encapsulated data
public void deposit(double amount) {
balance += amount;
}
public double getBalance() {
return balance;
}
public String getAccountNumber() {
return accountNumber;
}
}

In this example, the BankAccount class has two private variables: balance and accountNumber. The constructor initializes these variables. The class also provides methods like deposit() to modify the balance and getBalance() and getAccountNumber() to access the encapsulated data.

Key Takeaways

Now, go ahead and design your own classes with encapsulation in mind!

How many types of encapsulation are there in Java?

I'm happy to help! However, please note that I'll respond in English as per your request.

In Java, encapsulation is a fundamental concept that allows you to hide the internal implementation details of an object from the outside world while still exposing a public interface through which other objects can interact with it. There are several types of encapsulation in Java:

For example, consider a simple BankAccount class:

public class BankAccount {
private double balance;
public void deposit(double amount) {
balance += amount;
}
public double getBalance() {
return balance;
}
}

In this example, the balance variable is private, and the deposit and getBalance methods are public. Other classes can access the account balance only through these publicly accessible methods.

For instance, consider a Calculator class with a add method:

public class Calculator {
private double result;
public void add(double num1, double num2) {
// Internal implementation details: calculate the sum using the num1 and num2 variables
result = num1 + num2;
}
public double getResult() {
return result;
}
}

In this example, the add method hides its internal implementation details (calculating the sum) while still exposing a simple interface to other objects. The result variable is also private, so external objects cannot access or modify it directly.

For example:

public class Person {
private String name;
private int age;
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
}

In this example, the name and age variables are private, and the setName, getName, setAge, and getAge methods provide a controlled interface for accessing these values.

For example:

public class Calculator {
public int calculate(int num1, int num2) {
if (num1 > num2) {
return num1;
} else {
return num2;
}
}
// Private method: internal implementation details of the calculate method
private int internalCalculation(int num1, int num2) {
// ...
}
}

In this example, the calculate method hides its internal control flow (conditional statement) while still exposing a simple interface to other objects. The internalCalculation method is private, so external objects cannot access or modify it directly.

In summary, Java provides several types of encapsulation mechanisms, including class encapsulation, method encapsulation, data encapsulation, and control flow encapsulation. By using these concepts effectively, you can create robust, maintainable, and efficient software systems in Java.