Author: tech.ctoi.in

The `final` keyword in Java is used to make variables, methods, and classes unchangeable. A final variable cannot be reassigned, a final method cannot be overridden, and a final class cannot be subclassed. This ensures stability in your code, making it more predictable and secure.

Here’s an example using the `final` keyword with variables:

public class FinalExample {
    public static void main(String[] args) {
        final int MAX_VALUE = 100;
        System.out.println(MAX_VALUE);
    }
}
            

In this code, the `MAX_VALUE` variable is marked as `final`, meaning its value cannot be changed. The final keyword is often used in constants and to enforce immutability in Java, improving code clarity and preventing unintended behavior.

The `volatile` keyword in Java ensures visibility of changes to a variable across threads. It prevents threads from caching the value, ensuring they always read from main memory. While `volatile` guarantees visibility, it doesn’t provide atomicity, so it is often used with simple read/write operations in multi-threaded environments.

Here’s an example:

public class VolatileExample {
    private static volatile boolean flag = true;

    public static void main(String[] args) {
        new Thread(() -> {
            while (flag) {
                // Loop until flag is changed
            }
            System.out.println("Flag changed");
        }).start();

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        flag = false;
    }
}
            

In this code, the `volatile` keyword ensures that changes to `flag` are immediately visible to other threads. Use it wisely, as it impacts performance when used with complex operations.

Method overloading and overriding are two important concepts in Java that involve redefining methods. Overloading occurs when multiple methods in the same class share the same name but different parameters. Overriding occurs when a subclass redefines a method from its superclass with the same signature.

Here’s an example of both:

class Parent {
    void show() {
        System.out.println("Parent show");
    }
}

class Child extends Parent {
    @Override
    void show() {
        System.out.println("Child show");
    }

    void show(int a) {
        System.out.println("Overloaded show: " + a);
    }
}
            

In this example, the `Child` class overrides the `show()` method from `Parent` and overloads it with a new parameter. Overloading improves code flexibility, while overriding enables polymorphism.

Java’s `HashMap` is an efficient way to store key-value pairs. It uses hashing to quickly find values based on keys. The `hashCode()` method generates a hash for the key, and the value is stored in a specific bucket. Understanding hashing and collision resolution is crucial for optimizing performance.

Here’s a basic example of using `HashMap`:

import java.util.HashMap;

public class HashMapExample {
    public static void main(String[] args) {
        HashMap map = new HashMap<>();
        map.put("Apple", 1);
        map.put("Banana", 2);
        System.out.println(map.get("Apple"));
    }
}
            

In this example, `HashMap` allows efficient retrieval of values based on keys. However, understanding how hash collisions are resolved using chaining or open addressing is key to improving HashMap performance, especially with large datasets.

Java’s `Optional` class helps prevent `NullPointerException` by encapsulating potential null values. Instead of returning null, `Optional` returns an object that may or may not contain a value. This promotes safe programming practices and reduces runtime errors caused by nulls.

Here’s how you can use `Optional`:

import java.util.Optional;

public class OptionalExample {
    public static void main(String[] args) {
        Optional optionalValue = Optional.ofNullable(null);
        System.out.println(optionalValue.orElse("Default Value"));
    }
}
            

In this example, the `orElse` method provides a default value if `optionalValue` is null. Using `Optional` makes your code more robust by explicitly handling the possibility of null values, improving overall program stability.