Java and C Programming Quiz

In Java, synchronized methods can be overridden to be non-synchronized (and vice versa) because synchronization is a property of the implementation, not the method signature. Additionally, while a thread holds a lock on a synchronized method, other threads can freely access non-synchronized methods.

In C, adjacent string literals are concatenated during compilation. 'Kumar' 'Singh' becomes 'KumarSingh', and 'Bittoo' 'Roshan' becomes 'BittooRoshan'. The array contains: 'Ritesh', 'KumarSingh', 'Happy', 'BittooRoshan', 'Go' = 5 elements.

To free a linked list, you must save the next pointer BEFORE freeing the current node, then advance. Option B: 'struct node m = n; n = n->next; free(m);' correctly copies the pointer, advances n to next, then frees the original node. Option A frees next instead of current (memory leak), Option C frees before reading next (use-after-free crash), Option D frees before advancing (memory leak).

realloc expands existing allocation. Option A correctly uses realloc to resize ptr for 10 elements. Option B is missing assignment (memory leak), Option C uses malloc and adds to pointer (wrong), Option D only allocates 9 elements. Note: question uses 'ptr' in text but 'p' as variable name - minor inconsistency.

Sockets provide an interface for programming at the Transport layer of the OSI model, enabling applications to use TCP or UDP protocols for network communication. The Application layer uses socket services but doesn't define the socket interface itself.

Socket APIs are standardized across programming languages. A socket server written in Java can communicate with a client written in Python or C because they use the same underlying network protocols (TCP/IP) and socket interface standards defined by the operating system.

ServerSocket is the correct class for implementing TCP servers in Java, and it is located in the java.net package, not java.util. Option B incorrectly places ServerSocket in java.util, while options A and C reference a non-existent 'Server' class.

When a client attempts to connect to a server that is not running, Java throws a ConnectException. This is a runtime exception indicating the connection was refused because no server is listening at the specified host and port.

The getLocalPort() method returns the local port number to which the socket is bound. On the server side, this reveals the port assigned to the ServerSocket. On the client side, it shows the ephemeral port used for the connection. Options B and D are not valid methods or approaches for port discovery.

Marker interfaces have no methods and serve only to mark classes for special treatment by the JVM or compiler. Serializable, Remote, and Cloneable are marker interfaces, while List is a regular interface with multiple methods defining collection operations like add(), get(), and remove().

Java threads use priority-based scheduling where each thread has a priority level (1-10). The JVM scheduler attempts to run higher-priority threads before lower-priority ones, though the exact mapping to OS-level scheduling is platform-dependent and implementation-specific.

The transient modifier in Java tells the JVM to skip that field during serialization - it won't be written to the persistent stream. This is useful for fields that can be recalculated, are derived from other data, contain sensitive information, or reference non-serializable objects.

Hashtable extends the abstract Dictionary class, which was part of Java's original collection framework in version 1.0. While Dictionary is now deprecated and Hashtable implements the Map interface (since Java 2), Dictionary remains its direct superclass in the class hierarchy.

When a Java program starts, the JVM creates several threads beyond the main thread, including garbage collector threads and possibly other JVM-internal threads for monitoring, JIT compilation, and other runtime services. The main thread is just one of many threads running from the beginning.

HashMap does not guarantee any specific order of elements, and the order can change over time due to rehashing when the map resizes or when bucket chains are reorganized. ArrayList preserves insertion order, Stack maintains LIFO order, and Queue implementations follow FIFO order consistently.

Iterators in Java are 'fail-fast' - they throw ConcurrentModificationException if the collection is modified during iteration (except through the iterator's own remove method). The iterator does not automatically update to reflect changes made directly to the collection during traversal.

The %S format specifier in Java's Formatter class converts the string to uppercase. The format() method modifies the Formatter's internal content, and println(f) outputs the formatted result 'HELLO123'.

Float.equals(Double) returns false because they're different types (Float vs Double). s1==s2 returns false because they're different StringBuffer objects. s1.equals(s2) returns true because StringBuffer.equals() compares content. Result: 'falsefalsetrue'.