Object-Oriented Programming

Singleton pattern ensures a class has only one instance and provides a global access point to it. This is useful for shared resources like database connections or logging services. Option A incorrectly describes creating many instances, which contradicts Singleton's purpose. Option B is insufficient because a single constructor alone doesn't prevent multiple instances. Option D describes the Object Pool pattern, which manages reusable objects.

The Facade pattern provides a simplified interface to a complex subsystem of classes, making it easier to use. It doesn't encapsulate the subsystem but provides a higher-level interface that reduces complexity for clients. Adapter Pattern converts one interface to another, Bridge Pattern separates abstraction from implementation, and Proxy Pattern controls access to an object.

FileStream is a low-level stream class for reading and writing bytes. To write simple types (int, string, etc.) directly to a binary file, you need BinaryWriter or use serialization with FileStream. FileStream's Write methods only accept byte arrays, not typed data.

In C#, method overriding requires the base class method to be marked 'virtual' (or abstract) and the derived class method to be marked 'override'. The 'virtual' keyword allows the method to be overridden, while 'override' explicitly indicates that the method overrides a base class method. 'new' hides the base method, 'base' calls the base class implementation.

In C# inheritance syntax 'class derived : base', the class name before the colon (test) is the derived/child class, and the class name after the colon (Form) is the base/parent class. This means 'test' inherits from 'Form', not the reverse.

Enum is a value type in C#, while Delegate, Array, and Class are all reference types. Value types store their data directly, while reference types store a reference to the data's location in memory. Enums are derived from System.ValueType.

If you define any custom constructor in a C# class, the compiler no longer automatically provides the parameterless default constructor. The other statements are true: Object is the root class, static constructors are supported, and comparison operators like <= and >= must be overloaded in pairs.

In C#, constructor execution starts from the highest base class in the inheritance hierarchy down to the derived class. Since all classes implicitly inherit from System.Object, its constructor runs first, followed by A, B, and finally C. Distractors fail to include Object or list the execution order in reverse.

All lines compile correctly. Line 3's array syntax 'int[] a []' is valid (array of arrays). Line 4 can assign a long array to an Object reference (upcasting). Line 5 assigns a String array to an Object array reference (covariant arrays are allowed in Java).

Line 10 attempts 'e2.e = el' but 'el' is undefined (typo for 'e1'). Since e2 was set to null on line 8, this would cause a NullPointerException. The GC eligibility questions become moot because the code throws an exception before completing.

Since Faster is a nested enum inside the class Better, it must be referenced using its outer class name. Thus, Better.Faster is the correct type, and Better.Faster.Higher or Better.Faster.Longer are the correct value references. Extra whitespace in Better. Faster is ignored by the compiler, making both selected options valid.

Java initialization order: static blocks execute top-to-bottom when class is loaded, then for each object: instance initializers (top-to-bottom) then constructor. The trace shows: Bird static (prints nothing), then Raptor static (r1, r4), then 'pre', then Hawk() calls Raptor() which calls Bird(): Bird instance initializer (b1), Bird constructor (b2), then back to Raptor instance initializer (r3), Raptor constructor (r2), then 'hawk'. Result: r1 r4 pre b1 b2 r3 r2 hawk.

Access modifiers (public, private, protected) must appear BEFORE the variable's type or the method's return type in Java declarations. The syntax is: [modifier] type name = value. Option A is true but B is more specific about placement. Options C and E are wrong - modifiers cannot follow the declaration. Option D is wrong - order matters.

An interface in Java is a collection of abstract method declarations and constant values. It defines a contract without implementation - classes implement interfaces to provide specific behavior while achieving a form of multiple inheritance of type.