Advanced Java · Week 3

Encapsulation

Step 1 of 7

Java 2 Guided Tutorials - Week 3: Encapsulation

What You'll Learn

Welcome to Week 3 of Java 2! This week, we'll dive deep into encapsulation, one of the fundamental principles of object-oriented programming (OOP). We'll explore how encapsulation helps in creating more secure and maintainable code.

                    Lesson Overview:
                    Understanding Encapsulation
Access Modifiers in Java
Getters and Setters
Encapsulation Best Practices
Quiz to test your knowledge
Weekly project to apply what you've learned

                

By the end of this week, you'll have a solid understanding of encapsulation and how to apply it in your Java programs. Let's get started!

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.

                    Key Points:
                    Encapsulation provides data hiding
It helps in maintaining the integrity of data
It reduces system complexity
It improves modularity

                

Here's a simple example of encapsulation:

public class BankAccount {
    private double balance;  // private - encapsulated

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

    public double getBalance() {
        return balance;
    }
}

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:

                    Types of Access Modifiers:
                    public: Accessible from any other class
protected: Accessible within the same package and subclasses
default (no modifier): Accessible only within the same package
private: Accessible only within the same class

                

Here's an example demonstrating different access modifiers:

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");
    }
}

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

Write your code here

Make it print Public method accessed Protected method accessed Default method accessed Private method not accessible

Did it work?

Your program should print this:

Public method accessed
Protected method accessed
Default method accessed
Private method not accessible

Paste what you got:

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.

                    Key Points:
                    Getters retrieve the value of a private field
Setters modify the value of a private field
They allow for validation before setting a value
They provide a way to make a class immutable

                

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

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");
        }
    }
}

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

Write your code here

Make it print Name: John Doe Age: 25 Invalid age

Did it work?

Your program should print this:

Name: John Doe
Age: 25
Invalid age

Paste what you got:

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.

                    Best Practices:
                    Declare instance variables as private
Provide public setter and getter methods to modify and view the variables' values
For read-only fields, only provide a getter method
For write-only fields, only provide a setter method
Perform data validation in setter methods
Use meaningful names for getter and setter methods

                

Here's an example demonstrating these best practices:

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;
    }
}

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.

Write your code here

Make it print Name: Alice Johnson Employee ID: EMP001 Salary: 50000.0 Illegal Argument Exception: Salary must be positive

Did it work?

Your program should print this:

Name: Alice Johnson
Employee ID: EMP001
Salary: 50000.0
Illegal Argument Exception: Salary must be positive

Paste what you got:

Quick check

1. What is the main purpose of encapsulation?
2. Which access modifier provides the highest level of encapsulation?
3. What is the primary purpose of getter methods in encapsulation?

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.

                    Requirements:
                    Create a BankAccount class with private fields for account number, balance, and owner name
Implement proper getters and setters for each field
Include methods for deposit and withdrawal with appropriate validation
Create a read-only field for the account creation date
Implement a method to print account details
In the main method, create multiple bank accounts and perform various operations

                

Here's a template to get you started:

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
    }
}

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.

Write your code here

Make it print Account created for John Doe Deposit: $1000.0 Withdrawal: $500.0 Account Details: Account Number: AC001 Owner: John Doe Balance: $500.0 Creation Date: [Current Date]

Did it work?

Your program should print this:

Account created for John Doe
Deposit: $1000.0
Withdrawal: $500.0
Account Details:
Account Number: AC001
Owner: John Doe
Balance: $500.0
Creation Date: [Current Date]

Paste what you got:

PreviousClasses NextInheritance