Custom exceptions in Java allow you to create specific error types that are more meaningful for your application. You can define your own exception by extending the `Exception` class for checked exceptions or `RuntimeException` for unchecked exceptions.

Here’s how you can create a custom exception:

class InvalidAgeException extends Exception {
    public InvalidAgeException(String message) {
        super(message);
    }
}

public class TestCustomException {
    public static void main(String[] args) {
        try {
            checkAge(15);
        } catch (InvalidAgeException e) {
            System.out.println(e.getMessage());
        }
    }

    static void checkAge(int age) throws InvalidAgeException {
        if (age < 18) {
            throw new InvalidAgeException("Age is not valid");
        }
    }
}
            

This example creates a custom exception `InvalidAgeException` that is thrown when the age is less than 18. Custom exceptions improve code readability and help in handling specific error cases more effectively.

Creating a thread-safe singleton in Java ensures only one instance of a class is created. The Singleton pattern is useful when you want to control object creation. To make it thread-safe, you can use synchronized blocks or the Bill Pugh Singleton Design. Double-checked locking is another way to avoid performance issues.

Here’s an example using double-checked locking:

public class Singleton {
    private static volatile Singleton instance;

    private Singleton() { }

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}
            

This method ensures the instance is created only when needed and avoids locking every time. It also prevents multiple threads from creating separate instances, ensuring thread safety. Understanding these techniques can help you implement a reliable singleton.

Java Generics provide type safety and reusability by allowing you to define classes, methods, and interfaces with placeholder types. This avoids casting and helps catch errors at compile time. Generics make your code flexible and reusable without sacrificing type safety.

Here’s an example of a generic method:

public class GenericExample {
    public static  void printArray(T[] array) {
        for (T element : array) {
            System.out.println(element);
        }
    }

    public static void main(String[] args) {
        Integer[] intArray = {1, 2, 3};
        printArray(intArray);
    }
}
            

In this example, the method `printArray` can handle arrays of any type. Generics improve code reusability and ensure that type errors are caught during compilation, which boosts code quality.

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.

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.

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.

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.

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.