23. 상속, 코드 재활용, 기반 클래스, 파생 클래스, base, sealed

클래스는 다른 클래스로부터 유산을 물려받을 수 있다.(필드, 메소드, 프로퍼티 같은 멤버들)

 

파생 클래스는 객체를 생성할 때 내부적으로 기반 클래스의 생성자를 먼저 호출한 뒤에 자신의 생성자를 호출하고,

객체가 소멸될 때는 반대의 순서로(파생클래스 -> 기반 클래스)종료자를 호출한다. 

 

: 기반 클래스 먼저 생성되고 마지막까지 버티다 가장 나중에 종료자 호출함!

 

만약 기반 클래스의 생성자가 매개변수를 입력받도록 선언되어 있다면

파생 클래스의 인스턴스를 생성할 때 호출되는 기반 클래스의 생성자에는 어떻게 매개변수를 전달할 수 있을까.

이럴 때 base 키워드를 사용하면 된다.

this 키워드가 "자기 자신"을 가리킨다면 base는 "기반 클래스"를 가리킨다.

this를 통해 자기 자신의 멤버에 접근할 수 있었던 것처럼,

base 키워드를 통해 기반 클래스의 멤버에 접근할 수 있다. 

 

base()는 기반 클래스의 생성자이다.

파생 클래스의 생성자에서 기반 클래스의 생성자로 매개변수를 넘겨주기 위해서는...

이것 역시 this와 같다.

this()가 자기 자신의 생성자인 것 처럼, base()는 기반 클래스의 생성자이다.

base()에 매개 변수를 넘겨 호출하면 원했던 것처럼 Base() 생성자를 통해 Name 필드를 초기화할 수 있다.

this() 자기 자신의 생성자인 것 처럼, base()는 기반 클래스의 생성자이다.

base()에 매개변수를 넘겨 호출하면

기반 클래스 생성자를 통해 필드를 초기화할 수 있다.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static System.Console;

namespace UsingOut
{
    class Base
    {
        protected string Name;
        public Base(string Name)
        {
            this.Name = Name;
        }
        ~Base()
        {
            WriteLine("~Base()");
        }
        protected void BaseMethod()
        {
            WriteLine("Unity");
        }
    }

    class Derived : Base 
    {
        public Derived(string Name) : base(Name)
        {
            WriteLine($"{this.Name}");
        }
        ~Derived()
        {
            WriteLine("~Derived()");
        }
    }

    class MainApp
    {
        static void Main(string[] args)
        {
            Derived derived = new Derived("1");
        }
    }
}

<예제>

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static System.Console;

namespace UsingOut
{
    class Base
    {
        protected string Name;
        public Base(string Name) //기반 클래스 생성자
        {
            this.Name = Name;
            WriteLine($"{this.Name}.Base()");
        }
        ~Base()
        {
            WriteLine($"{this.Name}.~Base");
        }
        public void BaseMethod()
        {
            WriteLine($"{Name}.BaseMethod()");
        }
    }

    class Derived : Base
    {
        public Derived(string Name) : base(Name)
        {
            WriteLine($"{this.Name}.Derived()");
        }
        ~Derived()
        {
            WriteLine($"{this.Name}.~Derived()");
        }
        public void derivedMethod()
        {
            WriteLine($"{Name}.DerivedMethod()");
        }
    }

    class MainApp
    {
        static void Main(string[] args)
        {
            Base a = new Base("a");
            a.BaseMethod();

            Derived b = new Derived("b");
            b.BaseMethod();
            b.derivedMethod();

        }
    }
}

<예제 출력>

a.Base()
a.BaseMethod()
b.Base()
b.Derived()
b.BaseMethod()
b.DerivedMethod()
b.~Derived()
b.~Base
a.~Base

<연습 코드>

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static System.Console;

namespace UsingOut
{
    class Parent
    {
        protected int id;
        public Parent(int id)
        {
            this.id = id;
            WriteLine($"{this.id}.Parent()");
        }
        ~Parent()
        {
            WriteLine($"{this.id}.Parent 퇴장");
        }
        public void parentMethod()
        {
            WriteLine($"{id}.parentMethod()");
        }
    }

