코틀린에서 상속을 구현하는 방법은?

Q1: 코틀린에서 클래스 상속을 어떻게 선언하나요?
A1: 코틀린에서 클래스는 기본적으로 final이기 때문에 상속하려면 부모 클래스에 `open` 키워드를 붙여야 합니다. 자식 클래스는 콜론(`:`)과 함께 부모 클래스 이름을 명시하여 상속합니다.
```kotlin
open class Parent
class Child : Parent()
```

Q2: 상속받은 부모 클래스의 생성자를 호출하는 방법은?
A2: 자식 클래스 생성자에서 부모 클래스 생성자를 호출하려면 부모 클래스 이름 뒤에 괄호를 붙여 인자를 전달합니다.
```kotlin
open class Parent(val name: String)
class Child(name: String) : Parent(name)
```

Q3: 코틀린에서 메서드, 프로퍼티를 오버라이드하려면?
A3: 부모 클래스 멤버에 `open` 키워드를 붙여 오버라이드 가능하도록 하고, 자식 클래스에서는 `override` 키워드를 반드시 붙여 오버라이드합니다.
```kotlin
open class Parent {
open fun greet() { println("Hello") }
}

class Child : Parent() {
override fun greet() { println("Hi") }
}
```

Q4: 다중 상속은 가능한가요?
A4: 코틀린은 클래스 다중 상속을 지원하지 않지만, 여러 인터페이스를 구현하는 다중 인터페이스 상속은 가능합니다.
```kotlin
interface A
interface B
class C : A, B
```

Q5: 부모 클래스의 open 멤버를 오버라이드하면서 부모 구현을 호출하려면?
A5: `super` 키워드를 사용해 부모 구현을 호출할 수 있습니다.
```kotlin
open class Parent {
open fun greet() { println("Hello") }
}
class Child : Parent() {
override fun greet() {
super.greet()
println("Hi")
}
}
```

Q6: 상속 시 생성자에 기본값이 있는 경우 어떻게 처리하나요?
A6: 부모 생성자에 기본값이 있으면 자식 클래스가 인자를 전달하지 않아도 부모 생성자가 호출됩니다.
```kotlin
open class Parent(val name: String = "Default")
class Child : Parent()
```

Q7: 추상 클래스와 상속은 어떻게 사용하나요?
A7: `abstract` 키워드를 사용해 추상 클래스를 만들고, 추상 멤버는 자식 클래스에서 반드시 구현해야 합니다.
```kotlin
abstract class Parent {
abstract fun greet()
}

class Child : Parent() {
override fun greet() { println("Hi") }
}
```

Q8: 상속과 가시성(modifier)은 어떻게 작용하나요?
A8: 기본 가시성은 `public`이며, `private` 멤버는 상속 불가, `protected` 멤버는 자식 클래스에서 접근 가능합니다.

Q9: sealed 클래스와 상속의 관계는?
A9: `sealed` 클래스는 제한된 상속 계층을 만들어, 같은 파일 내부에서만 자식 클래스를 정의할 수 있습니다.

요약:
- 부모 클래스는 `open` 또는 `abstract`로 선언해야 상속 가능
- 자식 클래스에서 부모 생성자를 반드시 호출
- 멤버를 오버라이드하려면 부모 멤버도 `open`, 자식에서는 `override` 사용
- 다중 클래스 상속 불가, 인터페이스 다중 상속 가능
- `super`로 부모 구현 호출 가능
- 추상 클래스, sealed 클래스로 상속 구조 제어 가능

코틀린(Kotlin)은 객체 지향 프로그래밍 언어로, 클래스와 상속을 지원합니다.

상속은 기존 클래스의 속성과 메서드를 새로운 클래스에서 재사용할 수 있게 해주는 기능으로, 코드의 재사용성을 높이고 유지보수를 용이하게 합니다.

코틀린에서 상속을 구현하는 방법에 대해 자세히 살펴보겠습니다.

1. 클래스 선언 코틀린에서 클래스를 선언할 때는 `class` 키워드를 사용합니다.

기본적으로 클래스는 `final`로 선언되며, 상속을 허용하려면 `open` 키워드를 사용해야 합니다.

```kotlin open class Animal { open fun sound() { println("Some sound") } } ``` 위의 예제에서 `Animal` 클래스는 `open`으로 선언되어 있어 다른 클래스에서 상속할 수 있습니다.

