Kotlin 다양한 클래스와 인터페이스

추상 클래스와 인터페이스

추상 클래스는 선언 등의 대략적인 설계 명세와 공통의 기능을 구현한 클래스를 의미합니다. 인터페이스도 추상 클래스와 같은 역할을 하지만, 둘 사이에는 명확한 차이가 존재합니다.

이제부터 어떤 부분이 비슷하고 어떤 부분이 다른지 차근차근 알아봅시다.

추상 클래스(abstract class)

추상 클래스의 선언과 구현

추상 클래스는 class 앞에 abstract 키워드를 붙여서 선언할 수 있습니다. 추상 클래스는 추상 메서드와 프로퍼티를 가질 수 있습니다.

abstract class Temp {
	abstract val t: Int // 추상 프로퍼티
    abstract fun temp() // 추상 메서드
}

추상 클래스는 추상 프로퍼티와 메서드처럼 구현이 완료되지 않은 부분이 존재하기 때문에 인스턴스로 만들 수 없고 반드시 하위 클래스에 상속하여 사용하여야 합니다.

추상 클래스를 상속 받는 하위 클래스에서는 추상 클래스가 가지고 있는 모든 추상 메서드와 추상 프로퍼티를 오버라이딩 해야합니다.

abstract class Human {
    abstract var name: String
    abstract var age: Int
    abstract var job: String
    val hands = 2
    val legs = 2
    abstract fun work()
    fun eat() { println("eating....") }
}

class Programmer(override var name: String, override var age: Int): Human() {
    override var job: String = "programmer"
    override fun work() {
        println("coding....")
    }
}

fun main() {
//    val human = Human() 추상 클래스는 인스턴스화 될 수 없음.
    val programmer = Programmer("seongjki", 10)
    programmer.work() // "coding...."
    programmer.eat() // "eating...." 일반 메서드로 오버라이딩 하지 않아도 사용 가능
}

인터페이스

인터페이스는 추상 클래스와 비슷한 점이 많습니다. 인터페이스도 추상 메서드와 프로퍼티를 가질 수 있고 일반 메서드도 가질 수 있습니다. 하지만 일반 프로퍼티를 가질 수는 없습니다.

인터페이스와 추상 클래스의 차이점이 하나 더 있습니다. 추상 클래스는 일반 클래스와 마찬가지로 다중 상속이 불가능합니다. 반면, 인터페이스는 다중 상속이 가능합니다.

인터페이스의 선언과 구현

인터페이스는 interface 키워드를 사용하여 선언할 수 있습니다.

interface 인터페이스 이름: 상속받을 인터페이스 이름 {
	....
}

추상 클래스를 설명하면서 만들었던 예제를 인터페이스로 바꿔서 만들어 보겠습니다.

interface HumanInter {
    var name: String
    var age: Int
    var job: String
//    val hands = 2 인터페이스는 추상 프로퍼티가 아닌 프로퍼티는 가질 수 없음
//    val legs = 2
    fun work()
    fun eat() { println("eating....") }
}

class Programmer(override var name: String, override var age: Int): HumanInter {
    override var job: String = "programmer"
    override fun work() {
        println("coding....")
    }
}

인터페이스는 프로퍼티와 메서드를 선언하면 자동으로 abstract로 선언됩니다. 여기서 메서드는 인터페이스에서 구현을 하면 abstract가 아닌 일반 메서드가 됩니다. 하지만 프로퍼티는 일반 프로퍼티가 될 수 없기 때문에 주의해야 합니다.

추상클래스와 마찬가지로 인터페이스를 구현하는 클래스는 인터페이스의 추상 프로퍼티와 메서드를 모두 구현해야합니다.

Functional interface(SAM interface)

인터페이스가 단 하나의 추상 메서드만을 가지고 있으면 그 인터페이스를 Functional interface로 선언할 수 있습니다.

functional interface는 interface 앞에 fun 키워드를 사용하여 선언합니다.

fun interface 인터페이스 이름 {
	fun 함수 이름
}

functional interface의 조건

• functional interface는 프로퍼티를 가질 수 없습니다.
• functional interface는 추상 메서드는 단 하나만 가질 수 있다.

