# 프로그래밍 - CH7 상속과 다형성

상속과 다형성

반복을 줄이기 위해 만들어진 방법

상속과 다형성을 사용하지 않은 예

Dog 클래스

class Dog
{
    public int Age { get; set; }
    public string Color { get; set; }

    public Dog() { this.Age = 0; }

    public void Eat() { Console.WriteLine("냠냠 먹습니다"); }
    public void Sleep() { Console.WriteLine("쿨쿨 잠을 잡니다"); }
    public void Bark() { Console.WriteLine("왈왈 짖습니다"); }
}

Cat 클래스

class Cat
{
    public int Age { get; set; }

    public Cat() { this.Age = 0; }

    public void Eat() { Console.WriteLine("냠냠 먹습니다"); }
    public void Sleep() { Console.WriteLine("쿨쿨 잠을 잡니다"); }
    public void Meow() { Console.WriteLine("냥냥 웁니다"); }
}

Dog 클래스와 Cat 클래스의 인스턴스를 만들고 메서드 실행

static void Main(string[] args)
{
    List<Dog## Dogs = new List<Dog>() { new Dog(), new Dog(), new Dog() };
    List<Cat## Cats = new List<Cat>() { new Cat(), new Cat(), new Cat() };

    foreach (var item in Dogs)
    {
        item.Eat();
        item.Sleep();
        item.Bark();
    }

    foreach (var item in Cats)
    {
        item.Eat();
        item.Sleep();
        item.Meow();
    }
}

문제 → 의미 없이 반복되는 부분이 굉장히 많음 (유지보수에도 적합하지 않음)

해결책 → 상속과 다형성

상속

자식 클래스``:``부모 클래스

클래스 사이에 부모 자식 관계를 정의하는 작업

Animal 클래스 (부모 클래스)

class Animal
{
    public int Age { get; set; }

    public void Animal() { this.Age = 0; }

    public void Eat() { Console.WriteLine("냠냠 먹습니다."); }
    public void Sleep() { Console.WriteLine("쿨쿨 잠을 잡니다"); }
}

Dog 클래스와 Cat 클래스 (자식 클래스)

class Dog : Animal
{
    public string Color { get; set; }

    public void Bark() { Console.WriteLine("왈왈 짖습니다."); }
}

class Cat : Animal
{
    public void Meow() { Console.WriteLine("냥냥 웁니다."); }
}

자식 클래스는 부모 클래스의 public 또는 protected 멤버에 접근할 수 있음

다른 접근 제한자

접근 제한자	내부 클래스	외부 클래스	파생 클래스	프로젝트
public	O	O	O	O
internal	O	O	O
protected	O		O
private	O
protected internal	O	같은 어셈블리 안에 있을 때 접근 가능	O

base 키워드

부모 자식 간 멤버 이름이 겹치는 등의 특수한 이유(하이딩 등)로 인해 부모의 메서드에 접근할 수 없을 때,

this 키워드와 같은 형태로 base 키워드를 사용함

this가 자신을 나타내는 키워드라면 base는 부모를 나타내는 키워드임

protected 접근 제한자

private 과 비슷하지만 상속한 클래스(파생 클래스)에서는 접근할 수 있음

다형성

하나의 클래스가 여러 형태로 변환될 수 있는 성질 (=자식 클래스가 부모 클래스로 위장하는 것)

Animal dog = new Dog();
Animal cat = new Cat();

실제 들어있는 것은 각각 Dog과 Cat이지만, 외관상으로는 Animal 클래스이므로 사용할 수 있는 멤버는 Animal 클래스의 멤버 뿐임

부모 클래스로 위장함으로써 얻을 수 있는 효익

하나의 Animal 배열 또는 리스트에 여러 Dog 클래스와 Cat 클래스를 넣을 수 있음

List<Animal## Animals = new List<Animal>()
{
    new Dog(), new Cat(), new Cat(), new Dog(),
    new Dog(), new Cat(), new Dog(), new Dog()
};

foreach (var item in Animals)
{
    item.Eat();
    item.Sleep();
}

부모 클래스로 위장한 자식이 자식 클래스에 있는 메서드를 사용하려면?

자식 클래스로 자료형 변환을 해주어야 함

최상위 클래스

C#에서 만드는 모든 클래스는 Object 라는 클래스의 상속을 받게 됨

즉, 다형성을 활용하여 다음과 같이 사용할 수 있음

List<Object## listOfObject = new List<Object>();
listOfObject.Add(new Dog());
listOfObject.Add(new Cat());

마찬가지로 int, float 자료형 등도 모두 Object 클래스의 상속을 받으므로 다음과 같이 사용할 수도 있음

List<Object## listOfObject = new List<Object>();
listOfObject.Add(new Dog());
listOfObject.Add(new Cat());
listOfObject.Add(52);
listOfObject.Add(52.273f);

