Object-Oriented Programming

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.

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.

The terminology is: the overridden method is in the PARENT class (the original version being replaced), and the overriding method is in the CHILD class (the new version). The statement reverses this correctly, so False is the right answer. You're overriding the parent's method from the child.

You CAN override a non-abstract method as abstract in a subclass. This makes the subclass abstract and forces subclasses of it to provide an implementation. It's a valid technique when you want to require subclasses to reimplement a method, even if the parent provided a concrete version.

You cannot reduce visibility when overriding - private is more restrictive than public. Java's overriding rules require the subclass method to have at least the same access level as the parent. Changing public void doIt() to private void doIt() violates this, so the code is illegal.

The main method must be static so the JVM can invoke it without creating an instance of the class (no object exists at program startup). It must be public so the JVM, which is external to your class, can access it. Static methods belong to the class itself, not instances, and public allows unrestricted access from outside.

In Java, access modifiers restrict visibility in this order from most to least restrictive: private (only same class), package/default (same package), protected (same package + subclasses), public (everywhere). Since package-level access allows access only within the same package while protected additionally allows subclasses outside the package to access the member, package is indeed more restrictive than protected.

Mapper classes in iBATIS are Java classes that use SQL Mapping Annotations to define database operations. This annotation-based approach can replace XML configuration, providing a more concise and type-safe way to map SQL statements to Java methods.

All variables declared in a Java interface are implicitly public, static, and final. They become compile-time constants that must be initialized and cannot be modified. This is a fundamental Java language rule for interfaces.

In Java, all interface members are implicitly public. Conversely, an abstract class can declare members with any access modifier, including private and protected.

Abstract classes in Java CAN have constructors. While they cannot be instantiated directly, their constructors are called when a subclass is instantiated using super(). This allows initialization of inherited fields and setup logic.

Classes IMPLEMENT interfaces, not extend them. Option B claims classes extend interfaces, which is false - you use 'implements' keyword for interfaces. Classes extend other classes, and interfaces extend other interfaces.

When passing objects to remote methods in Java RMI, objects are passed by serialized copy (deep copy). This serialization process creates an object copy on the receiving side. By reference is not possible across JVM boundaries.

Java allows marker interfaces - interfaces with no methods. They are used to mark classes for special treatment by the JVM or compiler (e.g., Serializable, Cloneable). An empty interface declaration is syntactically valid and serves this purpose.