Opps Part 1 : Abstraction

  Abstraction in C# is a fundamental concept of object-oriented programming (OOP) that allows developers to create complex systems by breaking them down into simpler and more manageable parts. Abstraction enables the developer to hide the complexities of the system by creating abstract classes, interfaces, and methods, and exposing only the necessary functionalities to the users.

 using System;  
 abstract class Animal  
 {  
   public abstract void MakeSound();  
 }  
 class Dog : Animal  
 {  
   public override void MakeSound()  
   {  
     Console.WriteLine("Woof!");  
   }  
 }  
 class Cat : Animal  
 {  
   public override void MakeSound()  
   {  
     Console.WriteLine("Meow!");  
   }  
 }  
 class Program  
 {  
   static void Main(string[] args)  
   {  
     Animal myDog = new Dog();  
     Animal myCat = new Cat();  
     myDog.MakeSound(); // Output: Woof!  
     myCat.MakeSound(); // Output: Meow!  
   }  
 }                              

In this example, we have an abstract class called Animal that contains an abstract method called MakeSound(). The Animal class cannot be instantiated, and any class that derives from it must implement the MakeSound() method.

We then create two classes, Dog and Cat, that inherit from the Animal class and implement the MakeSound() method with their own unique sounds.

Finally, in the Main method, we create objects of the Dog and Cat classes and call their MakeSound() methods, which outputs "Woof!" and "Meow!" respectively.

This is an example of abstraction because we are abstracting away the implementation details of the Animal class, and only exposing the necessary functionality through the MakeSound() method. This allows us to create different types of animals with their own unique sounds, without having to worry about the underlying implementation details.

Abstract Base Class points

There are some important points about Abstract Base Class.

1. An Abstract Base class cannot be instantiated; it means the object of that class cannot be created.
2. The class having the abstract keyword with some of its methods (not all) is known as an Abstract Base Class.
3. The class having the Abstract keyword with all its methods is a pure Abstract Base Class.
4. The method of the abstract class that has no implementation is known as "operation". It can be defined as an abstract void method ();
5. An abstract class holds the methods, but the actual implementation is made in the derived class.

Opps part 1 : What is Inheritance?

 Inheritance is a concept in object-oriented programming (OOP) that allows a class (called the "child" or "derived" class) to inherit properties and methods from another class (called the "parent" or "base" class).

Inheritance promotes code reuse and allows developers to create new classes that are similar to existing classes, but with additional or modified functionality. The child class inherits all the public and protected properties and methods of the parent class, and can also add its own properties and methods.

For example, consider a class called "Animal" that has properties and methods for common attributes of all animals, such as "name", "age", and "eat()". A child class called "Cat" could inherit from the "Animal" class and add its own properties and methods, such as "purr()" or "scratch()". The "Cat" class can use the properties and methods of the "Animal" class, without having to rewrite them.

Inheritance is often used in software development to create a hierarchy of related classes that share common properties and behaviors, while also allowing for specialization and customization of each class.

Single Inheritance in C#

// Base class
class Animal
{
public void Eat()
{
Console.WriteLine("Animal is eating.");
}
}
// Derived class

class Dog : Animal
{
public void Bark()
{
Console.WriteLine("Dog is barking.");
}
}
// Example usage

class Program
{
static void Main(string[] args)
{
// Create an instance of the Dog class
Dog myDog = new Dog();
// Call methods from the Dog class

myDog.Bark();
// Call inherited method from the Animal class

myDog.Eat();
}

}

MultiLevel Inheritance in C#

// Base class class Animal { public void Eat() { Console.WriteLine("Animal is eating."); } } // Derived class class Dog : Animal { public void Bark() { Console.WriteLine("Dog is barking."); } } // Derived class class Bulldog : Dog { public void Guard() { Console.WriteLine("Bulldog is guarding."); } } // Example usage class Program { static void Main(string[] args) { // Create an instance of the Bulldog class Bulldog myBulldog = new Bulldog(); // Call methods from the Bulldog class myBulldog.Bark(); myBulldog.Guard(); // Call inherited method from the Dog class myBulldog.Eat(); } }

Hierarchical Inheritance in C#

// Base class class Animal { public void Eat() { Console.WriteLine("Animal is eating."); } } // Derived class class Dog : Animal { public void Bark() { Console.WriteLine("Dog is barking."); } } // Derived class class Cat : Animal { public void Meow() { Console.WriteLine("Cat is meowing."); } } class Program { static void Main(string[] args) { Dog myDog = new Dog(); Cat myCat = new Cat(); myDog.Bark(); myCat.Meow(); myDog.Eat(); myCat.Eat(); } }

Multiple Inheritance in C#

C# does not support multiple Inheritance through classes; a class cannot inherit from more than one base class at the same time.

Note. C# does support multiple inheritances through interfaces.

interface IShape { void Draw(); } interface IColor { void SetColor(string color); } class Square : IShape, IColor { private string color; public void Draw() { Console.WriteLine("Drawing square."); } public void SetColor(string color) { this.color = color; } public void PrintColor() { Console.WriteLine("Color of square is: " + color); } } class Program { static void Main(string[] args) { Square square = new Square(); square.Draw(); square.SetColor("Blue"); square.PrintColor(); } }