is 키워드

객체 is 클래스

특정한 객체가 어떤 클래스인지 확인하기 위한 키워드

static void Main(string[] args)
{
    List<Animal## Animals = new List<Animal>() { };

    foreach (var item in Animals)
    {
        item.Eat();
        item.Sleep();

        if (item is Dog) { }
        if (item is Cat) { }
    }
}

변수 item 이 Dog 클래스라면 다음의 경우 모두 true 를 출력하게 됨

item is Dog
item is Animal
item is Object

일반적인 자료형 변환

(클래스) 변수

변환에 실패하면 예외가 발생함

foreach (var item in Animals)
{
    item.Eat();
    item.Sleep();

    if (item is Dog) { ((Dog)item).Bark(); }
    if (item is Cat) { ((Cat)item).Meow(); }
}

as 키워드로 자료형 변환

변수 as 클래스

변환에 실패하면 null 을 넣어줌

foreach (var item in Animals)
{
    item.Eat();
    item.Sleep();

    var dog = item as Dog;
    if (dog!=null) { dog.Bark(); }

    var cat = item as Cat;
    if (cat!=null) { cat.Meow(); }
}

상속의 생성자

자식 인스턴스를 생성하면, 부모가 가지고 있는 멤버의 초기화를 위해 부모 생성자도 자동으로 호출됨

이 때, 호출되는 순서는 부모 생성자 → 자식 생성자 임

부모 생성자 호출을 명시적으로 지정하고 싶을 때는 base() 키워드를 사용함

다음과 같이 부모 생성자가 오버로딩되어있는 경우가 한 가지 예라고 할 수 있음

class Program
{
    class Parent
    {
        public Parent() { Console.WriteLine("Parent()"); }
        public Parent(int param) { Console.WriteLine("Parent(int param)"); }
        public Parent(string param) { Console.WriteLine("Parent(string param)"); }
    }

    class Child : Parent
    {
        public Child() : base(10)
        {
            Console.WriteLine("Child() : base(10)");
        }

        public Child(string input) : base(input)
        {
            Console.WriteLine("Child(string input) : base(input)");
        }
    }

    static void Main(string[] args)
    {
        Child childA = new Child();
        Child childB = new Child("string");
    }
}

클래스 변수 상속

클래스 변수는 상속되어도 부모 자식 클래스 간 공유되는 개념이기 때문에 각 클래스에서 같은 변수에 대해 같은 조작을 가하게 되면 변동값은 두 배가 된다.

섀도잉과 하이딩

변수에 같은 이름을 사용하면 이름 충돌이 발생하게 됨

이름 재사용의 종류는 다음과 같음

오버로딩
오버라이딩
섀도잉
하이딩
업스큐어링

이름을 재사용하면 코드를 이해하기 힘들어지므로 지양하는 것이 좋음

섀도잉

변수의 이름이 겹치면 자신과 가장 가까운 변수를 사용하게 됨

즉, 다음과 같은 경우 출력되는 number 는 메서드 내부의 변수 number 임

class Program
{
    public static int number = 10;

    static void Main(string[] args)
    {
        int number = 20;
        Console.WriteLine(number);
    }
}

이렇듯 특정한 영역에서 이름이 겹쳐 다른 변수를 가리는 것을 섀도잉 이라고 부름

어떤 대상이 섀도잉되면 일반적인 방법으로는 가려진 변수에 접근할 수 없음

하이딩

부모 클래스와 자식 클래스 간 동일한 이름의 멤버가 생성되었을 시 섀도잉과 같은 현상이 일어나는 것을 하이딩이라고 부름

즉, 다음과 같은 경우 출력되는 variable 은 자식 클래스의 변수 variable 임

class Program
{
    class Parent
    {
        public int variable = 273;
    }

    class Child : Parent
    {
        public string variable = "hiding";
    }

    static void Main(string[] args)
    {
        Child child = new Child();
        Console.WriteLine(Child.variable);
    }
}

하이딩을 하게 되면 정상적인 상속을 막아버릴 수 있음

이 경우 만약 부모 클래스에 있는 int 자료형의 변수를 사용하고 싶다면,

다음과 같이 부모로 자료형을 변환한 후 사용하면 됨

static void Main(string[] args)
{
    Child child = new Child();
    Console.WriteLine(((Parent)child).variable);
}

메서드 하이딩

메서드는 변수와 다르게 충돌이 발생할 때 하이딩할지 오버라이딩할지를 결정할 수 있음

하이딩과 오버라이딩

부모 클래스와 자식 클래스 멤버의 이름을 동일하게 작성할 때 하이딩 또는 오버라이딩이 일어나므로 두 경우를 명확하게 구분해주어야 함

하이딩은 멤버 전체(변수, 메서드 등)에서 모두 일어나지만, 오버라이딩은 메서드와 관련되어서만 일어남

