Java 2 Interview Questions and Answers for 7 years experience

1. What is the difference between `==` and `.equals()` in Java?

   • Answer: `==` compares memory addresses (for objects) or primitive values. `.equals()` compares the content of objects. For primitive types, they behave the same. For objects, you need to override `.equals()` to define meaningful content comparison, otherwise it defaults to comparing memory addresses. Overriding `.equals()` often necessitates overriding `hashCode()` as well to maintain consistency with hash-based collections.

2. Explain the concept of garbage collection in Java.

   • Answer: Garbage collection is an automatic memory management process in Java. The JVM identifies objects that are no longer reachable by the program and reclaims the memory they occupy. This prevents memory leaks. Different garbage collection algorithms exist (e.g., mark-and-sweep, generational GC), each with its trade-offs in performance and memory usage.

3. What are the different types of inner classes in Java?

   • Answer: Java supports several types of inner classes: nested classes (static inner classes), member inner classes (non-static inner classes), local inner classes (declared within a method), and anonymous inner classes (declared and instantiated in a single statement). Each type has its own access restrictions and relationship with the enclosing class.

4. What is the difference between `ArrayList` and `LinkedList` in Java?

   • Answer: `ArrayList` uses a dynamic array for storage, providing fast random access (O(1)) but slower insertions and deletions (O(n)). `LinkedList` uses a doubly linked list, offering fast insertions and deletions (O(1)) at any position but slower random access (O(n)). The choice depends on the application's access patterns.

5. Explain the concept of polymorphism in Java.

   • Answer: Polymorphism (meaning "many forms") allows objects of different classes to be treated as objects of a common type. This is achieved through inheritance and interfaces. It enables flexibility and extensibility in code by allowing different objects to respond to the same method call in their own specific way. This is crucial for using interfaces and abstract classes.

6. What are Java Generics? Explain their benefits.

   • Answer: Generics allow type parameters to be used with classes, interfaces, and methods. This improves type safety and avoids casting exceptions at runtime. Benefits include enhanced code readability, compile-time type checking, and reduced code duplication (through reusable code).

7. What is the difference between `HashMap` and `TreeMap` in Java?

   • Answer: `HashMap` stores key-value pairs in a hash table, providing fast average-case access (O(1)) but unordered iteration. `TreeMap` stores key-value pairs in a red-black tree, offering sorted iteration (by key) but slower average-case access (O(log n)).

8. Explain Exception Handling in Java. What are checked and unchecked exceptions?

   • Answer: Exception handling in Java uses `try`, `catch`, and `finally` blocks to handle runtime errors. Checked exceptions (subclasses of `Exception`, excluding `RuntimeException`) must be declared in method signatures or handled with `try-catch`. Unchecked exceptions (subclasses of `RuntimeException`) do not need to be declared and represent programming errors.

9. What is the purpose of the `finally` block in a `try-catch` statement?

   • Answer: The `finally` block always executes, regardless of whether an exception is thrown or caught. It's used for cleanup actions like closing files or releasing resources, ensuring they are released even if errors occur.

Thank you for reading our blog post on 'Java 2 Interview Questions and Answers for 7 years experience'.We hope you found it informative and useful.Stay tuned for more insightful content!