Object-Oriented Programming

The output is null, not 'tcs' or 'UX'. The testPoly() method returns a TestPolymorphism2 object, but the return value is discarded - it's not assigned to TSuper. TSuper.name remains null because the superclass's name field was never initialized (the subclass's local name is different).

Since the variable p is declared as static in the superclass TestSup, a single shared copy of p exists for both classes and all instances. Modifying p through any reference (TP, TS, TSP) updates this single value. The last assignment sets p to 500, so all print statements output 500.

Compiler error occurs because p1 is not declared - 'p1 = TSU.TestPoly(11, 9.0, 10);' lacks a type declaration. Should be 'double p1 = ...'. The code has nothing to do with polymorphism behavior - it's a simple syntax error.

In Java, static variables are NOT polymorphic - they are bound to the reference type, not the actual object type. When we assign TSP.p = 500, TSP is declared as TestSupe, so it sets TestSupe.p to 500. Similarly, TP.p = 400 sets TestPoly1.p to 400. When printing static variables using the class name (TestSupe.p or TestPoly1.p), we access the variable for that specific class. This is static variable hiding, not overriding.

In PHP 5, class constructors must be declared with the 'function' keyword before __construct() or the class-name method. The constructor is a special method that's automatically called when an object is instantiated, but it still requires standard function declaration syntax.

Polymorphism allows the same code to work with different types of objects that share a common interface or base class. This enables writing more flexible and reusable code. Options B and C describe benefits unrelated to polymorphism. Option D is incorrect - polymorphism is a core OOP benefit, not something to avoid.

A class is a template - you can create as many objects (instances) of a class as your program needs, limited only by available memory. There's no built-in limit of one object per class, constructor, or program. Objects are created using the 'new' keyword and can be instantiated repeatedly.

This is False due to constant ambiguity. When a class implements two interfaces that both define the same constant (PI), Java cannot determine which interface's constant to reference. This causes a compilation error. The constant must be explicitly qualified with the interface name (e.g., MyInterface1.PI) to resolve the ambiguity.

java.lang.Object is the root class of the Java class hierarchy. Every class implicitly extends Object unless it explicitly extends another class. It's a fundamental class in the Java core API.

Dependency injection is a design pattern where objects receive their dependencies from external sources rather than creating them internally. This promotes loose coupling, easier testing, and better code maintainability by allowing dependencies to be swapped or mocked.

In Aspect-Oriented Programming (AOP), particularly in Spring AOP, an aspect is a modularization of a concern that cuts across multiple objects, typically implemented as a regular Java class annotated or configured to encapsulate advices and pointcuts. The other options describe inheritance, interface implementation, or specific framework capabilities.

Spring framework defines multiple bean scopes. Singleton (default) creates one instance per Spring container, while prototype creates a new instance each time the bean is requested. Additional scopes like request, session, and application are available in web contexts.

Adapter wraps an incompatible class to match an expected interface, making unrelated classes work together. Bridge separates abstraction from implementation so both can vary independently. Adapter is about making incompatible interfaces compatible after-the-fact, while Bridge prevents permanent binding between abstraction and implementation.

The Prototype pattern allows creating new objects by copying an existing instance (prototype) without knowing their concrete class or how to construct them. This matches the requirements of a custom class loader loading classes dynamically. Builder, Abstract Factory, and Singleton require explicit creation logic or type knowledge.

Template Method defines algorithm skeleton in base class, letting subclasses override specific steps without changing structure. This lets vendors customize spell-checking logic while keeping core algorithm unchanged. Strategy encapsulates entire algorithms, while Template only varies steps within a fixed algorithm structure.