new 메서드를 사용한 하이딩

하이딩 = 같은 이름으로 멤버를 만들어 부모의 멤버를 숨기는 것

숨겨져 있을 뿐이므로 클래스형을 변환하는 등의 작업을 하면 숨겨진 멤버를 찾을 수 있음

class Program
{
    class Parent
    {
        public int variable = 273;
        public void Method()
        {
            Console.WriteLine("부모의 메서드");
        }
    }

    class Child
    {
        public new string variable = "hiding";
        public new void Method()
        {
            Console.WriteLine("자식의 메서드");
        }
    }

    static void Main(string[] args)
    {
        Child child = new Child();
        child.Method();
        ((Parent).child).Method();
    }
}

new 키워드를 적지 않으면 경고가 발생하지만 실행은 됨

virtual 메서드와 override 메서드를 사용한 오버라이딩

오버라이딩 = 부모의 메서드를 덮어씌우는 것

자식의 메서드가 부모의 메서드를 완전히 덮어씌워버리므로, 부모로 클래스형을 변환한다해도 자식에서 다시 정의한 메서드가 호출됨

class Program
{
    class Parent
    {
        public virtual void Method()
        {
            Console.WriteLine("부모의 메서드");
        }
    }

    class Child : Parent
    {
        public override void Method()
        {
            Console.WriteLine("자식의 메서드");
        }
    }

    static void Main(string[] args)
    {
        Child child = new Child();
        child.Method();
        ((Parent)child).Method();
    }
}

하이딩과 오버라이딩의 활용

class Animal
{
    public virtual void Eat()
    {
        Console.WriteLine("냠냠 먹습니다.");
    }
}

class Dog : Animal
{
    public new void Eat()   // 하이딩
    {
        Console.WriteLine("강아지 사료를 먹습니다.");
    }
}

class Cat : Animal
{
    public override void Eat()  // 오버라이딩
    {
        Console.WriteLine("고양이 사료를 먹습니다.");
    }
}

static void Main(string[] args)
{
    List<Animal## Animals = new List<Animal>()
    {
        new Dog(), new Cat(), new Cat(), new Dog(),
        new Dog(), new Cat(), new Dog(), new Dog()
    };

    foreach (var item in Animals)
    {
        item.Eat();
    }
}

냠냠 먹습니다.
고양이 사료를 먹습니다.
고양이 사료를 먹습니다.
냠냠 먹습니다.
냠냠 먹습니다.
고양이 사료를 먹습니다.
냠냠 먹습니다.
냠냠 먹습니다.

상속과 오버라이딩 제한

클래스에 절대 상속하지 말라거나 반드시 상속하라는 정보를 입력하는 것

또한, 메서드에 더 이상 오버라이딩하지 말라거나 무조건 오버라이딩해달라는 정보를 입력하는 것

sealed 키워드

클래스 → 절대 상속하지 말 것

class Program
{
    sealed class Parent
    {
        public void Test() { }
    }

    class Child : Parent    // 오류 발생
    {
        public void Test() { }
    }
}

메서드 → 더 이상 오버라이딩하지 말 것

class Parent
{
    public virtual void Test() { }
}

class Child : Parent
{
    sealed public override void Test() { }
}

class GrandChild : Child
{
    public override void Test() { }     // 오류 발생
}

abstract 키워드

클래스 → 반드시 상속해서 쓸 것

해당 클래스 자체는 인스턴스를 만들어 사용할 수 없게 됨

class Program
{
    abstract class Parent
    {
        public void Test() { }
    }

    class Child : Parent
    {
        public void Test() { }
    }

    static void Main(string[] args)
    {
        Parent parent = new Parent();   // 오류 발생
        Child child = new Child();
    }
}

메서드 → 반드시 오버라이딩할 것

abstract 키워드를 메서드에 적용하려면 반드시 클래스에도 abstract 키워드를 적용해야 함

abstract 키워드를 적용한 메서드에는 { } 를 적지 않고 곧바로 세미콜론을 찍음 → 어차피 상속해서 사용할 것이므로 내용을 적지 않는 것

abstract class Parent
{
    public abstract void Test();
}

class Child : Parent
{
    public override void Test() { }     // 이처럼 오버라이딩해주면 오류가 발생하지 않음
}

abstract 키워드를 적용했다면 virtual 키워드는 적어주지 않아도 됨 (입력 시 오류 발생)

Author And Source

이 문제에 관하여(# 프로그래밍 - CH7 상속과 다형성), 우리는 이곳에서 더 많은 자료를 발견하고 링크를 클릭하여 보았다 https://velog.io/@sookyeongyeom/C-프로그래밍-CH7-상속과-다형성

우수한 개발자 콘텐츠 발견에 전념 (Collection and Share based on the CC Protocol.)