functional interface의 특징

functional interface은 람다를 사용하여 구현할 수 있습니다.

fun interface Inter {
    fun doing()
    fun none() {
        println("none")
    }
}

fun main() {
	val interImpl = Inter {
    	println("doing")
    }
    
    interImpl.doing() // "doing"
    interImpl.none() // "none"
}

인터페이스의 위임

인터페이스를 구현하는 클래스에서 인터페이스의 구현을 다른 클래스에 위임할 수 있습니다.

interface Inter {
    fun doing()
}
class A: Inter {
    override fun doing() {
        println("AAAAAAAA")
    }
}
class B: Inter by A() {}

fun main() {
    B().doing() // AAAAAAAA
}

이러한 위임은 어떤 방식으로 작동하는 걸까요? 위의 예제를 통해 알아봅시다.

class B: Inter by A() 구문을 통해 컴파일러는 Inter라는 인터페이스를 A()를 통해 구현할 것이라는 사실을 알고 class B에 A를 private 멤버로 생성합니다. 또한 구현해야하는 메서드를 자동으로 생성하고 본문에서 A()를 통해 해당 메서드를 실행합니다.

컴파일러가 만드는 Java Byte Code는 다음과 유사합니다.

public final class B implements Inter {
	private final  A delegate = new A();
    
    public void doing() { this.delegate.doing() }
}

데이터 클래스와 기타 클래스

데이터 클래스 (data class)

데이터 클래스는 데이터를 보관하는 용도로 사용하는 클래스 입니다. 이러한 용도로 사용되는 클래스의 기능은 한정적입니다. 따라서 코틀린 컴파일러는 데이터 클래스가 필요한 기능을 자동으로 완성해줍니다.

코틀린의 데이터 클래스에서 내부적으로 자동 생성되는 메서드는 다음과 같습니다.

• 프로퍼티의 getter/setter
• equals(), hashCode(): 데이터 클래스가 갖는 데이터가 같은지 비교하기 위한 메서드
• toString(): 데이터 클래스가 갖는 데이터를 읽을수 있게 문자열로 변환하여 표현
• copy(): 특정 프로퍼티만 변경하여 객체 복사
• componentN(): 각 프로퍼티에 상응하는 메서드

자세한 내용은 아래에서 좀 더 알아보겠습니다.

데이터 클래스 선언하기

data class 클래스 이름(프로퍼티1, 프로퍼티2...)

데이터 클래스는 다음 조건을 만족할 때만 사용할 수 있습니다.

• 주 생성자는 최소한 하나의 매개변수를 가져야한다.
• 주 생성자의 모든 매개변수는 프로퍼티여야 한다.
• 데이터 클래스는 abstract, open, sealed, inner 키워드를 사용할 수 없다.

자동으로 생성되는 메서드

• equals():
  각 프로퍼티가 같은지 비교하는 equals() 메서드입니다.

data class data(var name: String, var age: Int)

class NoneData(var name: String, var age: Int)

fun main() {
	val data1 = data("kim", 10)
    val data2 = data("kim", 10)
    
    val noneData1 = NoneData("kim", 10)
    val noneData2 = NoneData("lee", 10)
    
    println(data1 == data2) // true
    println(noneData1 == noneData2) // false
}

data class가 아닌 보통 class는 equals를 만들어주지 않으면 Any 타입의 equals를 사용하므로 일반적으로 기대하는 == 비교가 되지 않습니다.

• hashCode(): 데이터 클래스가 갖고 있는 데이터에 따라 특정 고유값을 반환하는 메서드입니다.

