Java Interview Questions

Understanding the core components of the Java ecosystem – JDK, JRE, and JVM – is fundamental for anyone working with Java. While often used interchangeably by newcomers, each plays a distinct and crucial role in the development and execution of Java applications. This explanation clarifies their individual functions and how they relate to one another.

JVM (Java Virtual Machine)

The JVM is an abstract machine that provides a runtime environment in which Java bytecode can be executed. It is a specification that provides a runtime environment. Implementations of the JVM are available for various hardware and software platforms. When you compile a Java source file (.java), it gets compiled into bytecode (.class files), which is then interpreted and executed by the JVM. The JVM is responsible for crucial tasks like loading code, verifying code, executing code, and providing a runtime environment, including memory management (garbage collection) and security features. It is the component that makes Java 'write once, run anywhere' possible, as different JVM implementations handle platform-specific details.

Key Characteristics of JVM

• Specification: A document that formally describes what is required of a JVM implementation.
• Implementation: A concrete program that meets the requirements of the JVM specification (e.g., HotSpot JVM by Oracle).
• Runtime Instance: An instance of a JVM implementation running a specific Java application.
• Platform-Dependent: While Java bytecode is platform-independent, the JVM itself is platform-dependent (e.g., there's a different JVM for Windows, Linux, macOS, etc.).

JRE (Java Runtime Environment)

The JRE is a software package that provides the minimum requirements for executing a Java application. It literally provides the 'runtime environment' for Java programs. The JRE includes the JVM and the Java core class libraries, along with supporting files. Essentially, if you only want to run Java applications but not develop them, you only need the JRE. It does not contain any development tools like compilers or debuggers.

Components of JRE

• JVM: The heart of the JRE, responsible for executing Java bytecode.
• Core Class Libraries: A set of standard Java libraries (e.g., java.lang, java.io, java.util) that Java applications use.
• Supporting Files: Other files like property settings and resource files.

JDK (Java Development Kit)

The JDK is a super-set of JRE. It is a software development environment used for developing Java applications and applets. The JDK includes the JRE, along with a suite of development tools necessary to write, compile, debug, and run Java programs. If you are a Java developer, you need the JDK. It provides everything you need to develop and run Java applications.

Components of JDK

• JRE: Includes the JVM and Java core class libraries for running applications.
• Development Tools: This is where the JDK adds value for developers:
• javac: The Java compiler, which compiles Java source code (.java files) into bytecode (.class files).
• java: The Java launcher, which starts a Java application by loading its classes and invoking its main method (essentially a wrapper around the JVM).
• jar: The Java Archiver, for creating and managing JAR (Java Archive) files.
• javadoc: The Java documentation generator, for creating API documentation from source code comments.
• jdb: The Java debugger, for finding and fixing errors in Java programs.
• Other utilities: Such as jconsole, jstack, jmap for monitoring and profiling applications.

Summary of Differences and Relationships

The relationship between these three components can be visualized as nested sets: JDK encompasses JRE, and JRE encompasses JVM.

Java is a widely-used, object-oriented programming language known for its robustness, security, and platform independence. Its comprehensive feature set makes it suitable for developing a broad range of applications, from enterprise systems to mobile devices.

Key Characteristics of Java

• Object-Oriented: Java is based on the object-oriented programming paradigm, supporting concepts like classes, objects, inheritance, polymorphism, abstraction, and encapsulation for modular and reusable code.
• Platform Independent (WORA): Through the Java Virtual Machine (JVM), Java code (bytecode) can run on any device with a JVM installed, regardless of the underlying operating system or hardware. This is encapsulated in the 'Write Once, Run Anywhere' (WORA) principle.
• Simplicity: Designed to be easy to learn and use, Java's syntax is familiar to C++ programmers but removes complex features like explicit pointers and operator overloading, simplifying development.
• Security: Built with security in mind, Java provides a robust security model with features like a bytecode verifier, security manager, and classloader to protect systems from untrusted code.
• Robustness: Java emphasizes reliability with strong memory management (automatic garbage collection), excellent exception handling mechanisms, and rigorous compile-time error checking.
• Multithreading: Supports concurrent execution of multiple parts of a program (threads), enabling the creation of interactive and responsive applications, crucial for GUI programming and web servers.
• High Performance: While initially interpreted, Java uses Just-In-Time (JIT) compilers that convert bytecode into native machine code at runtime, significantly enhancing execution speed.
• Distributed: Java is designed for distributed environments, facilitating the creation of network-centric applications that can run across multiple machines.
• Dynamic: Capable of adapting to evolving environments, Java supports dynamic linking and reflection, allowing for flexible program structures and runtime modifications.

Example: A Simple Java Class

public class MyFeatureDemo {
    public static void main(String[] args) {
        // This program demonstrates a basic Java structure
        String feature = "Platform Independence";
        System.out.println("Hello from Java! One key feature is " + feature + ".");
    }
}

Object-Oriented Programming (OOP) is a programming paradigm that uses 'objects' – instances of classes – to design applications and computer programs. In Java, OOP is a fundamental concept that structures code into modular, reusable, and maintainable units. It is based on several core principles that guide software development.

What is OOP?

Object-Oriented Programming (OOP) is a methodology that organizes software design around data, or objects, rather than functions and logic. An object can be defined as a data field that has unique attributes and behavior. OOP focuses on modeling real-world entities and their interactions, leading to more intuitive and manageable code.

Four Main OOP Concepts

1. Encapsulation

Encapsulation is the bundling of data (attributes) and methods (behaviors) that operate on the data into a single unit, which is a class. It also involves restricting direct access to some of an object's components, meaning the internal state of an object is hidden from the outside world. This is typically achieved using access modifiers like 'private' for data fields and 'public' for getter and setter methods, providing controlled access.

class BankAccount {
    private double balance; // Encapsulated data

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

    // Public method to access balance safely
    public double getBalance() {
        return balance;
    }

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

2. Inheritance

Inheritance is a mechanism in which one class (subclass or child class) acquires the properties and behaviors of another class (superclass or parent class). It promotes code reusability and establishes an 'is-a' relationship between classes. The 'extends' keyword is used in Java to implement inheritance, allowing subclasses to inherit fields and methods from their superclass.

class Vehicle {
    String brand = "Generic";
    public void honk() {
        System.out.println("Vehicle sound!");
    }
}

class Car extends Vehicle { // Car inherits from Vehicle
    String modelName = "Sedan";
}

3. Polymorphism

Polymorphism means 'many forms'. It is the ability of an object to take on many forms. In Java, polymorphism allows methods to do different things depending on the object it is acting upon. It is primarily achieved through method overloading (compile-time polymorphism, where methods have the same name but different parameters) and method overriding (runtime polymorphism, where a subclass provides a specific implementation for a method already defined in its superclass).

class Animal {
    public void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog barks");
    }
}

// Example of usage:
// Animal myDog = new Dog();
// myDog.makeSound(); // Outputs "Dog barks"

4. Abstraction

Abstraction is the concept of hiding the complex implementation details and showing only the essential features of an object. It focuses on 'what' an object does rather than 'how' it does it. In Java, abstraction is achieved using abstract classes and interfaces. Abstract classes can have both abstract (without implementation) and concrete methods, while interfaces (since Java 8, can also have default and static methods) define a contract for classes that implement them.

abstract class Shape {
    abstract double area(); // Abstract method
    public void display() {
        System.out.println("This is a shape.");
    }
}

class Circle extends Shape {
    double radius;
    public Circle(double radius) {
        this.radius = radius;
    }
    @Override
    double area() {
        return Math.PI * radius * radius;
    }
}

Mastering these OOP concepts in Java is crucial for developing robust, scalable, and maintainable software. They provide a structured approach to program design, making code easier to understand, debug, and extend in large-scale applications.

In Java, both abstract classes and interfaces are fundamental concepts used to achieve abstraction, enforce contracts, and promote polymorphism. While they share the goal of enabling abstraction, their design, capabilities, and primary use cases differ significantly. Understanding these distinctions is crucial for designing robust and flexible object-oriented systems.

Key Differences

Abstract Class

An abstract class is a class that cannot be instantiated directly and may contain abstract methods (methods declared without an implementation) as well as concrete methods (methods with an implementation). It serves as a base for subclasses, providing common functionality while requiring specific implementations for its abstract methods. Subclasses must extend an abstract class and implement all its abstract methods, unless the subclass itself is declared abstract.

• Can have both abstract and non-abstract (concrete) methods.
• Can have instance variables (fields) that are final, non-final, static, or non-static.
• Can have constructors, which are called by subclass constructors.
• A class can extend only one abstract class (single inheritance).
• Can define access modifiers (public, protected, private) for its members.
• Can provide a partial implementation of an interface.

Interface

An interface is a blueprint of a class. Prior to Java 8, interfaces could only contain abstract methods and public static final variables. From Java 8 onwards, interfaces can also have default and static methods. From Java 9, private methods are also allowed. Interfaces define a contract that implementing classes must adhere to, enabling polymorphism and achieving multiple inheritance of type.

• Contains only abstract methods (before Java 8); can have default, static, and private methods from Java 8/9 onwards.
• Variables are implicitly public static final.
• Cannot have constructors.
• A class can implement multiple interfaces (multiple inheritance of type).
• All methods (abstract, default, static) are implicitly public.
• Does not provide any implementation for abstract methods (implementation is provided by implementing classes).

Summary Comparison

In Java, method overloading and overriding are two distinct concepts related to polymorphism, allowing methods to exhibit different behaviors in different contexts. Understanding these concepts is crucial for writing flexible and maintainable object-oriented code.

Method Overloading

Method overloading is a feature that allows a class to have multiple methods with the same name but different parameter lists. This is a form of compile-time (or static) polymorphism, as the compiler determines which method to call based on the arguments provided at compile time.

The key characteristic of overloading is that methods share the same name within the same class, but their signatures (the combination of method name and parameter types/order) must be unique. The return type alone is not sufficient to differentiate overloaded methods.

• Different number of parameters:
• Different types of parameters:
• Different order of parameters (if types are different):

class Calculator {
    // Overload 1: Adds two integers
    public int add(int a, int b) {
        return a + b;
    }

    // Overload 2: Adds two doubles
    public double add(double a, double b) {
        return a + b;
    }

    // Overload 3: Adds three integers
    public int add(int a, int b, int c) {
        return a + b + c;
    }
}

public class OverloadingDemo {
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        System.out.println("Sum of two integers: " + calc.add(10, 20));
        System.out.println("Sum of two doubles: " + calc.add(10.5, 20.5));
        System.out.println("Sum of three integers: " + calc.add(10, 20, 30));
    }
}

