Java Programming Fundamentals

In exception handling hierarchies, a catch block can catch exceptions of its declared type or any subclass of that type due to polymorphism. If you catch Exception ( superclass), it will also catch IOException, SQLException, etc. (subclasses). This is a fundamental principle of polymorphic exception handling in object-oriented programming.

A method can declare throwing multiple exceptions using a comma-separated list in the method signature. For example: 'void myMethod() throws IOException, SQLException, CustomException {...}' is valid syntax. The throws clause can include any number of checked exceptions that the method might throw but not handle internally.

In Java, a class cannot be both final and abstract because these modifiers have contradictory purposes. 'final' prevents inheritance (no subclasses allowed), while 'abstract' requires inheritance (must be subclassed to be instantiated). This creates an oxymoron - a class that both requires and forbids subclasses simultaneously. The compiler will reject this combination.

Abstract classes can and often do have constructors. Although you cannot instantiate an abstract class directly, its constructor is called when a concrete subclass is instantiated using super() in the subclass constructor. This is useful for initializing fields defined in the abstract class that are common to all subclasses. The constructor executes before the subclass constructor's code.

In Java, it is syntactically legal to access a static member or method using an instance variable of that class, although it is discouraged as a bad practice because static members belong to the class itself.

The for loop syntax for(i=l; k< 5; j++){}; is valid in C-like languages. The initialization, condition, and increment can use different variables - this will compile even though the logic is unusual (i is initialized, k is checked, j is incremented). The semicolon after the empty body is also valid syntax.

EJB (Enterprise Java Bean) is a server-side Java API for building distributed enterprise applications. It provides a component architecture for developing and deploying business logic in Java EE environments.

Non-static inner classes are tied to instances of their outer class. You cannot create an inner class instance without first having an outer class instance, as the inner class implicitly holds a reference to its enclosing object.

Method B only needs to declare the exception if it doesn't catch it. If B uses try-catch to handle A's exception, no declaration is needed. The rule applies only when propagating exceptions up the call stack.

Java allows implicit narrowing conversion from int literal to float when the value is within float's range. The integer 2 is automatically converted to 2.0f at compile-time, making this statement perfectly legal.

Static variables belong to the class and are shared across all instances. They are not implicitly final - their value can be modified. The 'final' keyword must be explicitly added to make a static variable constant.