    class Child : Parent
    { 
        public Child(int id) : base(id)
        {
            WriteLine($"{this.id}.Child()");
        }
        ~Child()
        {
            WriteLine($"{this.id}.Child 퇴장");
        }
        public void childMethod()
        {
            WriteLine($"{id}.childMethod");
        }
    }

    class MainApp
    {
        static void Main(string[] args)
        {
            Parent parent = new Parent(1);
            parent.parentMethod();

            Child child = new Child(2);
            child.parentMethod();
            child.childMethod();
        }
    }
}

<연습 코드 출력 결과>

1.Parent()
1.parentMethod()
2.Parent()
2.Child()
2.parentMethod()
2.childMethod
2.Child 퇴장
2.Parent 퇴장
1.Parent 퇴장

 

 

<실험 1>

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static System.Console;

namespace UsingOut
{
    class Base
    {
        public Base()
        {
            WriteLine("Base()");
        }
        ~Base()
        {
            WriteLine("~Base()");
        }
    }

    class Derived : Base 
    {
        public Derived()
        {
            WriteLine("Derived()");
        }
        ~Derived()
        {
            WriteLine("~Derived()");
        }
    }

    class MainApp
    {
        static void Main(string[] args)
        {
            Derived derived = new Derived();
        }
    }
}

<실험 1 출력 결과>

Base()
Derived()
~Derived()
~Base()

<실험 2>

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static System.Console;

namespace UsingOut
{
    class Base
    {
        public Base()
        {
            WriteLine("Base()");
        }
        ~Base()
        {
            WriteLine("~Base()");
        }
        protected void BaseMethod()
        {
            WriteLine("Unity");
        }
    }

    class Derived : Base 
    {
        public Derived()
        {
            base.BaseMethod();
            WriteLine("Derived()");
        }
        ~Derived()
        {
            WriteLine("~Derived()");
        }
    }

    class MainApp
    {
        static void Main(string[] args)
        {
            Derived derived = new Derived();
        }
    }
}

<실험 2 출력 결과>

Base()
Unity
Derived()
~Derived()
~Base()

<실험 3>

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static System.Console;

namespace UsingOut
{
    class Base
    {
        protected string Name;
        public Base(string Name)
        {
            this.Name = Name;
        }
        ~Base()
        {
            WriteLine("~Base()");
        }
        protected void BaseMethod()
        {
            WriteLine("Unity");
        }
    }

    class Derived : Base 
    {
        public Derived(string Name) : base(Name)
        {
            WriteLine($"{this.Name}");
        }
        ~Derived()
        {
            WriteLine("~Derived()");
        }
    }

    class MainApp
    {
        static void Main(string[] args)
        {
            Derived derived = new Derived("1");
        }
    }
}

<실험 3 출력 결과>

1
~Derived()
~Base()

<sealed>

기반 클래스의 작성자는 의도하지 않은 상속이나 파생 클래스의 구현을 막기 위해 상속이 불가능하도록 클래스를 선언할 수 있다. sealed 한정자를 이용하면 된다.

sealed 한정자로 클래스를 수식하면, 이 클래스는 "상속 봉인"(이런 클래스를 봉인 클래스라고 한다)이 되어

이로부터 상속받으려는 시도가 컴파일러로부터 발견됐을 때 에러메시지가 출력된다. 

 

<sealed때문에 컴파일 에러나는 예제>

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static System.Console;

namespace UsingOut
{
    sealed class Base
    {
        protected string Name;
        public Base(string Name)
        {
            this.Name = Name;
        }
        ~Base()
        {
            WriteLine("~Base()");
        }
        protected void BaseMethod()
        {
            WriteLine("Unity");
        }
    }

    class Derived : Base 
    {
        public Derived(string Name) : base(Name)
        {
            WriteLine($"{this.Name}");
        }
        ~Derived()
        {
            WriteLine("~Derived()");
        }
    }