Method Overriding

Method overriding occurs when a subclass provides a specific implementation for a method that is already defined in its superclass. This is a form of runtime (or dynamic) polymorphism, as the JVM determines which method to execute based on the actual object type at runtime.

For a method to be overridden, the subclass method must have the exact same method signature (name, parameter list, and return type) as the superclass method. The @Override annotation is often used to ensure this and helps catch errors if the signature doesn't match.

• The method in the subclass must have the same name, same parameter list, and same return type as the method in the superclass.
• The access modifier of the overriding method cannot be more restrictive than the overridden method.
• The final and static methods cannot be overridden.
• Constructors cannot be overridden.

class Animal {
    public void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog barks: Woof Woof!");
    }
}

class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Cat meows: Meow!");
    }
}

public class OverridingDemo {
    public static void main(String[] args) {
        Animal myAnimal = new Animal();
        Animal myDog = new Dog(); // Runtime polymorphism
        Animal myCat = new Cat(); // Runtime polymorphism

        myAnimal.makeSound();
        myDog.makeSound(); // Calls Dog's makeSound()
        myCat.makeSound(); // Calls Cat's makeSound()
    }
}

Key Differences: Overloading vs. Overriding

In Java, both `==` and `equals()` are used to compare values, but they operate differently, especially when dealing with objects. Understanding their distinctions is crucial for correct object comparison and avoiding common programming pitfalls.

