Java and Hibernate Programming Quiz

A final class is restricted from being inherited or subclassed (A). An abstract class cannot be instantiated directly using the new keyword (B). However, abstract classes can and are intended to be inherited by concrete subclasses (C), making all statements true.

IS-A relationship represents inheritance where a subclass 'is a' type of its superclass. For example, a Car IS-A Vehicle. Polymorphism enables method flexibility, abstraction hides complexity, and modularization divides systems into components.

Hibernate requires a no-argument constructor to instantiate objects via reflection when retrieving data from the database. While identifier properties and accessors are best practices, they are not mandatory for basic POJO functionality.

Hibernate's default_entity_mode is set to 'pojo' by default, which means it works with Plain Old Java Objects as the default entity representation mode for mapping.

When default_entity_mode is set to 'dynamic-map', the entity-name attribute must be defined instead of name. This is because dynamic-map mode uses entity names as keys in maps rather than class names.

The batch-size attribute specifies the batch size for fetching instances by identifier. This allows Hibernate to load multiple instances in a single batch when retrieving them by ID, improving performance.

In Hibernate XML configuration files, the <property> element maps a Java class field to a table column. The name attribute represents the property name in the Java class, which makes the syntax valid even if it violates standard Java naming conventions.

Hibernate can be configured programmatically using Java code, via a hibernate.properties file, or using hibernate.cfg.xml. All three methods are valid approaches depending on the project requirements.

The tag in hibernate.cfg.xml is used to add HBM XML resources for the current session factory. Each mapping resource points to an XML file containing entity mappings.

Hibernate supports three inheritance mapping strategies: Table per Concrete Class (each class gets its own table), Table per Subclass (shared parent table with separate subclass tables), and Table per Class Hierarchy (single table for entire hierarchy).

Bitwise operators in Java do not all share the same precedence level. For instance, bitwise AND (&) has a higher precedence than bitwise exclusive OR (^), which in turn has a higher precedence than bitwise inclusive OR (|).

When a subclass inherits from an abstract class, it must either provide concrete implementations for all inherited abstract methods or be declared as an abstract class itself. Leaving any abstract method unimplemented makes the subclass abstract.

A constructor's first statement must be either a call to super() or this(), but if you don't write either, the compiler automatically inserts super() as the first statement. So while a super constructor is always invoked, it doesn't have to be explicitly written by you.

Java arrays are statically typed - an array is declared to hold a specific type (like int[], String[]) and cannot hold mixed types. To store different types, you would need an array of Object or use a Collection.

The package statement, if present, must be the first non-comment statement in a Java source file. This rule ensures the package declaration appears before any imports or class declarations.

Interface methods are implicitly public. When a class implements an interface method, it cannot reduce visibility - it must remain public. Making it private, protected, or package-private would violate the interface contract.

Whether a class can be inherited depends on its access modifier. If the class is private or has no modifier (package-private), classes outside that package cannot inherit from it. If the class is public, it can be inherited by any class anywhere.

A final class cannot be subclassed, so all its methods are effectively non-overridable. While 'implicitly final' in the practical sense (they cannot be overridden), the methods themselves don't have the final keyword applied to them individually.