[Kotlin] Interface와 Class

Interface

특징

• 다중 상속 가능
• 추상함수(Abstract) 가질 수 있음
• 함수 본문 구현 가능
• 여러 interface에서 같은 함수 가질 수 있음
• 추상 property 가질 수 있음

다중 상속

여러 인터페이스에 동일한 이름의 추상 함수가 선언되어 있다.

이 때, 다중 상속한 클래스에서는 어떻게 구분해서 호출하는지 다음을 보면 알 수 있다.

fun main(args: Array<String>) {
	val base: Base = Base()
    base.printA() // AAAAA
    base.printB() // BBBBB
    base.printC() // ACAC\nBCBC
}


interface A {
    fun printA() {
    	println("AAAAA")
    }
    
    fun printC() {
    	println("ACAC")
    }
}

interface B {
	fun printB() {
    	println("BBBBB")
    }
    
    fun printC() {
    	println("BCBC")
    }
}

class Base: A, B {
	override fun printC() {
    	super<A>.printC()
        super<B>.printC()
    }
}

추상 Property

fun main(args: Array<String>) {
	val s: Student = Student()
    println(s.age) // "5"
}

interface Person {
	val age: Int
    
    fun printAny() {
    	println("Person")
    }
}

class Student: Person {
	override val age: Int = 5
}

Class 

class Person(var name: String, val age: Int)

val p = Person("bin", "29")
println(p.name) // "bin"

var: getter / setter 이용 가능

val: getter만 이용 가능

Data Class

이게 있어서 Java를 이용할 때 Lombok에서의 Data 어노테이션 등등이 필요가 없어진다.

• getter / setter 함수 생성
• hashCode(), equals(), toString() 생성
• copy(), componentN() 함수 생성
  • copy(): 객체 복사
  • componentN(): 객체가 가진 프로퍼티 개수만큼 호출 가능
    • component1(): 객체의 첫 번째 프로퍼티 값 반환

코틀린의 특성으로 인해 builder 어노테이션도 필요가 없어진다.

Object Class

Java에서는 직접 싱글턴 클래스를 만들어야 했지만, 코틀린에서는 object로 만들 수 있다.

호출 시에 메모리에 적재하도록 Lazy 처리를 직접 하기도 했지만

코틀린의 object를 이용하면 해당 클래스는 프로세스 실행 시에 메모리에 올라가게 된다.

object class ExcelUtils {
	...
}

용량이 큰 내부 변수들에 대해 lazy 키워드로 처리하는 것으로 어느 정도 해결할 수 있다.

Enum Class

프로퍼티와 함수가 모두 타입이 동일해야 한다는 제약이 있다.

enum class Error(val num: Int) {
	WARN(1) {
    	override fun getErrorName(): String {
        	return "WARN"
        }
    },
    
    ERROR(2) {
    	override fun getErrorName(): String {
        	return "ERROR"
        }
    },
    
    FAULT(3) {
    	override fun getErrorName(): String {
        	return "FAULT"
        }
    };
    
    abstract fun getErrorName(): String
}

Sealed Class

• 위의 제약 없이 새로운 타입을 확장할 수 있는 클래스
• enum의 확장 형태이며, 클래스를 묶은 클래스다.
• 1개 이상의 객체를 사용할 수 있다.

sealed class Expr {
	data class Const(val number: Double): Expr()
    data class Sum(val e1: Expr, val e2: Expr): Expr()
    object NotANumber: Expr()
}

fun eval(expr: Expr): Double = when(expr) {
	is Const -> expr.number
    is Sum -> eval(expr.e1) + eval(expr.e2)
    NotANumber -> Double.NaN
    // 모든 케이스를 커버할 수 있기 때문에 else가 없어도 컴파일 타임 오류가 발생하지 않는다.
}


//....

val sum = Sum(Const(5.0), Const(8.0)) // 다양한 Const 객체 생성, Sum 객체 생성
val result = eval(sum)
println(result) // 13.0

잘 보면 Enum과 다르게 다양한 프로퍼티를 가진 클래스를 정의하고,  이용할 수 있다.