C# Object-Oriented Programming (OOP)
Introduction to OOP
Object-Oriented Programming (OOP) is a programming paradigm based on the concept of objects that combine state and behavior.
In C#, OOP allows developers to model real-world entities as classes and objects, which have properties (data) and methods (functions).
The four main principles of OOP are: Encapsulation, Inheritance, Polymorphism, and Abstraction.
Classes and Objects
A class defines a blueprint for creating objects. It can contain fields, properties, and methods.
An object is an instance of a class. Multiple objects can be created from the same class, each with its own state.
using System;
namespace OOPExample
{
class Car
{
public string Brand;
public int Year;
public void Drive()
{
Console.WriteLine($"{Brand} is driving.");
}
}
class Program
{
static void Main(string[] args)
{
Car myCar = new Car();
myCar.Brand = "BMW";
myCar.Year = 2022;
Console.WriteLine($"Car: {myCar.Brand}, Year: {myCar.Year}");
myCar.Drive();
}
}
}Car: BMW, Year: 2022 BMW is driving.
Encapsulation
Encapsulation restricts direct access to an object's data and enforces controlled access through properties or methods.
Access modifiers like public, private, and protected are used to control visibility, and properties with getters and setters provide a safe way to expose data.
using System;
namespace EncapsulationExample
{
class Person
{
private string name;
public string Name
{
get { return name; }
set { name = value; }
}
}
class Program
{
static void Main(string[] args)
{
Person p = new Person();
p.Name = "Alice";
Console.WriteLine("Name: " + p.Name);
}
}
}Name: Alice
Inheritance
Inheritance allows one class (derived class) to reuse members of another class (base class).
In C#, the ':' symbol is used to declare inheritance.
using System;
namespace InheritanceExample
{
class Animal
{
public void Eat()
{
Console.WriteLine("This animal eats food.");
}
}
class Dog : Animal
{
public void Bark()
{
Console.WriteLine("The dog barks.");
}
}
class Program
{
static void Main(string[] args)
{
Dog d = new Dog();
d.Eat();
d.Bark();
}
}
}This animal eats food. The dog barks.
Polymorphism
Polymorphism allows methods in a base class to be redefined in derived classes, giving different behavior for the same method call.
In C#, this is commonly achieved with the 'virtual' keyword in the base class and 'override' in the derived class.
using System;
namespace PolymorphismExample
{
class Animal
{
public virtual void Speak()
{
Console.WriteLine("The animal makes a sound.");
}
}
class Dog : Animal
{
public override void Speak()
{
Console.WriteLine("The dog barks.");
}
}
class Cat : Animal
{
public override void Speak()
{
Console.WriteLine("The cat meows.");
}
}
class Program
{
static void Main(string[] args)
{
Animal a1 = new Dog();
Animal a2 = new Cat();
a1.Speak();
a2.Speak();
}
}
}The dog barks. The cat meows.
Abstraction
Abstraction focuses on hiding implementation details and exposing only the necessary operations to the user.
In C#, abstraction can be achieved using abstract classes or interfaces.
using System;
namespace AbstractionExample
{
abstract class Shape
{
public abstract void Draw();
}
class Circle : Shape
{
public override void Draw()
{
Console.WriteLine("Drawing a Circle.");
}
}
class Program
{
static void Main(string[] args)
{
Shape s = new Circle();
s.Draw();
}
}
}Drawing a Circle.