The `==` Operator

The == operator is primarily used for comparing two values. Its behavior depends on whether the operands are primitive types or object references.

For primitive data types (like int, char, boolean, float, double), == compares their actual values. If the values are identical, it returns true; otherwise, false.

int a = 10;
int b = 10;
int c = 20;

System.out.println(a == b); // true
System.out.println(a == c); // false

For objects, == compares the memory addresses (references) of the objects. It returns true only if both references point to the exact same object in memory. It does not compare the content or state of the objects.

String s1 = new String("hello");
String s2 = new String("hello");
String s3 = s1;

System.out.println(s1 == s2); // false (different objects in memory)
System.out.println(s1 == s3); // true (s1 and s3 refer to the same object)

The `equals()` Method

The equals() method is defined in the Object class, which is the superclass of all Java classes. By default, the equals() method in the Object class behaves exactly like the == operator for objects: it compares object references.

However, most standard Java classes (like String, Integer, Date, etc.) override the equals() method to provide a meaningful comparison of the objects' content or state, rather than just their memory addresses.

class MyObject {
    int value;
    MyObject(int value) { this.value = value; }
}

MyObject obj1 = new MyObject(10);
MyObject obj2 = new MyObject(10);

System.out.println(obj1.equals(obj2)); // false (default equals() compares references)

