Object-Oriented Programming

Property rules in PRPC can be created with the same name in different rulesets (allowing versioning and specialization) and in different classes (enabling class-specific properties). They cannot be overridden with the same name in the same ruleset and class combination, but PRPC's inheritance facility allows derived classes to access properties defined in parent classes.

All custom classes in PRPC inherit from the three base classes: Work- (for work objects and case types), Data- (for reusable data and reference data), and History- (for historical instances and audit records). These form the foundation of PRPC's class hierarchy.

Java bytecode can be decompiled to recover readable source code. Code obfuscators make reverse engineering harder by renaming variables and adding control flow complexity, but cannot prevent decompilation entirely. The sandbox protects against runtime threats, not decompilation.

A subclass is a separate class that inherits properties and behaviors from a superclass through inheritance. The subclass extends the superclass, gaining its features while adding its own specialized behavior. It is not nested within, nor does the superclass inherit from the subclass.

Object-Oriented Programming (OOP) encompasses all the concepts listed: objects, classes, inheritance, encapsulation, polymorphism, abstraction, methods, reusability, message passing, and dynamic binding. These are all fundamental pillars of OOP methodology, making 'All above' the correct answer.

Shared Objects in Flash are objects created by SWF files that can store data locally on the user's system (similar to cookies). They persist between sessions and allow data to be saved and retrieved. They are not library sharing mechanisms, class-to-class sharing, or property-sharing objects.

In Java, all non-static and non-private methods are virtual by default and resolved via dynamic dispatch, meaning they can be overridden. Applying the final keyword prevents overriding and renders them non-virtual.

In Rails, every model class inherits from ActiveRecord::Base (or ApplicationRecord in Rails 5+, which itself inherits from ActiveRecord::Base). This provides ORM functionality, database interaction, validations, and associations. ActiveRecord is the core Rails component that connects models to database tables. ActiveModel is for non-database models, and the other options don't exist.

Java bytecode can always be decompiled because it contains enough metadata to reconstruct readable source code. Code obfuscators make decompilation harder by renaming variables and obscuring control flow, but cannot prevent it. The Java sandbox (A) is about runtime security, not decompilation prevention. Java is not compiled to ELF binaries (B). JIT compilers don't perform string encryption by default (D).

In most programming languages like Java, methods with the same name and same argument list must have the same return type. Different return types alone do not constitute valid overloading or overriding - this creates ambiguity and is not allowed.

Instance variables are not overridden - they are hidden. When a subclass declares a variable with the same name, it shadows the parent's variable rather than overriding it. Only methods are truly overridden in polymorphism.

You can declare a reference variable of an abstract class type. While you cannot instantiate an abstract class directly using new, the reference can point to instances of any concrete subclasses.

In Java, every class implicitly extends java.lang.Object. Therefore, the superclass of Class is Object. The option text 'Class object' refers to the Object class, which is the root of the class hierarchy.

Default (package-private) access is the most restrictive that allows classes in the same package to access members. Public allows access from anywhere, private restricts access to the same class only, and protected allows access to subclasses (even in different packages).

In Java, interfaces CAN have variables, but they must be public, static, and final constants (implicitly all three). The statement 'An Interface can have a variable' is correct if referring to constant fields. Interfaces cannot have instance variables or mutable fields. Options B, C, and D describe what interface members CAN be (public, static, final), so they are not incorrect statements.