Kotlin in action(4)

data class

데이터 클래스는 필수 메서드를 컴파일러가 만들어준다. 코틀린 컴파일러는 이미 프로퍼티 접근자, 생성자같은걸 자바와는 다르게 알아서 만들어 주는걸 이전 내용에서 볼 수 있었는데, 거기에 한발 더 나가서 toString(), equals(), hashCode()와 같은 메서드를 컴파일러가 만들어준다.

코틀린의 == 는 equals()로 내부적으로 호출되어 객체를 비교한다. 따라서 자바에서 문제가 되던 참조비교가 코틀린의 ==에서는 발생하지않는다. 참조 비교가 필요하다면 ===로 사용하면 된다.

val client1 = Client("Alice", 342562)
val client2 = Client("Alice", 342562)
println(client1 == client2) println(client1 === client2)

 

둘다 false이다. 객체를 비교했기 때문인데, 값이 같은 걸 비교하려면 equals메서드를 Client클래스 내부에서 오버라이드 하여 구현해야된다.

hashCode()는 잘 모르던 개념인데, equals()가 true를 반환하는 두 비교객체는 같은 hashCode를 반환해야한다는 특징이 있다. 해시 컨테이너라고도 하는데, 구별ID라고 볼 수도 있다.

원래라면 데이터를 저장하는 역할만 하는 클래스에 이런 메서드를 상황에 맞게 오버라이드 해서 사용해야되지만, data class로 생성한 클래스는 이 메서드들을 자동 생성한다.

data class Client(val name: String, val postalCode: Int)

 

데이터 클래스의 주생성자로 선언된 프로퍼티를 고려해 equals, hashCode가 만들어진다.

불변성

데이터 클래스의 프로퍼티는 var로도 선언할 수 있지만, val로 권장된다. 불변성이 필수적인 타입 컨테이너에 데이터 클래스를 담는 경우, var로 선언한 값을 변경하면 컨테이너 상태가 변할 가능성이 있기 때문이다. 불변 객체를 사용하면 다중스레드일 때 더 안전하다. 쓰기로 접근할 수가 없으니 동기화할 필요가 줄어들기 때문이다. 그럼 var로 선언해야하만 하는 경우에는 어떤 방식으로 해결해야될까?

copy()가 있다. val 프로퍼티를 copy하여 복사본의 값을 재정의 한다. 이러면 원본은 살아있고, 복사본을 제거해도 원본에 영향이 없다.

val bob = Client("Bob", 973293)
println(bob.copy(postalCode = 382555))
// Client는 data class 객체.

 

위임 delegation

데코레이터 패턴이 예시로 나와있다. 헤드퍼스트 GoF 디자인패턴 책을 읽으면서 나왔던 건데, 필요한 기능이 있으면 상속받은 것 위에 덧씌워서 새로 인스턴스를 만드는 방식이다. 코틀린에서는 이걸 by 키워드로 간단하게 구현할 수 있다.

class CountingSet<T>(
        val innerSet: MutableCollection<T> = HashSet<T>()
) : MutableCollection<T> by innerSet {

    var objectsAdded = 0

    override fun add(element: T): Boolean {
        objectsAdded++
        return innerSet.add(element)
    }

    override fun addAll(c: Collection<T>): Boolean {
        objectsAdded += c.size
        return innerSet.addAll(c)
    }
}

 

innerSet을 위임받아서 필요한 add, addAll 메서드만 재정의하여 사용하는 모습이다.

object

object는 클래스 정의와 동시에 인스턴스를 생성하는 키워드다. 키워드하나로 싱글턴을 만들수 있게됐다.

object CaseInsensitiveFileComparator : Comparator<File> {
    override fun compare(file1: File, file2: File): Int {
        return file1.path.compareTo(file2.path,
                ignoreCase = true)
    }
}

 

생성자를 객체선언에 쓸수없다. 정확히는 선언과 동시에 인스턴스가 생성되니 쓸 필요가 없다. 부생성자도 마찬가지다. 의존관계가 많아지는 대규모 컴포넌트에서는 이런 특징이 생성을 제어할 수 없고 파라미터를 조절할 수 없어 단점이 되는데, 이때는 의존관계 주입 프레임워크를 사용해서 사용해야한다.

object는 클래스 안에서 선언할 수도 있고, 이때 역시 이 객체의 인스턴스는 하나뿐이다.

