Java Developer Interview Preparation Course

Java is not 100 percent object oriented because it uses primitive types wrapped by wrapper classes to become objects, so not everything revolves around objects.

Explore whether Java passes primitives by value and object references by value, with examples showing copying the value versus modifying the original object through the copied reference.

Learn covariant return types in Java, where after Java 5 an overriding method can return a subtype of the parent return type, illustrated with Object, String, Animal, Labrador, and Frog.

Explore the Java equals and hash code contract, implement equals, override hashCode, and understand shallow versus deep comparison for reliable map behavior.

Learn why pointers are not used in Java, as memory allocation is managed by the JVM and direct memory access is discouraged to preserve safety and simplicity.

Explore how the JIT compiler in Java converts bytecode into machine code at runtime to boost performance, while the interpreter translates bytecode line by line.

Understand why strings are immutable in Java, emphasizing safe sharing of string references and the creation of new string objects on modification to protect security.

Marker interfaces are empty, having no data members or functions, used in Java to convey metadata to the compiler.

Discover why private and static methods cannot be overridden in Java, how method hiding works with the same name and arguments, and referencing such methods with the class name.

Examine whether the finally block always executes in Java, and identify two cases where it does not: when the system crashes or when System.exit is called.

Learn how a singleton in Java is built with a private static instance, private constructor, and a getInstance method, then examine breaking it via reflection, serialization, and cloning.

Understand the Java object class and its core methods: clone copies objects, equals defaults to reference equality, finalize runs before garbage collection, and toString returns the object's string representation.

Learn six steps to make a class immutable in Java by declaring the class final, fields private and final, and always cloning or copying objects rather than returning real references.

Learn how to implement a singleton class in Java by using a private constructor, a private static instance, and a lazy getInstance method to ensure a single object.

Explore the Java collection hierarchy: collection interface with list and set, and map as a separate interface. Compare list's order and duplicates, set's uniqueness, and map's key-value pairs.

Focus on java list interface implementations: arraylist, linkedlist, vector, and stack; compare non-synchronous arraylist growth by 50 percent, vector doubling, insertion order, and synchronization differences.

Learn about the set interface in Java, including hashset, linkedhashset, and sorted set implementations, and how they ensure unique elements and control insertion or ascending order.

Examine Java queue concepts, including priority queue behavior where the highest priority item is removed first and insertion order is not preserved, and the idea of a doubly ended queue.

Explore Java map interface, comparing hash map and sorted map. Learn how hash maps are non synchronized with nullable values, while sorted maps disallow null keys and maintain ascending order.

Examine why the map interface does not extend the collection interface, as maps store key-value pairs with a dual access mechanism, an integral part of the Java collection framework.

Contrast fail fast and fail safe iterators in Java, showing how fail fast throws concurrent modification exception on structural changes, while fail safe uses a clone and avoids the exception.

Understand blocking queue from the concurrent package, a thread-safe queue that lets multiple threads put and take elements safely, blocking when full to prevent more inserts.

Differentiate synchronized and concurrent collections by performance and thread safety. Divide across segments in concurrent collections to enable parallel operations, while synchronized collections like a hash map are slower.

Learn how a hash map uses a hash function to map keys to bucket indices, storing key-value pairs in an entry object, with put/get and collision handling via linked lists.