Learn OOP (Object Oriented Programming) for beginners

 If you're just starting out in the world of programming and are interested in Object-Oriented Programming (OOP) using languages like Java or C#, you've come to the right place.

OOP is a programming paradigm that emphasizes the use of objects, which are instances of classes, to represent and manipulate data. This approach makes it easier to manage and organize large, complex software projects.

To get started with OOP in Java or C#, you'll need to understand the following concepts:

• ·      Classes and Objects
• ·      Abstraction
• ·      Encapsulation
• ·      Polymorphism
• ·      Inheritance

A) Classes and Objects:

A class is a blueprint for an object that defines its properties and methods. An object is an instance of a class that can be created and manipulated in your program.

In other words, think class as a container where you can keep all the properties and methods related to class whereas object is an instance of that class where you can access and manipulate the properties and methods of that class.

B) Abstraction

Abstraction is a fundamental concept in Object-Oriented Programming (OOP) that allows you to represent complex real-world objects by simplifying and focusing on the essential features that are relevant to your application, while ignoring or hiding the irrelevant details.

In OOP, abstraction is typically achieved by defining abstract classes or interfaces, which are used as blueprints for creating more specialized classes. Abstract classes define common properties and behaviors that are shared by a group of related classes, while interfaces define a set of methods that must be implemented by any class that implements the interface.

Abstraction helps you to create more flexible and maintainable code by reducing the dependencies between different parts of your application. It also allows you to hide the implementation details of your code, which makes it easier to change or update your code without affecting the rest of your application.

Abstraction is a key concept in OOP, and it is used in many programming languages, including Java, C#, Python, and others.

C) Encapsulation

Encapsulation is a fundamental principle in object-oriented programming that refers to the concept of hiding implementation details of an object from the outside world, and exposing only necessary information through public interfaces.

In C#, encapsulation is achieved through the use of access modifiers such as public, private, protected, and internal. These modifiers control the visibility of class members, such as fields, properties, and methods, from other parts of the program.

Here is an example of encapsulation in C#:

      
public class BankAccount {
    private double balance;

    public void Deposit(double amount) {
        balance += amount;
    }

    public void Withdraw(double amount) {
        if (amount <= balance) {
            balance -= amount;
        } else {
            Console.WriteLine("Insufficient funds");
        }
    }

    public double GetBalance() {
        return balance;
    }
}

      

In this example, the BankAccount class encapsulates the balance data and the Deposit, Withdraw, and GetBalance methods that operate on that data. The balance field is marked as private, which means it can only be accessed from within the BankAccount class.

The public methods, Deposit, Withdraw, and GetBalance, provide a simple interface for interacting with the BankAccount object, without exposing the internal workings of the class. This is a key aspect of encapsulation, as it helps to keep the implementation details of the class hidden and maintainable.

D) Polymorphism

Polymorphism is a fundamental concept in object-oriented programming (OOP) that allows objects of different types to be treated as if they are of the same type. In other words, it enables objects of different classes to be used interchangeably, as long as they share a common interface or base class.

In C#, there are two types of polymorphism: static polymorphism, which is achieved through overloading, and dynamic polymorphism, which is achieved through inheritance and overriding. Here, I will provide an example of dynamic polymorphism using inheritance and overriding.

Let's say we have a base class called Animal with a virtual method called MakeSound():

 public class Animal
 {
    public virtual void MakeSound()
    {
        Console.WriteLine("The animal makes a sound.");
    }
}

      

We also have two derived classes called Dog and Cat that inherit from Animal and override the MakeSound() method:

 public class Dog : Animal
 {
    public override void MakeSound()
    {
        Console.WriteLine("The dog barks.");
    }
}

public class Cat : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("The cat meows.");
    }
}

      

Now, we can create objects of type Animal, Dog, and Cat, and call the MakeSound() method on each of them:     

 Animal animal = new Animal();
animal.MakeSound(); // Output: The animal makes a sound.

Dog dog = new Dog();
dog.MakeSound(); // Output: The dog barks.

Cat cat = new Cat();
cat.MakeSound(); // Output: The cat meows.

Animal animal2 = new Dog();
animal2.MakeSound(); // Output: The dog barks.

Animal animal3 = new Cat();
animal3.MakeSound(); // Output: The cat meows.

      

As you can see, even though we declare animal2 and animal3 as type Animal, we are able to call the MakeSound() method on them and get the specific sound that each of them makes. This is because of dynamic polymorphism, which allows us to treat objects of derived classes as objects of the base class. When we call the MakeSound() method on an object of a derived class, the overridden method in the derived class is called instead of the base class method.

E) Inheritance

Inheritance is a fundamental concept in object-oriented programming (OOP) that allows a new class to be based on an existing class. The new class, called the derived class, inherits the properties and methods of the existing class, called the base class, and can add its own properties and methods as well.

 

In C#, inheritance is achieved through the : symbol, which indicates that one class is derived from another class. Here, I will provide an example of inheritance in C#:

      
public class Shape
{
    public int X { get; set; }
    public int Y { get; set; }

    public virtual void Draw()
    {
        Console.WriteLine("Drawing a shape at ({0}, {1})", X, Y);
    }
}

public class Rectangle : Shape
{
    public int Width { get; set; }
    public int Height { get; set; }

    public override void Draw()
    {
        Console.WriteLine("Drawing a rectangle at ({0}, {1}) with width {2} and height {3}", X, Y, Width, Height);
    }
}

      

In this example, we have a base class called Shape that has two properties (X and Y) and a virtual method called Draw(). We also have a derived class called Rectangle that inherits from Shape and adds two more properties (Width and Height) and overrides the Draw() method.

 

Now, we can create objects of type Shape and Rectangle and call the Draw() method on each of them

Shape shape = new Shape();
shape.X = 10;
shape.Y = 20;
shape.Draw(); // Output: Drawing a shape at (10, 20)

Rectangle rect = new Rectangle();
rect.X = 30;
rect.Y = 40;
rect.Width = 50;
rect.Height = 60;
rect.Draw(); // Output: Drawing a rectangle at (30, 40) with width 50 and height 60

As you can see, the Rectangle object can access both the properties and the Draw() method of the Shape object, as well as its own properties and overridden Draw() method. This is because of inheritance, which allows the Rectangle object to inherit the properties and methods of the Shape object and add its own properties and methods as well.