C#] Inheritance, Polymorphism, Abstraction, Interface

Inheritance

자식 클래스 Derived Class (child) - the class that inherits from another class

부모 클래스 Base Class (parent) - the class being inherited from 

To inherit from a class, use the : symbol

new class 생성 시, existing class의 method, fields를 재사용하기 위한 목적이다. 

class Vehicle  // base class (parent) 
{
  public string brand = "Ford";  // Vehicle field
  public void honk()             // Vehicle method 
  {                    
    Console.WriteLine("Tuut, tuut!");
  }
}

class Car : Vehicle  // derived class (child)
{
  public string modelName = "Mustang";  // Car field
}

class Program
{
  static void Main(string[] args)
  {
    // Create a myCar object
    Car myCar = new Car();

    // Call the honk() method (From the Vehicle class) on the myCar object
    myCar.honk();

    // Display the value of the brand field (from the Vehicle class) and the value of the modelName from the Car class
    Console.WriteLine(myCar.brand + " " + myCar.modelName);
  }
}

// Output : 
// Tuut, tuut!
// Ford Mustang

The sealed Keyword

다른 클래스에서 상속받지 못하도록 하려면, sealed keyword를 사용한다. 

sealed class를 상속하면, compile error 발생한다. 

Polymorphism

다형성, 상속으로 많은 class가 관련되어 있을때 생긴다. 

Inheritance는 다른 class에서 method와 fields를 상속할 수 있게 하고, Polymorphism은 상속받은 method로 다양한 task를 수행할 수 있게 한다. 

 

예를들어, Animal이라는 base class가 존재하고, animalSound()라는 함수가 존재한다. 

파생클래스는 Pigs, Cats, Dogs...이 있고, 각자의 animal sound를 가지고 있다. 

 

class Animal  // Base class (parent) 
{
  public void animalSound() 
  {
    Console.WriteLine("The animal makes a sound");
  }
}

class Pig : Animal  // Derived class (child) 
{
  public void animalSound() 
  {
    Console.WriteLine("The pig says: wee wee");
  }
}

class Dog : Animal  // Derived class (child) 
{
  public void animalSound() 
  {
    Console.WriteLine("The dog says: bow wow");
  }
}

class Program 
{
  static void Main(string[] args) 
  {
    Animal myAnimal = new Animal();  // Create a Animal object
    Animal myPig = new Pig();  // Create a Pig object
    Animal myDog = new Dog();  // Create a Dog object

    myAnimal.animalSound();
    myPig.animalSound();
    myDog.animalSound();
    
    // output
    // The animal makes a sound
    // The animal makes a sound
    // The animal makes a sound
  }
}

virtual keyword, override keyword

base class method를 override하기 위해서는, base class method에 virtual keyword를 붙이고, derived class method에는 override keyword를 붙인다. 

field는 가상일 수 없고, method, property, event, indexer만 가상일 수 있다. 

class Animal  // Base class (parent) 
{
  public virtual void animalSound() 
  {
    Console.WriteLine("The animal makes a sound");
  }
}

class Pig : Animal  // Derived class (child) 
{
  public override void animalSound() 
  {
    Console.WriteLine("The pig says: wee wee");
  }
}

class Dog : Animal  // Derived class (child) 
{
  public override void animalSound() 
  {
    Console.WriteLine("The dog says: bow wow");
  }
}

class Program 
{
  static void Main(string[] args) 
  {
    Animal myAnimal = new Animal();  // Create a Animal object
    Animal myPig = new Pig();  // Create a Pig object
    Animal myDog = new Dog();  // Create a Dog object

    myAnimal.animalSound();
    myPig.animalSound();
    myDog.animalSound();
    
    // output
    // The animal makes a sound
    // The pig says: wee wee
    // The dog says: bow wow
  }
}

virtual keyword 없는 method를 override하면 compile error 발생한다. 

ToString() 함수는 System.Object 클래스의 virtual method이므로, override할 수 있다. 

Access Base Class Members

base class의 virtual member에 접근하기 위해서는 base keyword를 사용할 수 있다. 

    class Animal  // Base class (parent) 
    {
        // Abstract method (does not have a body)
        public virtual void animalSound() {

            Console.WriteLine("Animal:");
        }
    }

    class Pig : Animal  // Derived class (child) 
    {
        public override void animalSound()
        {
            base.animalSound();
            Console.WriteLine("The pig says: wee wee");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {

            Animal myPig = new Pig();  // Create a Pig object

            myPig.animalSound();
            // output
            // Animal:
            // The pig says: wee wee

        }
    }

Abstraction

object의 특정 detail을 숨기고, 중요 detail만 노출하는데 사용한다. security!

abstract class 또는 interface를 사용한다. 

Abstract class

object를 생성할 수 없도록 제한된 class, derived class를 통해서 access할 수 있다. 

abstract method, regular method 모두 가질 수 있다. 

Abstract method

abstract class에서만 사용되며, body가 없다. derived class에서 body를 구현한다. 

    abstract class Animal  // Base class (parent) 
    {
        // Abstract method (does not have a body)
        public abstract void animalSound();
        // Regular method
        public void sleep()
        {
            Console.WriteLine("Zzz");
        }
    }

    class Pig : Animal  // Derived class (child) 
    {
        public override void animalSound()
        {
            Console.WriteLine("The pig says: wee wee");
        }
    }

    class Dog : Animal  // Derived class (child) 
    {
        public override void animalSound()
        {
            Console.WriteLine("The dog says: bow wow");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Animal myPig = new Pig();  // Create a Pig object
            Animal myDog = new Dog();  // Create a Dog object

            myPig.animalSound();
            myPig.sleep(); 
            myDog.animalSound();
            myDog.sleep(); 
            // output
            // The pig says: wee wee
            // Zzz
            // The dog says: bow wow
            // Zzz
        }
    }

Interfaces

abstraction을 구현할 수 있는 또 다른 방법은 interface이다. 

interface는 completely abstract class이다. abstract methods, properties만 포함할 수 있다. constructor, field는 불가능

interface class member는 기본으로 abstract, public이다. 

derived class를 통해서 access할 수 있다. 

inheritance와 동일하게 : symbol을 사용해서 interface를 구현할 수 있다. 

interface method는 구현 class에서 반드시 body를 작성하며, override keyword가 필요없다. 

// Interface
interface IAnimal 
{
  void animalSound(); // interface method (does not have a body)
}

// Pig "implements" the IAnimal interface
class Pig : IAnimal 
{
  public void animalSound() 
  {
    // The body of animalSound() is provided here
    Console.WriteLine("The pig says: wee wee");
  }
}

class Program 
{
  static void Main(string[] args) 
  {
    Pig myPig = new Pig();  // Create a Pig object
    myPig.animalSound();
  }
}

Abstract class와 interface는 유사하다, 가장 중요한 차이점은 class는 하나의 base class만 상속할 수 있는 반면에 여러개의 interfaces를 구현할 수 있다.