Java: Encapsulation, Getters and Setters, Access Modifiers

Hey everyone! In my previous post, I covered constructors, return methods, and comments — essential concepts in Java. Today, we’ll continue exploring Object-Oriented Programming (OOP) by learning about encapsulation, getters and setters, access modifiers, and why modifying values directly isn’t a good practice. Encapsulation in Java Encapsulation is used to hide the values or state of a structured data object inside a class, preventing unauthorized direct access to them. Instead of allowing values to be changed freely, we use getters and setters to control access and ensure data integrity. Why use encapsulation? ✅ Keeps data safe by limiting access. ✅ Provides better control over how data is modified. ✅ Makes your code easier to maintain. Access Modifiers Access modifiers define the visibility of classes, methods, and variables. Java has four main access modifiers: public: Accessible from anywhere. default: Accessible within the same package protected: Accessible within the same package and by subclasses private: Accessible only within same class Example of Encapsulation with Getters and Setters: class Car { // Private fields to ensure data protection private String brand; private int maxSpeed; // Constructor to initialize values public Car(String brand, int maxSpeed) { this.brand = brand; this.maxSpeed = maxSpeed; } // Getter method for the brand public String getBrand() { return brand; } // Setter method for the brand public void setBrand(String brand) { this.brand = brand; } // Getter method for maxSpeed public int getMaxSpeed() { return maxSpeed; } // Setter method for maxSpeed public void setMaxSpeed(int maxSpeed) { this.maxSpeed = maxSpeed; } public void outputValues() { System.out.println("Brand: " + brand); System.out.println("Max Speed: " + maxSpeed); } } public class Main { public static void main(String[] args) { Car car = new Car("BMW", 250); // Using getter to display values System.out.println("Initial brand: " + car.getBrand()); // Using setter to update values car.setBrand("Audi"); car.setMaxSpeed(300); // Display updated values car.outputValues(); } } Output: Initial brand: BMW Brand: Audi Max Speed: 300 Why Avoid Direct Value Modification? Directly changing field values bypasses important checks and logic that ensure data consistency. Using getters and setters allows you to: ✅ Add validation rules. ✅ Control how values are updated. ✅ Improve code flexibility and scalability. Summary ✅ Encapsulation protects your data by using private fields. ✅ Getters and setters help control how data is accessed and modified. ✅ Access modifiers define what can be accessed from where. Whats next In the next post, we'll explore the topic of inheritance, method overriding, and polymorphism in Java. To practice, I suggest writing your own class with private fields, using both getters and setters. Try experimenting with access modifiers to understand their behavior better.

Mar 21, 2025 - 16:56

Java: Encapsulation, Getters and Setters, Access Modifiers

Hey everyone!

In my previous post, I covered constructors, return methods, and comments — essential concepts in Java. Today, we’ll continue exploring Object-Oriented Programming (OOP) by learning about encapsulation, getters and setters, access modifiers, and why modifying values directly isn’t a good practice.

Encapsulation in Java

Encapsulation is used to hide the values or state of a structured data object inside a class, preventing unauthorized direct access to them. Instead of allowing values to be changed freely, we use getters and setters to control access and ensure data integrity.

Why use encapsulation?

✅ Keeps data safe by limiting access.
✅ Provides better control over how data is modified.
✅ Makes your code easier to maintain.

Access Modifiers

Access modifiers define the visibility of classes, methods, and variables. Java has four main access modifiers:

public: Accessible from anywhere.
default: Accessible within the same package
protected: Accessible within the same package and by subclasses
private: Accessible only within same class

Example of Encapsulation with Getters and Setters:

class Car {
    // Private fields to ensure data protection
    private String brand;
    private int maxSpeed;

    // Constructor to initialize values
    public Car(String brand, int maxSpeed) {
        this.brand = brand;
        this.maxSpeed = maxSpeed;
    }

    // Getter method for the brand
    public String getBrand() {
        return brand;
    }

    // Setter method for the brand
    public void setBrand(String brand) {
            this.brand = brand;
    }

    // Getter method for maxSpeed
    public int getMaxSpeed() {
        return maxSpeed;
    }

    // Setter method for maxSpeed
    public void setMaxSpeed(int maxSpeed) {
            this.maxSpeed = maxSpeed;
    }

    public void outputValues() {
        System.out.println("Brand: " + brand);
        System.out.println("Max Speed: " + maxSpeed);
    }
}

public class Main {
    public static void main(String[] args) {
        Car car = new Car("BMW", 250);

        // Using getter to display values
        System.out.println("Initial brand: " + car.getBrand());

        // Using setter to update values
        car.setBrand("Audi");
        car.setMaxSpeed(300);

        // Display updated values
        car.outputValues();
    }
}

Output:

Initial brand: BMW
Brand: Audi
Max Speed: 300

Why Avoid Direct Value Modification?

Directly changing field values bypasses important checks and logic that ensure data consistency. Using getters and setters allows you to:

✅ Add validation rules.
✅ Control how values are updated.
✅ Improve code flexibility and scalability.

Summary

✅ Encapsulation protects your data by using private fields.
✅ Getters and setters help control how data is accessed and modified.
✅ Access modifiers define what can be accessed from where.

Whats next

In the next post, we'll explore the topic of inheritance, method overriding, and polymorphism in Java.

To practice, I suggest writing your own class with private fields, using both getters and setters. Try experimenting with access modifiers to understand their behavior better.