When equals() is overridden, it typically compares the values of the instance variables to determine if two objects are logically equal.

String str1 = new String("java");
String str2 = new String("java");

System.out.println(str1.equals(str2)); // true (String class overrides equals() to compare content)

Key Differences Summarized

When to Use Which?

• Use == when comparing two primitive values (e.g., int, boolean).
• Use == when you specifically want to check if two object references point to the exact same object in memory.
• Use equals() when you want to compare the content or logical equivalence of two objects. This is the most common use case for objects.
• Always be aware of whether the equals() method has been overridden in the class you are working with. If not overridden, it behaves like ==.

Inheritance is a fundamental principle of Object-Oriented Programming (OOP) in Java. It allows one class to acquire the fields and methods of another class. The main purpose of inheritance is to promote code reusability and establish an "IS-A" relationship between classes, enabling a hierarchical classification of objects.

What is Inheritance?

In Java, when one class inherits another class, the inheriting class (subclass or child class) gains access to the non-private members (fields and methods) of the inherited class (superclass or parent class). This mechanism allows for the creation of new classes that are built upon existing classes, extending their functionality without rewriting the code.

Key Concepts

• Subclass (Child Class): The class that inherits from another class. It can add its own new fields and methods in addition to the inherited ones.
• Superclass (Parent Class): The class whose features are inherited by another class.
• extends Keyword: Used to indicate that a class is inheriting from another class (e.g., class Dog extends Animal).
• super Keyword: Used to refer to the superclass members (methods, fields, and constructors) from within the subclass.

Types of Inheritance Supported by Java

• Single Inheritance: A class inherits from only one direct superclass.
• Multilevel Inheritance: A class inherits from a parent class, which in turn inherits from another parent class (e.g., A -> B -> C).
• Hierarchical Inheritance: Multiple subclasses inherit from a single superclass (e.g., A is inherited by B, C, and D).

Java does not support multiple inheritance for classes (a class cannot extend more than one class directly) to avoid the diamond problem, but it can be achieved indirectly through interfaces.

Example of Inheritance

Let's consider a simple example where a Car class inherits from a Vehicle class. The Vehicle class defines common attributes and behaviors, and the Car class adds specific attributes and behaviors.

Superclass: Vehicle

class Vehicle {
    String brand;
    public Vehicle(String brand) {
        this.brand = brand;
    }
    public void honk() {
        System.out.println("Vehicle sound!");
    }
    public void displayBrand() {
        System.out.println("Brand: " + brand);
    }
}

Subclass: Car

class Car extends Vehicle {
    String model;
    public Car(String brand, String model) {
        super(brand); // Call the superclass constructor
        this.model = model;
    }
    public void drive() {
        System.out.println(brand + " " + model + " is driving.");
    }
    // Method Overriding
    @Override
    public void honk() {
        System.out.println("Car horn sound!");
    }
}

Demonstration

public class Main {
    public static void main(String[] args) {
        Car myCar = new Car("Toyota", "Camry");
        myCar.displayBrand(); // Inherited from Vehicle
        myCar.honk();         // Overridden method in Car
        myCar.drive();        // Specific to Car

        Vehicle genericVehicle = new Vehicle("Generic");
        genericVehicle.honk(); // Vehicle's honk
    }
}

Advantages of Inheritance

• Code Reusability: Common code can be placed in a superclass and reused by multiple subclasses.
• Method Overriding: Allows subclasses to provide specific implementations for methods already defined in their superclass, supporting runtime polymorphism.
• Eliminates Redundancy: Reduces duplicate code, making the application more efficient and easier to maintain.
• Maintainability: Changes in the superclass automatically propagate to subclasses, simplifying updates.
• Extensibility: New functionality can be added to the base class, and all derived classes will inherit it, or new derived classes can be easily created.

Polymorphism, one of the core principles of Object-Oriented Programming (OOP) in Java, allows objects to take on many forms. It enables a single interface to represent different underlying forms or types, promoting flexibility and reusability in code.

What is Polymorphism?

Polymorphism literally means 'many forms'. In Java, it refers to the ability of an object to take on many forms. Specifically, it allows you to define one interface and have multiple implementations. This concept is fundamental to achieving flexibility and extensibility in software design.

Types of Polymorphism

Compile-Time Polymorphism (Static Polymorphism)

Compile-time polymorphism is achieved through method overloading. Method overloading occurs when a class has multiple methods with the same name but different parameters (number of parameters, type of parameters, or order of parameters). The Java compiler determines which overloaded method to call at compile time based on the method signature.

