Mastering OOPs Concepts in C#: A Comprehensive Guide

 class SchoolBag {
    book;
    pen;
    ReadBook();
}

 public class Student {
    private string name;
    private int age;

    public string GetName() {
        return name;
    }
    public void SetName(string newName) {
        name = newName;
    }
}

 using System;
public class BankAccount {
    // Private field to store the balance
    private double balance;

    // Constructor to initialize the balance
    public BankAccount(double initialBalance) {
        if(initialBalance >= 0) {
            balance = initialBalance;
        } else {
            balance = 0;
            Console.WriteLine("Initial balance can't be negative. Setting balance to 0.");
        }
    }

    // Public method to get the current balance (read-only access)
    public double GetBalance() {
        return balance;
    }

    // Public method to deposit money (with validation)
    public void Deposit(double amount) {
        if(amount > 0) {
            balance += amount;
            Console.WriteLine($"Deposited: {amount}. New Balance: {balance}");
        } else {
            Console.WriteLine("Deposit amount must be positive.");
        }
    }

    // Public method to withdraw money (with validation)
    public void Withdraw(double amount) {
        if(amount > 0 && amount <= balance) {
            balance -= amount;
            Console.WriteLine($"Withdrawn: {amount}. New Balance: {balance}");
        } else {
            Console.WriteLine("Invalid withdrawal amount.");
        }
    }
}

public class Program {
    public static void Main() {
        // Creating a new bank account with an initial balance
        BankAccount account = new BankAccount(500);

        // Checking initial balance
        Console.WriteLine("Initial Balance: " + account.GetBalance());

        // Trying to deposit money
        account.Deposit(200);

        // Trying to withdraw money
        account.Withdraw(150);

        // Trying to withdraw an invalid amount
        account.Withdraw(600);
        
        // Trying to deposit a negative amount
        account.Deposit(-50);
    }
}

 Initial Balance: 500
Deposited: 200. New Balance: 700
Withdrawn: 150. New Balance: 550
Invalid withdrawal amount.
Deposit amount must be positive.

 public class BaseClass {
    // Base class members (fields, methods, etc.)
}
public class DerivedClass : BaseClass {
    // Derived class members (fields, methods, etc.)
}

 using System;
public class Animal {
    public void Eat() {
        Console.WriteLine("This animal is eating.");
    }
}
public class Dog : Animal {
    public void Bark() {
        Console.WriteLine("The dog is barking.");
    }
}
public class Program {
    public static void Main() {
        Dog myDog = new Dog();
        // Calling method from the derived class
        myDog.Bark();
        
        // Calling inherited method from the base class
        myDog.Eat();
    }
}

 The dog is barking.
This animal is eating.

 using System;
public class Employee {
    public string Name { get; set; }
    public int EmployeeID { get; set; }

    public Employee(string name, int employeeID) {
        Name = name;
        EmployeeID = employeeID;
    }

    // Base class method
    public virtual void DisplayDetails() {
        Console.WriteLine($"Name: {Name}, Employee ID: {EmployeeID}");
    }
}
// Derived class representing full-time employees
public class FullTimeEmployee : Employee {
    public double AnnualSalary { get; set; }

    public FullTimeEmployee(string name, int employeeID, double annualSalary)
        : base(name, employeeID) {
        AnnualSalary = annualSalary;
    }

    // Overriding the base class method
    public override void DisplayDetails() {
        base.DisplayDetails();
        Console.WriteLine($"Annual Salary: {AnnualSalary}");
    }
}
// Derived class representing part-time employees
public class PartTimeEmployee : Employee {
    public double HourlyWage { get; set; }
    public int HoursWorked { get; set; }

    public PartTimeEmployee(string name, int employeeID, double hourlyWage, int hoursWorked)
        : base(name, employeeID) {
        HourlyWage = hourlyWage;
        HoursWorked = hoursWorked;
    }

    // Overriding the base class method
    public override void DisplayDetails() {
        base.DisplayDetails();
        Console.WriteLine($"Hourly Wage: {HourlyWage}, Hours Worked: {HoursWorked}, Total Pay: {HourlyWage * HoursWorked}");
    }
}
public class Program {
    public static void Main() {
        // Creating a full-time employee object
        FullTimeEmployee ftEmployee = new FullTimeEmployee("John Doe", 101, 60000);
        Console.WriteLine("Full-Time Employee Details:");
        ftEmployee.DisplayDetails();

        Console.WriteLine();

        // Creating a part-time employee object
        PartTimeEmployee ptEmployee = new PartTimeEmployee("Jane Smith", 102, 20, 25);
        Console.WriteLine("Part-Time Employee Details:");
        ptEmployee.DisplayDetails();
    }
}

 Full-Time Employee Details:
Name: John Doe, Employee ID: 101
Annual Salary: 60000

Part-Time Employee Details:
Name: Jane Smith, Employee ID: 102
Hourly Wage: 20, Hours Worked: 25, Total Pay: 500

 public abstract class Animal {
    public abstract void MakeSound();  // Abstract method
    public void Eat() {                // Concrete method
        Console.WriteLine("This animal is eating.");
    }
}

 using System;
public abstract class Animal {
    // Abstract method (no implementation)
    public abstract void MakeSound();

    // Concrete method (has implementation)
    public void Sleep() {
        Console.WriteLine("This animal is sleeping.");
    }
}
// Derived class providing implementation for abstract method
public class Dog : Animal {
    public override void MakeSound() {
        Console.WriteLine("The dog barks.");
    }
}
public class Program {
    public static void Main() {
        // Animal myAnimal = new Animal(); // Error! Cannot instantiate abstract class

        Dog myDog = new Dog();  // Create a Dog object
        myDog.MakeSound();      // Calls the implemented method
        myDog.Sleep();          // Calls the inherited concrete method
    }
}

 The dog barks.
This animal is sleeping.

 public interface IAnimal {
    void MakeSound();  // Interface method (no implementation)
}

 using System;
public interface IAnimal {
    // Abstract method (implicitly abstract, no implementation)
    void MakeSound();
}

public class Dog : IAnimal {
    // Implementing the interface method
    public void MakeSound() {
        Console.WriteLine("The dog barks.");
    }
}

public class Program {
    public static void Main() {
        Dog myDog = new Dog();
        myDog.MakeSound();
    }
}

 The dog barks.

 using System;
public interface IPayment {
    void ProcessPayment(double amount);  // Abstract method
}
public class CreditCardPayment : IPayment {
    public void ProcessPayment(double amount) {
        Console.WriteLine($"Processing credit card payment of {amount}.");
    }
}
public class BankTransferPayment : IPayment {
    public void ProcessPayment(double amount) {
        Console.WriteLine($"Processing bank transfer payment of {amount}.");
    }
}
public class Program {
    public static void Main() {
        IPayment payment;

        // Process credit card payment
        payment = new CreditCardPayment();
        payment.ProcessPayment(250.00);

        // Process bank transfer payment
        payment = new BankTransferPayment();
        payment.ProcessPayment(1500.00);
    }
}

 Processing credit card payment of 250.
Processing bank transfer payment of 1500.