    class MainApp
    {
        static void Main(string[] args)
        {
            Derived derived = new Derived("1");
        }
    }
}

<기반 클래스와 파생 클래스 사이의 형식 변환, 그리고 is와 as>

개와 고양이는 종은 다르지만 젖을 먹인다는 공통점 때문에 포유류로 분류된다.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static System.Console;

namespace UsingOut
{
    class Mammal
    {
        public void Nurse() { }
    }
    class Dog: Mammal
    {
        public void Bark() { }
    }
    class Cat: Mammal
    {
        public void Meow() { }
    }

    class MainApp
    {
        static void Main(string[] args)
        {
            Mammal mammal = new Mammal();
            mammal.Nurse();

            Dog dog = new Dog();
            dog.Nurse();
            dog.Bark();

            Cat cat = new Cat();
            cat.Nurse();
            cat.Meow();
        }
    }
}

기반 클래스와 파생 클래스 사이에서는 족보를 오르내리는 형식 변환이 가능하며,

파생 클래스의 인스턴스는 기반 클래스의 인스턴스로서도 사용할 수 있다.

이를 통해 코드의 생산성이 높아진다. 

 

-동물원의 예시-

Mammal 클래스에서 300가지의 클래스가 파생되었다고 치고,

동물원의 사육사 클래스를 만들고 동물들을 씻기는 Wash()메소드를 구현한다고 생각해보자.

다음과 같이 300개의 Wash()메소드를 오버로딩해야 한다.

 

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static System.Console;

namespace UsingOut
{
    class ZooKeeper
    {
        public void Wash(Dog dog) {/*~Wash 메소드 내용~*/ }
        public void Wash(Cat cat) {/*~Wash 메소드 내용~*/ }
        public void Wash(Rabbit rabbit) {/*~Wash 메소드 내용~*/ }
        public void Wash(Whale whale) {/*~Wash 메소드 내용~*/ }
        
        //등등... 300개 버전의 Wash() 메소드 선언

    }
    class Mammal
    {
        public void Nurse() { }
    }
    class Dog: Mammal
    {
        public void Bark() { }
    }
    class Rabbit : Mammal
    {
        public void Jump() { }
    }
    class Whale : Mammal
    {
        public void Swim() { }
    }
    class Cat : Mammal
    {
        public void Meow() { }
    }
    class MainApp
    {
        static void Main(string[] args)
        {
            Mammal mammal = new Mammal();
            mammal.Nurse();

            mammal = new Dog();
            mammal.Nurse();

            Dog dog = (Dog)mammal;
            dog.Nurse();
            dog.Bark();

            mammal = new Cat();
            mammal.Nurse();

            Cat cat = (Cat)mammal;
            cat.Nurse();
            cat.Meow();
        }
    }
}

하지만 300개의 동물 클래스가 모두 Mammal 클래스로부터 상속받았기 때문에

이들은 모두 Mammal로 간주할 수 있다.

따라서 다음과 같이 딱 하나의 Wash()메소드만 준비하면 300개의 동물 클래스에 사용이 가능하다.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static System.Console;

namespace UsingOut
{
    class ZooKeeper
    {
        public void Wash(Mammal mammal) {/*~Wash 메소드 내용~*/ }


    }
    class Mammal
    {
        public void Nurse() { }
    }
    class Dog: Mammal
    {
        public void Bark() { }
    }
    class Rabbit : Mammal
    {
        public void Jump() { }
    }
    class Whale : Mammal
    {
        public void Swim() { }
    }
    class Cat : Mammal
    {
        public void Meow() { }
    }
    class MainApp
    {
        static void Main(string[] args)
        {
            Mammal mammal = new Mammal();
            mammal.Nurse();

            mammal = new Dog();
            mammal.Nurse();

            Dog dog = (Dog)mammal;
            dog.Nurse();
            dog.Bark();

            mammal = new Cat();
            mammal.Nurse();

            Cat cat = (Cat)mammal;
            cat.Nurse();
            cat.Meow();
        }
    }
}