Kotlin 클래스와 객체지향 프로그래밍

Kotlin 클래스와 객체지향 프로그래밍

코틀린(Kotlin)은 객체지향 프로그래밍(Object-Oriented Programming, OOP)을 기본적으로 지원하는 언어입니다. 객체지향 프로그래밍은 데이터와 관련된 기능을 하나의 단위로 묶어, 코드의 재사용성과 유지보수성을 높이는 방법론입니다. 이번 포스팅에서는 클래스와 객체, 생성자와 초기화, 상속과 인터페이스에 대해 예제와 함께 살펴보겠습니다.

클래스와 객체

코틀린에서 클래스는 객체를 생성하기 위한 청사진 역할을 합니다. 클래스는 속성(properties)과 메서드(methods)로 구성되며, 이러한 요소들을 하나로 묶어 데이터와 행동을 정의합니다. 객체는 클래스를 기반으로 만들어진 실체입니다. 아래는 간단한 클래스와 객체를 만들어 보는 예제입니다.

class Person(val name: String, var age: Int) {
    fun introduce() {
        println("안녕하세요, 저는 \$name이고, 나이는 \$age살입니다.")
    }
}

fun main() {
    val person = Person("홍길동", 25)
    person.introduce()
}

위 코드에서 Person 클래스는 name과 age라는 두 속성을 가지고 있습니다. introduce 메서드는 이름과 나이를 출력하는 역할을 합니다. main 함수에서 Person 클래스를 이용해 person 객체를 생성하고, introduce 메서드를 호출하여 정보를 출력합니다.

생성자와 초기화

클래스의 생성자는 객체를 생성할 때 초기화를 담당합니다. 코틀린에서는 주 생성자(primary constructor)와 보조 생성자(secondary constructor)를 사용할 수 있습니다. 주 생성자는 클래스의 정의와 함께 선언되며, 보조 생성자는 추가적인 생성 방법을 제공할 때 사용됩니다.

주 생성자

주 생성자는 클래스 이름 뒤에 괄호로 선언됩니다. 아래 예제는 Car 클래스를 정의하고, 주 생성자를 이용해 초기화하는 방법을 보여줍니다.

class Car(val brand: String, val model: String, val year: Int) {
    fun displayInfo() {
        println("브랜드: \$brand, 모델: \$model, 연식: \$year")
    }
}

fun main() {
    val car = Car("현대", "소나타", 2023)
    car.displayInfo()
}

Car 클래스는 brand, model, year라는 세 속성을 가지고 있으며, 생성 시 초기화됩니다. displayInfo 메서드를 통해 자동차 정보를 출력할 수 있습니다.

보조 생성자

보조 생성자는 constructor 키워드를 사용하여 정의됩니다. 보조 생성자는 주 생성자를 호출하거나 추가적인 초기화 로직을 정의할 때 유용합니다.

class Student(val name: String, val grade: Int) {
    constructor(name: String) : this(name, 1) {
        println("보조 생성자를 통해 학생이 생성되었습니다.")
    }

    fun displayInfo() {
        println("학생 이름: \$name, 학년: \$grade")
    }
}

fun main() {
    val student1 = Student("김철수", 3)
    student1.displayInfo()

    val student2 = Student("이영희")
    student2.displayInfo()
}

위 코드에서 Student 클래스는 name과 grade를 속성으로 가지며, 보조 생성자를 통해 학년이 지정되지 않은 학생을 자동으로 1학년으로 초기화합니다.

상속과 인터페이스

코틀린에서는 상속을 사용하여 기존 클래스의 기능을 확장할 수 있습니다. 상속은 코드의 재사용성을 높이고, 공통 기능을 부모 클래스에 정의하여 자식 클래스들이 이를 공유하도록 합니다. 코틀린의 클래스는 기본적으로 final이므로, 상속을 위해서는 open 키워드를 사용해야 합니다.

클래스 상속

아래 예제는 Animal 클래스를 상속받아 Dog 클래스를 정의하는 방법을 보여줍니다.

open class Animal(val name: String) {
    open fun sound() {
        println("동물이 소리를 냅니다.")
    }
}

class Dog(name: String) : Animal(name) {
    override fun sound() {
        println("\$name가 멍멍 짖습니다.")
    }
}

fun main() {
    val dog = Dog("바둑이")
    dog.sound()
}

Animal 클래스는 name 속성을 가지고 있으며, sound 메서드는 동물의 소리를 출력합니다. Dog 클래스는 Animal 클래스를 상속받고, sound 메서드를 재정의하여 강아지의 소리를 출력합니다.

인터페이스

인터페이스는 클래스가 구현해야 하는 함수의 집합을 정의합니다. 코틀린에서 인터페이스는 다중 상속이 가능하며, 클래스와 달리 상태를 가질 수 없습니다.

아래 예제는 Flyable 인터페이스를 정의하고, Bird 클래스에서 이를 구현하는 방법을 보여줍니다.

interface Flyable {
    fun fly()
}

class Bird(val name: String) : Flyable {
    override fun fly() {
        println("\$name가 하늘을 납니다.")
    }
}

fun main() {
    val bird = Bird("참새")
    bird.fly()
}

Flyable 인터페이스는 fly 메서드를 정의하며, Bird 클래스는 이를 구현하여 새가 나는 행동을 정의합니다. 인터페이스를 사용하면 여러 클래스에서 동일한 기능을 강제할 수 있어 일관성을 유지하는 데 유용합니다.

예제와 함께 클래스 활용하기

마지막으로 클래스와 객체지향 개념을 이용하여 간단한 예제를 만들어 보겠습니다. 이번 예제에서는 동물원 프로그램을 작성해 봅니다.

open class Animal(val name: String, val type: String) {
    open fun introduce() {
        println("저는 \$type인 \$name입니다.")
    }
}

class Lion(name: String) : Animal(name, "사자") {
    override fun introduce() {
        println("저는 용맹한 사자, \$name입니다.")
    }
}

class Elephant(name: String) : Animal(name, "코끼리") {
    override fun introduce() {
        println("저는 큰 귀를 가진 코끼리, \$name입니다.")
    }
}

fun main() {
    val animals = listOf(Animal("동물1", "알 수 없는 동물"), Lion("레오"), Elephant("엘리"))
    for (animal in animals) {
        animal.introduce()
    }
}

위 예제에서는 Animal 클래스를 기본으로, Lion과 Elephant 클래스를 상속받아 각각의 동물 소개 방식을 재정의했습니다. main 함수에서 다양한 동물 객체를 생성하고 소개하는 모습을 확인할 수 있습니다.

마무리

이번 포스팅에서는 코틀린에서 클래스와 객체지향 프로그래밍을 사용하는 방법에 대해 살펴보았습니다. 클래스와 객체의 기본 개념부터 생성자, 상속, 인터페이스까지 다양한 예제와 함께 학습해 보았습니다. 객체지향 프로그래밍은 코드의 재사용성과 유지보수성을 높이는 데 중요한 개념이므로, 다양한 예제를 통해 익혀보시기 바랍니다.