class Calculator {
    int add(int a, int b) {
        return a + b;
    }

    int add(int a, int b, int c) {
        return a + b + c;
    }

    double add(double a, double b) {
        return a + b;
    }
}

public class Demo {
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        System.out.println(calc.add(5, 10));          // Calls int add(int, int)
        System.out.println(calc.add(5, 10, 15));      // Calls int add(int, int, int)
        System.out.println(calc.add(5.5, 10.5));      // Calls double add(double, double)
    }
}

• Achieved by method overloading.
• Methods have the same name but different parameter lists.
• Decision of which method to call is made at compile time.
• Increases the readability and flexibility of the program.

Run-Time Polymorphism (Dynamic Polymorphism)

Run-time polymorphism is achieved through method overriding. Method overriding occurs when a subclass provides a specific implementation for a method that is already defined in its superclass. The decision of which method to call is made at runtime by the Java Virtual Machine (JVM) based on the actual type of the object, not the reference type.

class Animal {
    void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Dog barks");
    }
}

class Cat extends Animal {
    @Override
    void makeSound() {
        System.out.println("Cat meows");
    }
}

public class Demo {
    public static void main(String[] args) {
        Animal myAnimal = new Animal(); // Animal reference and object
        Animal myDog = new Dog();       // Animal reference but Dog object
        Animal myCat = new Cat();       // Animal reference but Cat object

        myAnimal.makeSound(); // Output: Animal makes a sound
        myDog.makeSound();    // Output: Dog barks (Runtime polymorphism)
        myCat.makeSound();    // Output: Cat meows (Runtime polymorphism)
    }
}

• Achieved by method overriding.
• Methods have the same name, same parameters, and are in different classes (parent-child relationship).
• Decision of which method to call is made at runtime.
• Uses 'upcasting' (referring to a subclass object by a superclass reference).

Key Benefits of Polymorphism

• Code Reusability: Write code once and use it for different types of objects.
• Flexibility and Extensibility: Easily add new types without modifying existing code.
• Maintainability: Easier to manage and update code.
• Decoupling: Reduces dependencies between components, improving modularity.
• Dynamic Behavior: Allows objects to behave differently based on their actual type at runtime.

Summary Table: Compile-Time vs. Run-Time Polymorphism

Access modifiers in Java are keywords that set the accessibility (scope) of classes, constructors, methods, and data members (fields). They control the visibility of a member from other classes or packages. Properly using access modifiers is crucial for encapsulation and managing the visibility of components within a Java application.

Understanding Access Modifiers

Access modifiers help to restrict access to classes, methods, and variables from other parts of the code. This is a core concept of encapsulation in object-oriented programming, allowing developers to hide internal implementation details and expose only what is necessary.

Types of Access Modifiers

Java provides four types of access modifiers:

1. Public

The public access modifier specifies that the class, method, or data member is accessible from anywhere. There are no restrictions on its visibility.

public class MyClass {
    public int publicVar = 10;
    public void publicMethod() {
        System.out.println("This is a public method.");
    }
}

2. Protected

The protected access modifier specifies that the class, method, or data member is accessible within the same package and by subclasses (whether they are in the same package or a different package).

package com.example.pack1;

public class Parent {
    protected int protectedVar = 20;
    protected void protectedMethod() {
        System.out.println("This is a protected method.");
    }
}

// In a different package, a subclass can access protected members
package com.example.pack2;
import com.example.pack1.Parent;

public class Child extends Parent {
    public void accessProtected() {
        System.out.println(protectedVar); // Accessible
        protectedMethod();             // Accessible
    }
}

3. Default (Package-Private)

When no access modifier is specified for a class, method, or data member, it is considered default (or package-private). This means it is only accessible within the same package. It cannot be accessed from outside the package.

package com.example.pack1;

class DefaultClass {
    int defaultVar = 30; // default access
    void defaultMethod() { // default access
        System.out.println("This is a default method.");
    }
}

// In the same package, can access
public class AnotherClassInPack1 {
    public void useDefault() {
        DefaultClass obj = new DefaultClass();
        System.out.println(obj.defaultVar); // Accessible
        obj.defaultMethod();             // Accessible
    }
}

// In a different package, cannot access
// package com.example.pack2;
// import com.example.pack1.DefaultClass;
// public class SomeOtherClass {
//    public void tryAccess() {
//        DefaultClass obj = new DefaultClass(); // Compile-time error: DefaultClass is not public
//    }
// }

