DEV Community

Cover image for What is encapsulation and how to use it.
Ifeoluwa
Ifeoluwa

Posted on

What is encapsulation and how to use it.

What is encapsulation?
Encapsulation in Java is all about keeping the details of how something works hidden while still letting others use it. You group your data (like variables) and methods (like functions) into one unit, called a class. Instead of letting everyone directly access your data, you provide methods (getters and setters) to control how it’s accessed or changed. This way, you protect your data and keep your code clean and organized, without letting anyone mess with the inner workings unless you want them to.

How to use it
To use encapsulation in Java, you create a class with private fields and provide public methods (like getters and setters) to access and modify those fields. This ensures that the data can only be changed in a controlled way. For example, if you want to create a Person class where the name and age are private, you would use getters to retrieve the values and setters to update them. Here's how you can do it:

public class Person {
    // Private fields
    private String name;
    private int age;

    // Constructor
    public Person(String name, int age) {
        this.name = name;
        this.age = 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
    public void setAge(int age) {
        if(age > 0) { // Simple validation
            this.age = age;
        } else {
            System.out.println("Age must be positive.");
        }
    }
}

// Using the Person class
public class Main {
    public static void main(String[] args) {
        Person person = new Person("John", 25);

        // Accessing fields using getters
        System.out.println(person.getName()); // Output: John
        System.out.println(person.getAge());  // Output: 25

        // Modifying fields using setters
        person.setName("Jane");
        person.setAge(30);

        System.out.println(person.getName()); // Output: Jane
        System.out.println(person.getAge());  // Output: 30
    }
}

Enter fullscreen mode Exit fullscreen mode

Lets break it down
Let's break down the code and explain each section step by step:

1. Class Definition with Private Fields
public class Person {
    // Private fields
    private String name;
    private int age;
}

Enter fullscreen mode Exit fullscreen mode
Explanation:

This is the Person class where we define two private fields: name (a String) and age (an int). By making these fields private, we ensure that no other class can directly access or modify them. This is the core idea of encapsulation β€” hiding the internal state of an object.

2. Constructor
    // Constructor
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

Enter fullscreen mode Exit fullscreen mode
Explanation:

The constructor initializes the Person object when it's created. It takes two parameters, name and age, and assigns these values to the private fields. This ensures that when a new Person object is created, it starts with valid data.

3. Getter and Setter for
    // Getter for name
    public String getName() {
        return name;
    }

    // Setter for name
    public void setName(String name) {
        this.name = name;
    }

Enter fullscreen mode Exit fullscreen mode
Explanation:

The constructor initializes the Person object when it's created. It takes two parameters, name and age, and assigns these values to the private fields. This ensures that when a new Person object is created, it starts with valid data.

4. Getter and Setter for age (with validation)
    // Getter for age
    public int getAge() {
        return age;
    }

    // Setter for age
    public void setAge(int age) {
        if (age > 0) { // Simple validation
            this.age = age;
        } else {
            System.out.println("Age must be positive.");
        }
    }

Enter fullscreen mode Exit fullscreen mode
Explanation:

The getter getAge() works the same way as the one for name, allowing access to the age field.
The setter setAge() not only allows modification of the age field but also adds a validation check. The if condition ensures that the age is only set if it's a positive number. If an invalid age is provided (like a negative number), the setter prevents the update and prints a message instead. This is an example of how encapsulation lets you control what kind of data can be set.

5. Using the Person Class
// Using the Person class
public class Main {
    public static void main(String[] args) {
        Person person = new Person("John", 25);

        // Accessing fields using getters
        System.out.println(person.getName()); // Output: John
        System.out.println(person.getAge());  // Output: 25

        // Modifying fields using setters
        person.setName("Jane");
        person.setAge(30);

        System.out.println(person.getName()); // Output: Jane
        System.out.println(person.getAge());  // Output: 30
    }
}

Enter fullscreen mode Exit fullscreen mode
Explanation:

In this section, we create a Person object (person) using the constructor. The constructor sets the initial name as "John" and age as 25.

Then, we use the getters (getName() and getAge()) to print the values of name and age. After that, we use the setters (setName() and setAge()) to update the values. Finally, the updated values are printed using the getters again.

Key Points of Encapsulation in Action:

  • Data Protection:

    The private fields can't be directly accessed or modified from outside the class.

  • Controlled Access:

    Getters and setters provide a controlled way of accessing and modifying the private fields.

  • Validation:

    The setter for age demonstrates how you can enforce rules (e.g., age must be positive) to protect the data from invalid input.

Top comments (3)

Collapse
 
munezero2000 profile image
Munezero2000

Thanks for sharing even though alot are now interested in js so OOP is another story to us but java is sweety when you understand it

Collapse
 
ife_oluwa profile image
Ifeoluwa

thanks

Collapse
 
ife_oluwa profile image
Ifeoluwa

what do you guys think