Object-Oriented Programming

C++ uses colon syntax for inheritance: 'class DerivedClass : accessSpecifier BaseClass'. Options B and C show incorrect syntax ('inherit' keyword and '<-' notation are not valid in C++).

A good hashCode implementation should combine significant fields using non-zero multipliers and handle null checks or existing field hashes appropriately. Option B combines the hash of the name string with the age field multiplied by a prime number, fulfilling standard contract requirements.

In Ab Initio, DML (Data Manipulation Language) can be copied from other components through propagation. 'Propagate from Neighbors' copies from connected components in the graph, while 'Propagate from other component' allows selecting any component. 'Copy DML' is not a standard propagation method, and 'All of the above' would be incorrect since option A is wrong.

In .NET, assemblies are private by default, meaning they are only accessible within the application directory where they are deployed. Public or shared assemblies must be explicitly configured in the Global Assembly Cache (GAC).

The wildcard ? extends Instrument means the list can hold any subtype of Instrument, but the compiler cannot guarantee type safety for add operations. You can only add null to such a list because the actual type could be any specific subclass (like Guitar or Violin), and adding the wrong subtype would break type safety. The code attempts to add Guitar and Violin objects, which causes a compilation error.

To instantiate a static nested class from outside its enclosing class, you must qualify the nested class name with the outer class name, using the syntax Outer.Inner obj = new Outer.Inner(). Other options fail due to missing qualifiers.

Properties in object-oriented languages like C# or Java provide encapsulation by controlling access to class fields. They act as intermediaries, allowing validation and computed logic while hiding the actual field storage.

Properties encapsulate an object's type state by providing controlled access to internal fields. Getters and setters define how state is read and modified, hiding the actual storage mechanism.

Read-only properties have only a get accessor (getter), not a set accessor. The statement incorrectly claims they have only a set accessor. Write-only properties would have only a set accessor.

Read-only properties must be assigned during object construction or initialization, as they cannot be modified afterward. This is typically done through constructors or initializer syntax.

Static properties belong to the class itself, not to instances. They can only access static members (other static fields, properties, or methods), not instance members which require an object reference.

Properties can be overridden polymorphically using keywords like virtual (in base class) and override (in derived class). These modifiers apply to the entire property declaration, not to individual accessors.

An abstract property contains no implementation (code) in the declaring class. It acts as a blueprint, forcing any non-abstract derived class to override and provide the actual implementation for its getters and setters.

C# uses indexers to provide array-like access to objects. Indexers are parameterized properties that allow indexing syntax (obj[index]) instead of traditional property syntax. The statement correctly identifies this relationship.

In C# and similar languages, a property getter must return a value (cannot be void) because it needs to provide the property's value when accessed. The setter can be void since it just modifies state. This question specifically addresses the getter's return requirement.