data class Person(val name: String) {
    object NameComparator : Comparator<Person> {
        override fun compare(p1: Person, p2: Person): Int =
            p1.name.compareTo(p2.name)
    }
}

 

코틀린 클래스 안에는 static 한 멤버를 가질 수 없다. 따라서 클래스 밖에 최상위 함수/ 프로퍼티로 선언해서 사용하는데, 최상위 멤버는 private로 된 멤버에 접근할 수 없다는 단점이있다. 이때 사용되는 것이 동반객체 companion object이다.

class A {
    companion object customName {
        fun bar() {
            println("Companion object called")
        }
    }
}

 

이렇게 선언된 동반 객체의 멤버에 접근하려면 A.bar() 처럼 하면 된다. private 멤버에 접근할 수있다고 했는데, 이 말은 곧 private 생성자를 여기서 호출하면 된다는 뜻이다. 동반객체는 클래스 안/밖의 private 멤버에 접근 가능해서, private 처리된 주 생성자를 여기서 호출하는 일종의 팩토리 패턴형태를 사용할 수 있다. 코드로 바로 보면 이해가 빠르다.

class User private constructor(val nickname: String) {
    companion object {
        fun newSubscribingUser(email: String) =
            User(email.substringBefore('@'))

        fun newFacebookUser(accountId: Int) =
            User(getFacebookName(accountId))
    }
}

 

동반객체의 메서드는 private 생성자를 제어할 수 있는 팩토리 메서드다.

 

User 인스턴스를 생성해야하는 경우, 팩토리 메서드를 사용할 수 있다. 또한 object이기 때문에 팩토리 메서드로 생성된 인스턴스는 주소별로 유일하고, 이미 생성된 인스턴스에 접근 할 때는 캐시에 있는 인스턴스를 반환할 수 있다.

동반 객체는 클래스 안에 정의된 일반 객체이고 인터페이스 상속, 확장함수, 프로퍼티 정의 ,다 가능하다. 동반 객체에서 구현된 인터페이스는 동반객체를 둘러싼 클래스 이름으로 접근 할 수있다.

 

인터페이스를 구현한 동반객체를 갖는 클래스의 이름을 사용해 필요한 메서드로 인스턴스를 넘길 수 있다.

fun loadJson<T>(factory: C<T>): T{

}
class P(val name: String){
    companion object : C<P>{
        // 인터페이스 구현
        override fun fromJson(jsonText: String):P = ...
    }
}
loadJson(P)

 

이런식으로 사용할 수 있다.

이름없이 정의된 동반객체에 접근하기 위해서는 Companion이라는 이름을 써야되는데, 동반객체 확장 예시와 같이 보자.

class A {
    companion object {
        fun bar() {
            println("Companion object called")
        }
    }
}

fun A.Companion.foo(): String{
    return "foo"
}

fun main(args: Array<String>) {
    A.bar()
    A.foo()
}

 

동반객체의 확장함수를 정의하려면 빈 동반 객체라도 갖고있어야한다.

무명 객체를 정의할 때도 object가 사용된다. 안드로이드의 setOnClickListener에서도 보였던 방법인데

etSignupPhone.setOnClickListener { object : View.OnClickListener {
                override fun onClick(v: View?) {
                    TODO("Not yet implemented")
                }
            } }

 

이런식으로 예전에는 사용했었다. EditText에서 TextWatcher를 object로 넘기는 것도 이 경우다. 객체 이름이 없는데, 객체 식의 특징이다. 이름을 붙여야 한다면

val clickListener = object : View.OnClickListener {
                override fun onClick(v: View?) {
                    TODO("Not yet implemented")
                }
            }

 

이런식으로 변수에 대입하여 사용하면 된다.

 

중요한 점은 무명객체는 싱글턴이 아니라, 사용 시 마다 인스턴스가 생성된다는 것이다. 객체 식은 무명 객체 안에서 여러 메서드를 오버라이드 해야하는 경우에 유용하다. 이 예시가 바로 EditText의 addTextChangedListener인 것이고, 구현이 필요한 추상메서드가 하나인 인터페이스를 뜻하는 SAM 종류인 setOnClickListener는 람다를 사용해 바로 사용할 수 있다.

 

"댓글, 공감 버튼 한 번씩 누르고 가주시면 큰 힘이 됩니다"