또한, `sound` 메서드도 `open`으로 선언되어 있어 자식 클래스에서 오버라이드할 수 있습니다.



2. 상속 구현 상속을 구현하려면, 자식 클래스에서 부모 클래스의 이름을 지정하고 `:` 기호를 사용합니다.

자식 클래스에서 부모 클래스의 메서드를 오버라이드하려면 `override` 키워드를 사용해야 합니다.

```kotlin class Dog : Animal() { override fun sound() { println("Bark") } } class Cat : Animal() { override fun sound() { println("Meow") } } ``` 위의 코드에서 `Dog` 클래스와 `Cat` 클래스는 `Animal` 클래스를 상속받습니다.

각 클래스는 `sound` 메서드를 오버라이드하여 자신만의 구현을 제공합니다.



3. 상속의 사용 상속을 통해 생성된 객체는 부모 클래스의 속성과 메서드를 사용할 수 있습니다.

다음은 상속을 활용한 예제입니다.

```kotlin fun main() { val dog: Animal = Dog() val cat: Animal = Cat() dog.sound() // 출력: Bark cat.sound() // 출력: Meow } ``` 위의 `main` 함수에서 `Dog`와 `Cat` 객체를 생성하고, 각각의 `sound` 메서드를 호출합니다.

각 객체는 자신이 오버라이드한 메서드의 구현을 사용합니다.



4. 생성자와 상속 부모 클래스의 생성자를 호출하려면 자식 클래스의 주 생성자에서 `super` 키워드를 사용합니다.

부모 클래스가 매개변수를 가진 생성자를 가질 경우, 자식 클래스에서 이를 호출해야 합니다.

```kotlin open class Animal(val name: String) { open fun sound() { println("Some sound") } } class Dog(name: String) : Animal(name) { override fun sound() { println("$name says Bark") } } class Cat(name: String) : Animal(name) { override fun sound() { println("$name says Meow") } } ``` 위의 예제에서 `Animal` 클래스는 `name`이라는 속성을 가지고 있으며, `Dog`와 `Cat` 클래스는 이를 상속받아 생성자에서 `super(name)`을 통해 부모 클래스의 생성자를 호출합니다.



5. 다중 상속 코틀린은 클래스의 다중 상속을 지원하지 않지만, 인터페이스를 통해 다중 상속의 기능을 제공합니다.

인터페이스는 `interface` 키워드를 사용하여 정의하며, 클래스는 여러 개의 인터페이스를 구현할 수 있습니다.

```kotlin interface Pet { fun play() } class Dog(name: String) : Animal(name), Pet { override fun sound() { println("$name says Bark") } override fun play() { println("$name is playing") } } ``` 위의 예제에서 `Dog` 클래스는 `Animal` 클래스를 상속받고, `Pet` 인터페이스를 구현합니다.

이로 인해 `Dog` 클래스는 `sound` 메서드와 `play` 메서드를 모두 구현해야 합니다.



6. 추상 클래스와 상속 추상 클래스는 `abstract` 키워드를 사용하여 정의하며, 인스턴스를 생성할 수 없습니다.

추상 클래스는 자식 클래스에서 반드시 구현해야 하는 추상 메서드를 가질 수 있습니다.

```kotlin abstract class Animal { abstract fun sound() } class Dog : Animal() { override fun sound() { println("Bark") } } ``` 위의 예제에서 `Animal` 클래스는 추상 클래스이며, `sound` 메서드는 추상 메서드로 선언되어 있습니다.

`Dog` 클래스는 이를 오버라이드하여 구현해야 합니다.

결론 코틀린에서 상속은 객체 지향 프로그래밍의 핵심 개념 중 하나로, 코드의 재사용성과 유지보수성을 높이는 데 큰 역할을 합니다.

`open` 키워드를 사용하여 클래스를 상속 가능하게 만들고, `override` 키워드를 통해 메서드를 오버라이드하여 자식 클래스에서 새로운 기능을 추가할 수 있습니다.

또한, 인터페이스와 추상 클래스를 활용하여 다중 상속과 강제 구현을 통해 유연한 설계를 할 수 있습니다.

이러한 기능들을 적절히 활용하면 더욱 효율적이고 관리하기 쉬운 코드를 작성할 수 있습니다.