[Kotlin] 다양한 클래스

💡companion, data class, 중첩 클래스, enum, sealed💡

 

---

▪️companion

· 객체를 생성하지 않고 사용할 수 있다.

· 공통된 값이 많다면 companion을 사용하면 된다.

fun main() {
    // 객체를 생성해야 그 안의 내용들을 쓸 수 있음
    val obj = ComClass()

    println("obj.num1 : ${obj.num1}")
    obj.comFunction1()

    // companion은 객체를 생성하지 않고 바로 사용 가능
    println("obj.num2 : ${ComClass.num2}")
    ComClass.comFunction2()
}

class ComClass {
    var num1 = 100

    fun comFunction1() {
        println("comFunction1 호출")
    }

    companion object {
        var num2 = 200

        fun comFunction2() {
            println("comFunction2 호출")
        }
    }
}

 

 

▪️data class

· 매개체의 데이터를 관리하는 용도로 사용하는 클래스이다.

· 반드시 주 생성자를 가지고 있어야 한다.

fun main() {
    val obj1 = DatClass("짱구", 10)
    val obj2 = DatClass("철수", 20)
    val obj3 = DatClass("맹구", 30)

    println("obj1 : ${obj1.name}, ${obj1.age}")
    println("obj2 : ${obj2.name}, ${obj2.age}")
    println("obj3 : ${obj3.name}, ${obj3.age}")
}

data class DatClass(
    val name : String,
    val age : Int
)

 

 

▪️Generic

· 제네릭을 사용하면 객체 생성 시에 변수의 타입을 결정할 수 있다.

fun main() {
    val obj1 = GenClass1<Int>()
    obj1.genClass1function(100)

    val obj2 = GenClass2<Double>(100.0)
    obj2.genClass2function(200.0)

    val obj3 = GenClass3<Int, Double>()
    obj3.genClass3function(100, 100.0)

    val obj4 = GenClass4<Int, Double, String, Boolean>(100,100.0)
    obj4.genClass4function("가나다", false)
}

// 객체를 만들 때 <>안에 타입을 넣어준다면 해당 타입만 넣을 수 있음
class GenClass1<T> {
    fun genClass1function(what : T) {
        println("genClass1function what : $what")
    }
}

class GenClass2<T>(var what1 : T) {
    fun genClass2function(what2 : T) {
        println("GenClass2 what : $what1")
        println("genClass2function what : $what2")
    }
}

// 한 개 이상의 타입을 넣을 수 있음
class GenClass3<A, B> {
    fun genClass3function(what1 : A, what2 : B) {
        println("genClass3function what1 : $what1")
        println("genClass3function what2 : $what2")
    }
}

class GenClass4<A, B, C, D>(var what1 : A, var what2 : B) {
    fun genClass4function(what3 : C, what4 : D) {
        println("GenClass4 what1 : $what1")
        println("GenClass4 what2 : $what2")
        println("genClass4function what3 : $what3")
        println("genClass4function what4 : $what4")
    }
}

 

 

▪️중첩 클래스

· 클래스 안에 만드는 클래스를 중첩 클래스라고 부른다.

· class 앞에 inner 키워드를 작성하면 된다.

fun main() {
    // inner class의 객체를 생성하려면 상위 클래스의 객체를 먼저 생성해야 한다.
    val obj1 = InnClass1()
    val obj2 = obj1.InnClass2()

    obj2.innClass2Function()
}

class InnClass1 {
    inner class InnClass2 {
        fun innClass2Function() {
            println("innClass2Function 호출")
        }
    }
}

 

익명 중첩 클래스

· 이름이 없는 클래스를 익명 중첩 클래스라고 부른다.

· 인터페이스나 추상클래스를 사용할 때 이용된다.

· 이름이 없으므로 객체를 생성할 수 없다.

fun main() {
    val obj1 = InnClass1()
    obj1.innAbsFunction()

    val obj2 = InnClass2()
    obj2.innIntFunction()

    // 익명 중첩 클래스
    val obj3 = object : InnClass1() {
        override fun innAbsFunction() {
            println("익명 중첩 클래스의 innAbsFunction 호출")
        }
    }
    obj3.innAbsFunction()

    val obj4 = object : InnClass2() {
        override fun innIntFunction() {
            println("익명 중첩 클래스의 innIntFunction 호출")
        }
    }
    obj4.innIntFunction()
}

abstract class InnAbsClass {
    abstract fun innAbsFunction()
}

interface InnIntClass {
    fun innIntFunction()
}

// 추상 클래스를 상속받은 클래스
open class InnClass1 : InnAbsClass() {
    override fun innAbsFunction() {
        println("innAbsFunction 호출")
    }
}

// 인터페이스를 구현한 클래스
open class InnClass2 : InnIntClass {
    override fun innIntFunction() {
        println("innIntFunction 호출")
    }
}

 

 

▪️enum

· 열거형은 정의한 단어 자체가 프로그램에서 사용하는 값이 된다.

fun main() {
    enuFunction1(EnuClass1.SOUTH)
    enuFunction2(EnuClass2.TWO)
}

enum class EnuClass1 {
    NORTH, SOUTH, WEST, EAST
}

enum class EnuClass2(val num : Int, val str : String) {
    ONE(1,"하나"), TWO(2,"둘"), THREE(3,"셋")
}

fun enuFunction1(what : EnuClass1) {
    when(what) {
        EnuClass1.NORTH -> println("북쪽입니다.")
        EnuClass1.SOUTH -> println("남쪽입니다.")
        EnuClass1.WEST -> println("서쪽입니다.")
        EnuClass1.EAST -> println("동쪽입니다.")
    }
}

fun enuFunction2(what : EnuClass2) {
    when(what) {
        EnuClass2.ONE -> println("ONE입니다.")
        EnuClass2.TWO -> println("TWO입니다.")
        EnuClass2.THREE -> println("THREE입니다.")
    }

    // 분기가 가능
    when(what.num) {
        1 -> println("1입니다.")
        2 -> println("2입니다.")
        3 -> println("3입니다.")
    }

    when(what.str) {
        "하나" -> println("하나입니다.")
        "둘" -> println("둘입니다.")
        "셋" -> println("셋입니다.")
    }
}

 

 

▪️sealed

· sealed class는 객체를 모아 관리하는 클래스이다.

fun main() {
    val n1 = SeaClass.SealedTwo(1)
    checkNumber(n1)

    val n2= SeaClass.SealedTwo(2)
    checkNumber(n2)

    val n3= SeaClass.SealedThree(3, 3.0)
    checkNumber(n3)
}

sealed class SeaClass {
    class SealedOne(val num : Int) : SeaClass()
    // 메서드도 작성할 수 있음
    class SealedTwo(val num : Int) : SeaClass() {
        fun seaFunction() {
            println("seaFunction 호출")
        }
    }
    class SealedThree(val num : Int, val num2 : Double) : SeaClass()
}

fun checkNumber(number : SeaClass) {
    when(number) {
        // 클래스타입 검사는 is를 쓰면 됨
        is SeaClass.SealedOne -> {
            println("SealedOne")
            println(number.num)
        }

        is SeaClass.SealedTwo -> {
            println("SealedTwo")
            println(number.num)

            when(number.num) {
                1 -> println("1입니다.")
                2 -> println("2입니다.")
                3 -> println("3입니다.")
            }

            number.seaFunction()
        }

        is SeaClass.SealedThree -> {
            println("SealedThree")
            println(number.num)

            when(number.num) {
                3 -> println("3입니다.")
            }

            when(number.num2) {
                3.0 -> println("3.0입니다.")
            }
        }
    }
}

 

---