Programming Languages - Java and C Fundamentals

If a class does not explicitly define any constructors, the Java compiler automatically provides a default, no-argument constructor with the same access modifier as the class.

In Java, constructors can be overloaded (multiple constructors with different signatures in the same class), but they cannot be overridden because they are not inherited by subclasses.

The default constructor's access modifier IS the same as the class modifier. If the class is public, the default constructor is public. If the class has package-private access, the default constructor is also package-private. This ensures the constructor is accessible wherever the class itself is accessible.

When a constructor uses super() to call the parent class constructor, it MUST be the first statement. This ensures the parent class is properly initialized before the child class does its own initialization. The compiler enforces this rule and will complain if super() is not first.

In Java, the extends keyword is used for both class inheritance and interface inheritance. A class can extend another class, and an interface can extend another interface, but they cannot be mixed - a class implements an interface using the implements keyword, not extends.

Variable shadowing occurs when a variable declared within a specific scope has the same name as a variable in an outer scope. The local variable takes precedence, hiding the instance variable within that scope.

In Java and similar OO languages, an interface can extend one or more interfaces (multiple inheritance is allowed for interfaces), but cannot extend classes. Classes implement interfaces. Option C is incomplete, and 'All of the above' is incorrect because interfaces don't extend classes.

Cohesion is the OO principle that a class should have a single, well-focused purpose or responsibility. High cohesion means a class does one thing well. Hiding implementation details is encapsulation (information hiding), and knowing other classes only through APIs is also related to encapsulation and loose coupling, not cohesion.

If Class A methods use public methods in Class B, this indicates Class B has weak encapsulation because its internal methods are exposed and tightly coupled to other classes. Class A using variables in Class C violates encapsulation but the question asks what is 'most likely true', and Class B's weak encapsulation is directly stated. Class D has no relationship described, so its cohesion cannot be determined.

The code compiles with a warning because main() has no explicit return type (assumed int in pre-C99 standards). The printf statement is valid and the program runs correctly, printing "hello world" to stdout. Modern compilers may warn about implicit int declaration or missing return statement, but these are warnings, not errors.

This code fails to compile because the #include<stdio.h> directive is missing the closing angle bracket. The correct syntax is #include<stdio.h> with both < and > brackets. This syntax error prevents compilation entirely. Additionally, conio.h and string.h are non-standard/unnecessary but the missing bracket is the definitive compilation error.

The code uses nested loops where the outer loop runs from i=0 to i<5, and the inner loop runs from j=0 to j<i, printing '1\t' each time. For i=0: nothing prints. For i=1: one '1'. For i=2: two '1's. For i=3: three '1's. For i=4: four '1's. This creates a triangular pattern of 1s increasing from 1 to 4 per row, matching the stated output.

The nested loop structure has a definite termination condition (i<5) and no modification to loop variables that would prevent termination. The outer loop runs i from 0 to 4, the inner loop has a fixed range, and both loops increment properly. This code will definitely terminate after a finite number of iterations - it does NOT go into an infinite loop.

The inner loop condition j=i; j<=0; j-- is problematic. When i=0, j starts at 0, condition is true, j becomes -1, condition fails immediately. When i=1 or higher, j starts >=1, condition j<=0 is false immediately, so the inner loop never executes. The code runs and terminates normally - it does NOT enter an infinite loop. The claimed answer is correct.

The outer loop runs i from 0 to 5 (inclusive). The inner loop runs j from 0 to i (exclusive), printing '1\t' each time. For i=0: prints nothing. For i=1: prints one '1'. For i=2: prints two '1's. For i=3: prints three '1's. For i=4: prints four '1's. For i=5: prints five '1's. The output matches the stated pattern of increasing 1s from 1 to 5 per row.

The code attempts to print an integer variable i using the format specifier %f, which expects a floating-point value. While this type mismatch causes undefined behavior at runtime, most C compilers will issue a warning and still successfully compile the code.

In modern C standards, omitting the return type of main defaults to int, and omitting a return statement at the end of main is allowed. However, in older compilers, this code compiles with a warning about the missing return type but still runs successfully.

In Java, static methods are associated with the class rather than instance objects and cannot be overridden. Attempting to override a static method with a non-static method in a subclass results in a compilation error.

In Java, the synchronized modifier is not part of a method's signature. This means a subclass can override a synchronized method and choose whether to keep or remove the synchronized keyword. The synchronization is an implementation detail, not a contract that must be preserved.