fun main() {
    val data1 = data("kim", 10)
    val data2 = data("kim", 10)

    val noneData1 = NoneData("kim", 10)
    val noneData2 = NoneData("lee", 10)

    println("data1: ${data1.hashCode()}, data2: ${data2.hashCode()}")
    // data1: 3291931, data2: 3291931
    println("noneData1: ${noneData1.hashCode()}, noneData2: ${noneData2.hashCode()}")
    // noneData1: 980546781, noneData2: 2061475679

hashCode() 메서드도 일반 클래스에서는 Any타입의 hasCode를 사용하기 때문에 프로퍼티의 값이 같아도 기대하는 결과를 얻을 수 없습니다.

• copy(): 데이터를 복사할 수 있는 함수입니다. (파라미터를 사용하여 특정 프로퍼티의 값만 바꿔서 복사가 가능합니다.)

data class data(var name: String, var age: Int)

fun main() {
    val data1 = data("kim", 10)
    val data2 = data1.copy(age=3)

    println("data1: $data1, data2: $data2")
	// data1: data(name=kim, age=10), data2: data(name=kim, age=3)

}

• toString(): 데이터 클래스가 갖고 있는 데이터를 읽기 쉽게 문자열로 변경해주는 메서드입니다.

data class data(var name: String, var age: Int)

class NoneData(var name: String, var age: Int)

fun main() {
    val data1 = data("kim", 10)
    val noneData1 = NoneData("kim", 10)

    println("$data1") // data(name=kim, age=10)
    println(data1.toString()) // data(name=kim, age=10)
    println("$noneData1") // NoneData@3a71f4dd
    println(noneData1.toString()) // NoneData@3a71f4dd
}

• componentN(): 각 프로퍼티에 대응하는 메서드입니다. 순서대로 1,2,3,4...으로 이름 붙여져서 생성됩니다.

data class data(var name: String, var age: Int)

fun main() {
    val data1 = data("kim", 10)

    println(data1.component1()) // kim
    println(data1.component2()) // 10
}

코틀린 컴파일러는 내부적으로 이 component 메서드를 사용하여 객체를 분해(Destructing)합니다.

data class data(var name: String, var age: Int)

fun main() {
    val data1 = data("kim", 10)

	val (first, second) = data1
    println(first) // kim
    println(second) // 10
}

이러한 객체 분해 문법은 지역 범위(local scope)에서만 사용 가능합니다.

data class data(var name: String, var age: Int)

val data1 = data("kim", 10)

val (globalFirst, globalSecond) = data1 // Top Level Declarlation Error

fun main() {
	val (first, second) = data1 // local OK
    println(first) // kim
    println(second) // 10
}

내부 클래스 기법

중첩 클래스(nested class)

클래스는 다른 클래스에 중첩될 수 있습니다. 클래스 in 클래스, 클래스 in 인터페이스, 인터페이스 in 클래스, 인터페이스 in 인터페이스 모든 조합이 가능합니다.

interface OuterInterface {
    class InnerClass
    interface InnerInterface
}

class OuterClass {
    class InnerClass
    interface InnerInterface
}

중첩 클래스는 JVM에서 static으로 선언되기 때문에 바깥 클래스를 생성하지 않아도 중첩 클래스를 생성하는게 가능합니다.

class NestClass {
    val id = 3
    class NestedClass {
    	/* val subId = id  //Compile Error */
        fun inside() {
            println("in")
        }
    }
}

fun main() {
	NestClass.NestedClass().inside()
}

이너 클래스(inner class)

이너 클래스는 중첩 클래스 앞에 inner 키워드를 사용하여 선언합니다.

class OuterClass {
	val id = 3
	inner class InnerClass {
    	val subId = id // 바깥 클래스의 멤버에 접근 O
    }
}

이너 클래스는 JVM에서 static으로 선언되지 않습니다. 그렇기 때문에 OuterClass를 생성해야만 InnerClass를 생성할 수 있습니다. 또한 이너 클래스에서는 바깥 클래스의 멤버에 접근이 가능합니다.

sealed class와 enum class

sealed class

sealed class는 상속받는 자식 클래스를 제한합니다. sealed class는 같은 패키지 내에 있는 클래스에게만 상속될 수 있습니다. 즉, 컴파일러는 sealed class의 자식이 어떤 클래스인지를 알고 있습니다.

그래서 sealed class를 when에서 사용할 때, 모든 분기를 나열하면 컴파일러가 else 분기를 작성하지 않는것을 용인합니다.

sealed class는 추상 클래스이므로 객체를 만들 수 없습니다. 또한 생성자도 private 생성자만 존재해야 합니다.

enum class

enum class는 자료형이 동일한 상수를 나열할 수 있는 클래스입니다.

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

enum class가 enum과 다른점은 프로퍼티와 메서드를 가질 수 있다는 점입니다.

enum class Direction(val num: Int) {
	NORTH(0), SOUTH(1), WEST(2), EAST(3);
    fun printNum(dir: Direction) = println(dir.num)
}

enum class Direction(_num: Int) {
	NORTH(0), SOUTH(1), WEST(2), EAST(3);
    val num = _num
    fun printNum(dir: Direction) = println(dir.num)
}

enum class에 프로퍼티와 메서드를 선언하고 싶다면 상수의 선언이 끝나는 부분에 세미콜론(;)을 붙여야 합니다. 그 이후에 일반 클래스에 하던대로 프로퍼티와 메서드를 작성하면 됩니다.

애노테이션 클래스

애노테이션은 코드에 부가 정보를 추가하는 역할을 합니다. @ 기호와 함께 나타내는 표기법으로 주로 컴파일러나 프로그램 실행 시간에서 사전 처리를 위해 사용합니다. 예를 들어 @Test는 유닛 테스트를 위해 사용하고 @JvmStatic은 자바 코드에서 컴패니언 객체를 접근 가능하게 합니다.

애노테이션 클래스를 직접 만드는 것은 프레임워크를 제작하지 않는 한 사용할 일은 별로 없습니다. 오히려 프레임워크에서 제공하는 애노테이션을 사용하는 경우가 많습니다. 여기서는 애노테이션을 사용하는 방법에 대해 대략적으로만 살펴봅니다.

애노테이션 선언하기

사용자 애노테이션을 만들기 위해서는 키워드 annotation을 사용해 클래스를 선언합니다.

annotation class 클래스 이름

애노테이션은 다음과 같은 몇 가지 속성을 사용해 정의될 수 있습니다.

• @Target: 애노테이션이 지정되어 사용할 종류(클래스, 함수, 프로퍼티 등)를 정의
• @Retention: 애노테이션을 컴파일된 클래스 파일에 저장할 것인지 실행시간에 반영할 것인지 결정.
• @Repeatable: 애노테이션을 같은 요소에 여러 번 사용 가능하게 할지를 결정.
• @MustDocumented: 애노테이션을 API의 일부분으로 문서화하기 위해 사용

@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION,
AnnotationTarget.VALUE_PARAMETER, AnnotationTarget.EXPRESSION)
@Retention(AnntationRetention.SOURCE)
@MustBeDocumented
annotation class: Fancy

