Example of Data Hiding in Java

One of the core ideas of object-oriented programming (OOP) is data hiding, which is limiting access to an object's features and only revealing what is required. It is a fundamental idea that helps encapsulate data into classes, improving code maintainability and security.

Data hiding, sometimes referred to as information concealing, is a core idea in object-oriented programming (OOP) that centers on limiting access to specific object characteristics and revealing only the information required for the program to operate. Encapsulating a class's implementation details and separating its internal state from its outward interface is the main objective. Data hiding in Java is accomplished by using access modifiers such as private, protected, and public. Within a class and its subclasses, these modifiers control which variables and methods are shown.

Ways to Implement Data Hiding

1. Modifier for Private Access

To limit access to members (variables or methods) within the same class, use the private access modifier. It is not possible to immediately contact these people from outside the classroom.

public class MyClass {
    private int hiddenData;

    // Getter and Setter methods for hidden data
}

2. Setters and Getters:

It is standard procedure to indirectly access private members by using getter and setter methods. This permits restricted access to and alteration of the personal information.

public class MyClass {
    private int hiddenData;

    public int getHiddenData() {
        return hiddenData;
    }

    public void setHiddenData(int data) {
        this.hiddenData = data;
    }
}

ImplementDataHiding.java

public class ImplementDataHiding {
    // Private variable to demonstrate data hiding
    private int hiddenData;
    // Constructor to initialize hiddenData
    public ImplementDataHiding (int initialData) {
        this.hiddenData = initialData;
    }
    // Getter method to access the private variable hidden data
    public int getHiddenData() {
        return hiddenData;
    }
    // Setter method to modify the private variable hidden data
    public void setHiddenData(int newData) {
        this.hiddenData = newData;
    }
    public static void main(String[] args) {
        // Example usage of data hiding
        ImplementDataHiding myObject = new ImplementDataHiding (42);
        // Accessing hiddenData using the getter method
        int currentData = myObject.getHiddenData();
        System.out.println("Initial hiddenData value: " + currentData);
        // Modifying hiddenData using the setter method
        myObject.setHiddenData(100);
        System.out.println("Updated hiddenData value: " + myObject.getHiddenData());
    }
}

Output:

Initial hiddenData value: 42
Updated hiddenData value: 100

Implementation of Data Hiding

Let's examine a comprehensive example that shows how to hide data in Java.

DataHiding.java

public class DataHiding {
    private double balance;
    public DataHiding (double initialBalance) {
        this.balance = initialBalance;
    }
    // Getter for balance
    public double getBalance() {
        return balance;
    }
    // Method to deposit money
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
            System.out.println(amount + " deposited. New balance: " + balance);
        } else {
            System.out.println("Invalid deposit amount.");
        }
    }
    // Method to withdraw money
    public void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            System.out.println(amount + " withdrawn. New balance: " + balance);
        } else {
            System.out.println("Invalid withdrawal amount or insufficient funds.");
        }
    }
    public static void main(String[] args) {
        // Example usage
        DataHiding account = new DataHiding (1000.0);
        System.out.println("Initial balance: " + account.getBalance());
        account.deposit(500.0);
        account.withdraw(200.0);
    }
}

Output:

Initial balance: 1000.0
500.0 deposited. New balance: 1500.0
200.0 withdrawn. New balance: 1300.0

Explanation

The getBalance method is used in this example to grant access to the balance variable, which is defined as private. Methods are used for both deposits and withdrawals, guaranteeing restricted access to the account balance.

Advantages of Data Hiding

1. Encapsulation

Data hiding and encapsulation are closely related ideas. Data and methods that work with the data are bundled together into a class or single unit through the process of encapsulation. Encapsulation encourages modular and well-organized code by concealing a class's internal details (implementation and data). Because the core workings are concealed, and users engage through a clearly defined interface, this aids in better managing complexity.

2. Security

The improvement of security is one of the main applications of data concealing. Sensitive data is shielded from accidental or unauthorized changes by designating specific data members as private and limiting access using methods (getters and setters). This maintains the integrity and security of the program by preventing other parties from altering important data.

3. Maintainability

Code maintainability is enhanced via data hiding, which conceals a class's internal workings. Changes to the internal implementation are less likely to break current code since external code depends on a well-defined interface instead of the complex intricacies of the class. This reduces the possibility of unexpected adverse effects when updating and improving the software.

4. Code Organization

By making it apparent what should be kept private and what should be available from outside the class, data hiding encourages better code organization. The division of responsibilities promotes readability in the code and facilitates independent comprehension and development of various system components by developers.

Conclusion

A key component of Java programming that encourages encapsulation improves code security, and helps with better code organization is data hiding. Developers can create a robust and maintainable software system by properly implementing data-hiding techniques.

Next TopicForeign Function and Memory APIs in Java 21

← prev next →