Object-Oriented Programming

SetTOProperty only modifies the property values for the current test run session - it is a temporary runtime change. The Object Repository itself is not permanently modified by SetTOProperty. To make permanent changes to the Object Repository, you would need different methods like the Repository automation object model.

In Pega PRPC class hierarchy, work objects can be instantiated from classes derived from Work- base class, as well as from top-level classes. The class hierarchy supports flexible instantiation patterns while maintaining proper inheritance. Top-level classes provide another entry point for creating work objects outside the standard Work- hierarchy.

In Pega, class rules support both pattern inheritance (based on class name naming conventions) and directed inheritance (explicitly specified parent classes) during rule resolution. Therefore, class rules belong to both pattern and direct inheritance rather than only one.

Java compiles to bytecode that retains enough high-level information to be decompiled back into readable source code using tools like JD-Gui, CFR, or Procyon. Code obfuscators (e.g., ProGuard) can rename variables and methods to make reverse engineering more difficult and time-consuming, but they cannot prevent decompilation entirely. Java is not compiled to ELF binaries (option B), and the JIT compiler does not perform string encryption (option D). The sandbox environment protects against malicious runtime behavior, not decompilation (option A).

Variables declared inside a method are called local variables because they are only accessible within that method's scope. They are created when the method is called and destroyed when it exits. Private and static variables are declared at class level, while 'serial' is not a standard variable scope term.

Method overloading occurs when a class has multiple methods with the same name but different parameter lists (different number, types, or order of parameters). Overriding refers to a subclass providing a specific implementation of a method already defined in its superclass with the same signature.

Constructors in object-oriented programming cannot have a return type, not even 'void'. The code shows 'Public int EmployeeMgmt' which declares a return type of 'int', making it invalid as a constructor. A constructor should be 'public EmployeeMgmt' with no return type specifier.

When a class implements an interface, it must inherit all properties the interface defines, contain implementations of all the interface's methods (unless the class is abstract), and you can create objects of the class that implements the interface (though not directly instantiate the interface itself).

A sealed class in C# or Java (final) is explicitly marked to prevent other classes from inheriting from it. Consequently, it cannot be used as a base class for inheritance. This makes the statement true.

Abstract classes in object-oriented programming can contain instance variables (fields), can have constructors (used by subclasses), and can extend another class (single inheritance). Therefore, all three statements A, B, and C are correct features of abstract classes.

Method overloading in C# allows creating multiple methods with the same name but different signatures. The three valid ways to differentiate signatures are: different parameter data types (int vs string), different number of parameters (1 arg vs 2 args), and different parameter order (string,int vs int,string). All three approaches can be used alone or combined.

In C#, 'protected internal' access means member access is granted to classes derived from the containing class, or classes within the same assembly. However, the stored option description limits this to derived classes within the same assembly, whereas it is actually an OR condition (either derived OR within the same assembly). Since it is still the intended answer and other options are completely wrong, we mark it OK.

In C#, a class can implement multiple interfaces simultaneously, which enables achieving a form of multiple inheritance (implementation inheritance). This is different from extending multiple classes, which C# does not support. Interfaces provide contracts that a class must fulfill.

The virtual keyword marks a method as able to be overridden in derived classes. It allows the most derived implementation to be called even when referencing the base class (polymorphism). A virtual method is not automatically public (access is separate), not static (static methods cannot be virtual), and "derived" is vague - the key concept is overriding.