연산자 오버로딩(operator overloading)

연산자의 작동 방식

연산자를 사용하면 그 연산자와 관련된 메서드를 호출하는 것과 같습니다. a+b를 호출하면 a.plus(b)라는 함수가 호출되는 것입니다.

기본 자료형의 산술 연산자는 Primitives.kt에 구현되어 있습니다.

우리가 만든 사용자 정의 클래스에서 연산자를 사용하려면 연산자 오버로딩을 통해 연산자를 구현해주면 됩니다.

class OverloadPractice(var value: Int) {
    operator fun plus(ref: OverloadPractice) = OverloadPractice(value + ref.value)
    operator fun minus(ref: OverloadPractice) = OverloadPractice(value - ref.value)

}

fun main() {
    val temp1 = OverloadPractice(10)
    val temp2 = OverloadPractice(5)

	println((temp1 + temp2).value) // 15
    println((temp1 - temp2).value) // 5
    temp1 += temp2
    println(temp1.value) // 15
    temp1 -= temp2
    println(temp1.value) // 10
}

연산자의 종류

주요 연산자의 종류와 사용법, 호출 메서드에 대해 정리해보겠습니다.

산술 연산자

표현식	호출 메서드
a+b	a.plus(b)
a - b	a.minus(b)
a * b	a.times(b)
a / b	a.div(b)
a % b	a.rem(b)
a..b	a.rangeTo(b)

호출 연산자

