Encapsulation

1. Understanding Encapsulation

What is Encapsulation?

Encapsulation is one of the four fundamental OOP concepts. It refers to the bundling of data with the methods that operate on that data, or the restricting of direct access to some of an object's components. Encapsulation is used to hide the values or state of a structured data object inside a class, preventing direct access to them by clients in a way that could expose hidden implementation details or violate class invariants.

Here's a simple example of encapsulation:

<code>public class BankAccount {
    private double balance;  // private - encapsulated

    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }

    public double getBalance() {
        return balance;
    }
}</code>

In this example, the balance variable is private and can only be accessed or modified through the public methods deposit() and getBalance(). This is encapsulation in action.

2. Access Modifiers

Understanding Access Modifiers

Access modifiers are keywords in object-oriented languages that set the accessibility of classes, methods, and other members. Java provides four types of access modifiers:

Here's an example demonstrating different access modifiers:

<code>public class AccessModifierDemo {
    public int publicVar = 1;
    protected int protectedVar = 2;
    int defaultVar = 3;
    private int privateVar = 4;

    public void publicMethod() {
        System.out.println("This is a public method");
    }

    protected void protectedMethod() {
        System.out.println("This is a protected method");
    }

    void defaultMethod() {
        System.out.println("This is a default method");
    }

    private void privateMethod() {
        System.out.println("This is a private method");
    }
}</code>

Try creating a class with different access modifiers and experiment with accessing them from another class. Use the compiler below to write your code.

3. Getters and Setters

Understanding Getters and Setters

Getters and setters are methods used to retrieve and modify the values of private variables. They are a fundamental part of encapsulation, allowing controlled access to class members.

Here's an example of a class using getters and setters:

<code>public class Person {
    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 && age < 120) {
            this.age = age;
        } else {
            System.out.println("Invalid age");
        }
    }
}</code>

Try creating a class with private fields and implement getters and setters for them. Use the compiler below to write your code.

4. Encapsulation Best Practices

Best Practices for Encapsulation

Implementing encapsulation effectively involves following certain best practices. These guidelines help in creating more robust and maintainable code.

Here's an example demonstrating these best practices:

<code>public class Employee {
    private String name;
    private double salary;
    private final String employeeId;  // read-only

    public Employee(String name, String employeeId) {
        this.name = name;
        this.employeeId = employeeId;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        if (name != null && !name.isEmpty()) {
            this.name = name;
        } else {
            throw new IllegalArgumentException("Name cannot be null or empty");
        }
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        if (salary > 0) {
            this.salary = salary;
        } else {
            throw new IllegalArgumentException("Salary must be positive");
        }
    }

    public String getEmployeeId() {
        return employeeId;
    }
}</code>

Try creating a class that follows these best practices. Implement proper encapsulation for at least three attributes, including one read-only attribute. Use the compiler below to write your code.

5. Encapsulation Quiz

6. Weekly Project: Bank Account Management System

Project Description

For this week's project, you'll create a simple Bank Account Management System that demonstrates the principles of encapsulation.

Here's a template to get you started:

<code>import java.util.Date;

public class BankAccount {
    private String accountNumber;
    private double balance;
    private String ownerName;
    private final Date creationDate;

    // Constructor
    public BankAccount(String accountNumber, String ownerName) {
        // Initialize fields here
    }

    // Implement getters and setters

    public void deposit(double amount) {
        // Implement deposit logic
    }

    public void withdraw(double amount) {
        // Implement withdrawal logic
    }

    public void printAccountDetails() {
        // Print account details
    }

    public static void main(String[] args) {
        // Create bank accounts and perform operations
    }
}
</code>

Implement the BankAccount class and demonstrate its usage in the main method. Make sure to include proper encapsulation and validation. Use the online compiler to write and test your code. Once you're satisfied with your program, paste a sample output of creating an account, depositing money, withdrawing money, and printing account details in the autograder to check your work.