4. Private

The private access modifier specifies that the method or data member is only accessible within the class in which it is declared. It is the most restrictive modifier and promotes strong encapsulation.

public class MyPrivateClass {
    private int privateVar = 40;
    private void privateMethod() {
        System.out.println("This is a private method.");
    }

    public void accessPrivate() {
        System.out.println(privateVar);   // Accessible within the same class
        privateMethod();               // Accessible within the same class
    }
}

Access Modifiers Summary Table

Best Practices

• Use private for fields to enforce encapsulation. Access them via public getter/setter methods.
• Use public for methods that define the public API of a class.
• Use protected when you want to allow subclasses to extend or modify behavior, but prevent direct access from unrelated classes.
• Use default (package-private) for helper classes or methods that are only relevant within a specific package, keeping them hidden from the rest of the application.

Choosing the right access modifier is critical for designing robust, maintainable, and secure Java applications. It directly impacts the object-oriented principles of encapsulation and modularity.

Encapsulation is one of the four fundamental pillars of Object-Oriented Programming (OOP), alongside inheritance, polymorphism, and abstraction. It plays a crucial role in improving code maintainability, security, and reusability.

What is Encapsulation?

Encapsulation is the mechanism of wrapping the data (variables) and code acting on the data (methods) together as a single unit. It involves bundling the data with the methods that operate on that data, and restricting direct access to some of an object's components. This means that the internal representation of an object is hidden from the outside. Only the object itself can access and modify its internal state through a public interface (methods).

How is Encapsulation Achieved in Java?

In Java, encapsulation is primarily achieved through the use of access modifiers and getter/setter methods. By making the instance variables private, their direct access from outside the class is prevented. Public getter methods are then provided to read the values of these variables, and public setter methods are provided to modify them. This approach allows controlled access to the internal state of an object.

• Declare the instance variables of a class as private. This makes them inaccessible directly from outside the class.
• Provide public 'getter' methods (also known as accessors) to allow read-only access to the private variables.
• Provide public 'setter' methods (also known as mutators) to allow controlled modification of the private variables. These methods can include validation logic to ensure data integrity.

Example

public class BankAccount {
    private String accountNumber;
    private double balance;

    public BankAccount(String accountNumber, double initialBalance) {
        this.accountNumber = accountNumber;
        setBalance(initialBalance); // Use setter for initial validation
    }

    // Getter for accountNumber
    public String getAccountNumber() {
        return accountNumber;
    }

    // Getter for balance
    public double getBalance() {
        return balance;
    }

    // Setter for balance with validation
    public void setBalance(double newBalance) {
        if (newBalance >= 0) {
            this.balance = newBalance;
        } else {
            System.out.println("Balance cannot be negative.");
        }
    }

    public void deposit(double amount) {
        if (amount > 0) {
            this.balance += amount;
        } else {
            System.out.println("Deposit amount must be positive.");
        }
    }

    public void withdraw(double amount) {
        if (amount > 0 && this.balance >= amount) {
            this.balance -= amount;
        } else if (amount <= 0) {
            System.out.println("Withdrawal amount must be positive.");
        } else {
            System.out.println("Insufficient balance.");
        }
    }
}

public class BankApp {
    public static void main(String[] args) {
        BankAccount myAccount = new BankAccount("12345", 1000.0);

        System.out.println("Account Number: " + myAccount.getAccountNumber());
        System.out.println("Initial Balance: " + myAccount.getBalance());

        myAccount.deposit(200.0);
        System.out.println("Balance after deposit: " + myAccount.getBalance());

        myAccount.withdraw(300.0);
        System.out.println("Balance after withdrawal: " + myAccount.getBalance());

        myAccount.setBalance(-50.0); // Attempt to set invalid balance
        System.out.println("Balance after invalid set: " + myAccount.getBalance());
    }
}

Benefits of Encapsulation

• Data Hiding: It restricts direct access to data, preventing unauthorized or incorrect modifications.
• Flexibility and Maintainability: The internal implementation of a class can be changed without affecting the code that uses the class, as long as the public interface (getter/setter methods) remains consistent.
• Modularity: Encapsulated classes are easier to understand, test, and debug as they have well-defined interfaces and responsibilities.
• Increased Security: By controlling how data is accessed and modified, encapsulation helps in preventing data corruption and ensuring data integrity through validation logic in setter methods.
• Reusability: Well-encapsulated components are easier to reuse in different parts of an application or in other projects.