In Java, constructors are special methods used to initialize objects. They have the same name as the class they belong to, making option 1 ("class") the correct choice. Constructors cannot have a return type.

The "%" (modulo) operator in Java is used to divide the left-hand operand by the right-hand operand and returns the remainder. For example, "10 % 3" returns 1 because 10 divided by 3 leaves a remainder of 1. The other operators perform different arithmetic operations.

In Java, when you create a HashMap without specifying an initial capacity, it defaults to an initial capacity of 16. This means that initially, the HashMap can accommodate 16 key-value pairs. However, as the number of entries increases and reaches a certain threshold (usually 75% of the capacity), the HashMap automatically resizes itself, doubling its capacity. So, option (a) is correct, with the explanation that it can ideally accommodate 16 entries initially but will resize when necessary.

When a method is overridden in the child class, the version of the method in the child class is called when the method is invoked on an instance of the child class. This is known as method overriding and is a fundamental concept in object-oriented programming.

To ensure thread safety in a multithreaded application, you can use synchronized methods for read and write operations on the shared User object. This prevents multiple threads from accessing and modifying the object simultaneously, avoiding data corruption and race conditions. The other options do not provide effective thread safety mechanisms.

The lock() method of the Lock interface is used to acquire the lock. It blocks until the lock is available and then acquires it. The unlock() method is used to release the lock. The acquire() and tryLock() methods are not part of the standard Lock interface in Java.

When the join() method is called on a thread in Java, the calling thread will wait for the specified thread to finish its execution. This is often used to ensure that a thread completes its task before the calling thread proceeds. It's a mechanism for thread synchronization.

In Java, Lambda expressions benefit from type inference, which allows the compiler to automatically infer the parameter types from the context and the Lambda body. This feature makes Lambda expressions concise and expressive. It helps reduce the verbosity of code by eliminating the need for explicit type declarations in most cases. Understanding how type inference works with Lambdas is essential for writing clean and readable code when using functional programming techniques in Java.

Lambda expressions eliminate the need for anonymous inner classes. Before lambda expressions were introduced in Java, anonymous inner classes were used to implement single-method interfaces, like Runnable or ActionListener. Lambda expressions provide a more concise and expressive way to define such implementations, reducing the verbosity of code.

It uses type conversion to promote one of the operands to the type of the other operand, and then performs the operation. For example, if you add a string and an int, the int is converted to a string, and string concatenation is performed. If you add two integers, normal addition is performed.