أسئلة القسم

Object-Oriented Programming (OOP) is a paradigm that organizes software design around objects instead of functions and logic.

Main Principles (Pillars):

• Encapsulation: Hiding internal details, exposing only necessary behavior.
• Inheritance: Reusing and extending existing classes.
• Polymorphism: Ability for different classes to be treated through a common interface.
• Abstraction: Focusing on essential behavior, hiding complexity.

An object is an instance of a class.

It represents a real-world entity with state (fields/properties) and behavior (methods).

Encapsulation = wrapping data + methods together and controlling access via access modifiers.

Protects internal state, only exposes what’s necessary.

Example:

public class BankAccount {
    private decimal balance; // hidden from outside
    public void Deposit(decimal amount) => balance += amount;
    public decimal GetBalance() => balance;
}

Inheritance allows one class (child) to reuse and extend another class (parent).

Promotes code reuse.

Example:

class Vehicle { public void Drive() => Console.WriteLine("Driving..."); }
class Car : Vehicle { public void Honk() => Console.WriteLine("Beep!"); }

Car car = new Car();
car.Drive(); // inherited
car.Honk();  // child’s own

Polymorphism = “many forms” → same method name can behave differently depending on the context.

Types:

1. Compile-time Polymorphism (Static)
   • Achieved using method overloading or operator overloading.
   • Decided at compile time by the compiler.
2. Runtime Polymorphism (Dynamic)
   • Achieved using method overriding with virtual/override.
   • Decided at runtime by the CLR.

Abstraction = hiding implementation details, exposing only what an object does, not how.

Done using abstract classes or interfaces.

A constructor is a special method (with the same class name) that runs when an object is created.

Used to initialize fields/properties.

• Default constructor: No parameters.
• Parameterized constructor: Takes arguments.
• Copy constructor: Copies values from another object.
• Static constructor: Runs once, initializes static data.
• Private constructor: Prevents direct instantiation, often used in Singleton.

Constructor:

• Called when object is created.
• Used for initialization.

Destructor (~ClassName):

• Called by GC before object is destroyed.
• Used for cleanup (rare in C#, usually replaced by IDisposable).

Yes.

Common Use Cases:

• Singleton pattern: Restricts instantiation.
• Static classes: Prevents object creation.

A class declared with static keyword:

• Cannot be instantiated.
• Can only contain static members.
• Often used for utility/helper methods.

No, a static class cannot implement an interface because:

• Static classes cannot be instantiated.
• Interfaces define a contract meant to be implemented by instances of classes.

Abstract Method:

• No implementation in base class.
• Must be overridden in derived class.

Virtual Method:

• Has a default implementation.
• Can be overridden (optional).

• Regular class: Normal type.
• Abstract class: Cannot be instantiated.
• Sealed class: Cannot be inherited.
• Static class: Contains only static members.
• Partial class: Split across multiple files.
• Nested class: Class inside another class.

Sealed class: Cannot be inherited.

Used when:

• You want to prevent inheritance for security or design reasons.
• For performance (JIT optimizes sealed methods).