Topic 11918 min readStructured Tutorial

Understanding the Private Access Modifier in Java

Quick Answer

Private explains in Java, access modifiers control the visibility of classes, methods, and variables.

Learning Objectives

Explain the purpose of Private in a practical learning context.
Identify the main ideas, terms, and decisions involved in Private.
Apply Private in a simple real-world scenario or practice task.

Introduction

In Java, access modifiers control the visibility of classes, methods, and variables.

The private access modifier is one of the most restrictive modifiers, limiting access to within the declaring class only.

"Encapsulation is the key to object-oriented programming."

What is the Private Access Modifier?

The private keyword in Java is used to declare class members that are accessible only within the class they belong to.

This means no other class, even subclasses or classes in the same package, can access private members directly.

Used to hide data and implementation details.
Supports encapsulation by restricting access.
Commonly applied to fields and helper methods.

How Private Differs from Other Access Modifiers

Java provides four access levels: private, default (package-private), protected, and public.

Private is the most restrictive, ensuring maximum encapsulation.

Java Access Modifiers Comparison
Modifier	Accessible Within Class	Accessible Within Package	Accessible in Subclass	Accessible Anywhere
private	Yes	No	No	No
default (no modifier)	Yes	Yes	No	No
protected	Yes	Yes	Yes	No
public	Yes	Yes	Yes	Yes

Using Private Members in Java Classes

Private members are typically accessed via public getter and setter methods.

This approach allows controlled access and validation when modifying private data.

Declare fields as private to protect data integrity.
Provide public methods to read or modify private fields safely.
Avoid exposing private fields directly to maintain encapsulation.

Example: Private Field with Getter and Setter

Consider a class representing a bank account with a private balance field.

Practical Example

This example shows a private balance field accessed only through public methods, ensuring controlled updates.

Examples

Java Private Field with Getter and Setter Example

public class BankAccount {
    private double balance;

    public BankAccount(double initialBalance) {
        this.balance = initialBalance;
    }

    public double getBalance() {
        return balance;
    }

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

    public void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
        }
    }
}

This example shows a private balance field accessed only through public methods, ensuring controlled updates.

Best Practices

Always declare class fields as private unless there is a strong reason not to.
Use public getter and setter methods to access private fields.
Validate data inside setter methods to maintain object integrity.
Avoid making methods private unless they are helper methods not needed outside the class.

Common Mistakes

Making fields public and exposing internal state directly.
Not providing any access methods for private fields, making them inaccessible.
Using private when package-private or protected would be more appropriate for intended access.
Overusing private methods that could be reused by subclasses.

Hands-on Exercise

Create a Class with Private Members

Write a Java class called 'Person' with private fields for name and age. Provide public getter and setter methods for these fields.

Expected output: A class with private fields and public getters/setters.

Hint: Use private keyword for fields and public methods for access.

Interview Questions

What does the private access modifier do in Java?

Interview

The private access modifier restricts access to class members so they can only be accessed within the class they are declared in.

Can a subclass access private members of its superclass?

Interview

No, private members are not accessible to subclasses directly.

Why should fields generally be declared private?

Interview

Declaring fields private enforces encapsulation, protecting the internal state from unauthorized access or modification.