호출 연산자(invoke operator)는 함수 객체에서 함수를 호출할 때 사용됩니다.

람다 함수를 선언하면 Function 객체가 만들어지는데 이 Function 객체의 invoke 메서드를 호출하면 우리가 선언한 람다 함수가 실행됩니다.

호출 연산자는 함수를 실행하는 것처럼 ()를 사용해 실행할 수 있습니다. 인자를 갖는 호출 연산자도 만들 수 있습니다.

fun main() {
    val lambda = {
        println("lambda execute")
    }
    
    val parameterLambda = { num: Int ->
    	println("num: $num")
    }

    lambda.invoke() // "lambda execute"
    lambda() // "lambda execute"
    parameterLambda.invoke(1) // "num: 1"
    parameterLambda(1) // "num: 1"
}

인덱스 접근 연산자

인덱스 접근 연산자는 대괄호[i]를 통해 값을 읽어오거나 쓰는 기능을 제공합니다.

표현식	호출 메서드
a[i]	a.get(i)
a[i,j]	a.get(i, j)
a[i_1,...,i_n]	a.get(i_1, ..., i_n)
a[i] = b	a.set(i, b)
a[i, j] = b	a.set(i, j, b)
a[i_1,...,i_n] = b	a.set(i_1,...i_n, b)

data class data(var name: String, var age: Int) {
    operator fun get(n: Int) = when (n) {
        0 -> component1()
        1 -> component2()
        else -> java.lang.IllegalArgumentException("out of range")
    }

    operator fun get(i: Int, j: Int) = Pair( get(i), get(j) )
    )
}

fun main() {
    val data = data("kim", 123)
    println(data[1]) // 123
    println(data[0, 1]) // (kim, 123)
}

단일 연산자

단일 연산자는 각 연산자에 대한 함수를 호출한 다음 연산된 결과를 반환합니다.

표현식	호출 메서드
+a	a.unaryPlus()
-a	a.unaryMinus()
!a]	a.not()

다음은 기본 자료형 Int와 Boolean에 대한 단일 연산자의 예제입니다.

fun main() {
    val num = 4
    val bool = false

    println(num.unaryPlus()) // 4
    println(num.unaryMinus()) // -4
    println(bool.not()) // true
}

범위 연산자

in 연산자는 특정 객체를 반복하기 위해 반복문에 사용하거나 범위 연산자와 함께 포함 여부를 판단할 수도 있습니다.

표현식	호출 메서드
a in b	b.contains(a)
a !in b	!b.contains(a)

fun main() {
    val array = intArrayOf(1,2,3,4)

    println(3 in array) // array.contains(3)
    println(3 !in array) // !array.contains(3)
    println(0 in array) // array.contains(0)
    println(0 !in array) // !array.contains(0)
}

대입 연산자

대입 연산자는 연산의 결과를 할당합니다. 주의할 점은 plus의 연산자를 오버로딩하면 plusAssign도 컴파일러가 만들어주기 때문에 중복으로 만들 필요가 없다는 점입니다.

표현식	호출 메서드
a += b	a.plusAssign(b)
a -= b	a.minusAssign(b)
a *= b	a.timesAssign(b)
a /= b	a.divAssign(b)
a %= b	a.remAssign(b)

동등성 연산자

표현식	호출 메서드
a == b	a.equals(b)
a != b	!a.equals(b)

동등성 연산자는 두 객체의 값의 동등성을 판별합니다. ==와 !=는 모두 equals()로 변경되어 동작합니다.

또한 동등성 연산자는 Any 클래스에 operator로 정의되어 있어서 확장 함수로 구현할 수 없다는 점을 주의해야합니다.

비교 연산자

표현식	호출 메서드
a > b	a.compareTo(b) > 0
a < b	a.compareTo(b) < 0
a >= b	a.compareTo(b) >= 0
a <= b	a.compareTo(b) <= 0

모든 비교 연산자는 compareTo 메서드를 통해 반환되는 정수를 보고 비교합니다.

출처

코틀린 공식 문서
코틀린 월드 - sealed class란 무엇인가
Do it 코틀린 프로그래밍(2021, 황영덕)