Object-Oriented Programming

The native modifier in Java is used to indicate that a method is implemented in platform-dependent code (like C/C++), so it applies only to methods. Interfaces cannot have instance variables, abstract and static are mutually exclusive, and classes cannot be marked as synchronized.

Extension methods allow adding methods to existing types without inheritance or recompilation. This feature was introduced in C# 3.0 / .NET Framework 3.5. Lambda expressions, anonymous methods, and expression trees are related features but don't extend existing classes directly.

In Java, static methods cannot be overridden (only hidden), meaning a static method cannot override a non-static method, and vice versa. However, overloading allows methods with the same name but different signatures, regardless of static modifiers. Synchronized methods can be overridden freely.

The Factory Pattern provides a simple decision-making class that returns one of several possible subclasses of an abstract base class depending on the data provided. It encapsulates object creation logic and allows runtime determination of which concrete class to instantiate.

The Decorator Pattern attaches additional responsibilities to an object dynamically. It provides a flexible alternative to subclassing for extending functionality by wrapping the original object and passing unchanged methods through to it.

The Chain of Responsibility Pattern decouples sender from receiver by giving more than one object a chance to handle a request. The request passes along the chain until an object handles it, promoting loose coupling between classes.

The Observer pattern establishes a one-to-many relationship where a subject (the object being observed) automatically notifies all registered observers when its state changes. This enables loose coupling between objects since observers don't need to know about each other. The Visitor pattern is for separating algorithms from object structures, Template Pattern defines the skeleton of an algorithm in a base class, and 'Notifier Pattern' is not a standard GoF pattern.

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.