[Kotlin in Action] 04장 - 클래스, 객체, 인터페이스

interface Clickable {
    fun click()
}

class Button : Clickable {
    override fun click() = println("I was clicked")
}

-> Button().click()

interface Clickable {
    fun click() // 일반 메소드 선언
    fun showOff() = println("I'm clickable")    // 디폴트 구현이 있는 메소드
}

interface Focusable {
    fun showOff() = println("I'm focusable")    // 디폴트 구현이 있는 메소드
}

class Button : Clickable, Focusable {
    override fun click() = println("I was clicked")
    override fun showOff() {    // 이름과 시그니처가 같은 멤버 메소드에 대해 둘 이상의 디폴트 구현이 있는 경우 인터페이스를 구현하는 하위 클래스에서 명시적으로 새로운 구현을 제공해야 한다.
        super<Clickable>.showOff()
        super<Focusable>.showOff()
    }
}

open class RichButton : Clickable { // 이 클래스는 열려있다.
    fun disable() {}    // 이 함수는 final 이다.
    open fun animate() {}   // 이 함수는 열려있다.
    override fun click() {} // 이 함수는(상위 클래스에서 선언된) 열려있는 메소드를 오버라이드한다. 오버라이드한 메소드는 기본적으로 열려있다.
}

open class RichButton : Clickable {
    final override fun click()  // final이 없는 override 메소드나 프로퍼티는 기본적으로 열려있으므로 final로 금지시킨다.
}

abstract class Animated {
    abstract fun animate()  // 추상 함수는 항상 열려 있다.
    open fun stopAnimating() {} // 추상 클래스에 속하더라도 비추상 함수는 기본적으로 파이널이지만 원한다면 open 으로 오버라이드를 허용 가능
    fun animateTwice() {}
}

class Button : View {
    override fun getCurrentState(): State = ButtonState()
    class ButtonState : State {}    // 자바의 정적 중첩 클래스와 대응된다.
}

class Outer {
    inner class Inner {
        fun getOuterReference(): Outer = this@Outer
    }
}

sealed class Expr { // 기반 클래스를 sealed로 봉인한다.
    class Num(val value: Int) : Expr()  // 기반 클래스의 모든 하위 클래스를 중첩 클래스로 나열한다.
    class Sum(val left: Expr, val right: Expr) : Expr()
}

fun eval(e: Expr): Int =
    when (e) {  // "when" 식이 모든 하위 클래스를 검사하므로 별도의 "else" 분기가 없어도 된다.
        is Expr.Num -> e.value
        is Expr.Sum -> eval(e.right) + eval(e.left)
    }

class User(val nickname: String)    //파라미터가 하나뿐인 주 생성자

class User(val nickname: String, val isSubscribed: Boolean = true)  // 디폴트 값을 제공하는 생성자

class TwitterUser(nickname: String) : User(nickname) {} // 기반 클래스를 초기화하려면 기반 클래스 이름 뒤에 괄호를 치고 생성자를 넘긴다.

open class Button   // 인자가 없는 디폴트 생성자 생성

class RadioButton: Button() // Button 클래스를 상속한 하위 클래스는 반드시 Button 클래스의 생성자를 호출해야 한다.

class Secretive private constructor() {} // 비공개 생성자 - 클래스 외부에서 인스터늣화하지 못하게 막을려면 private 선언

open class View {
    constructor(ctx: Context) {}
}

open class MyButton : View {
    constructor(ctx: Context) : super(ctx) {}   // 상위 클래스의 생성자 호출
}

open class MyButton : View {
    constructor(ctx: Context) : this(ctx, MY_STYLE) {}   // 이 클래스의 다른 생성자에게 위임

    constructor(ctx: Context, attr: AttributeSet): super(ctx, attr) {}
}

interface User {
    val nickname: String
}

class PrivateUser(override val nickname: String) : User // 주 생성자에 있는 프로퍼티

class SubscribingUser(val email: String) : User {
    override val nickname: String
        get() = email.substringBefore('@')  // 커스텀 게터 - 매번 결과를 계산
}

class FacebookUser(val accountId: Int) : User {
    override val nickname = getFacebookName(accountId)  // 프로퍼티 초기화 식 - 필드에 저장했다가 불러오는 방식
}

class User(val name: String) {
    val address: String = "unspecified"
        set(value: String) {
            println("""
                Adress was changed for $name:
                "$field" -> "$value".""".trimIndent())  // 뒷받침하는 필드 값 읽기
            field = value   // field라는 특별한 식별자를 통해 뒷받침하는 필드 값 변경
        }
}

class LengthCounter {
    var counter: Int = 0
        private set // 이 클래스 밖에서 이 프로퍼티의 값을 바꿀 수 없다.
    fun addWord(word: String) {
        counter += word.length
    }
}

class Client(val name: String, val postalCode: Int) {
    override fun toString() = "Client(name=$name, postalCode=$postalCode)"
}

class Client(val name: String, val postalCode: Int) {
    override fun equals(other: Any?) = Boolean {
        if(other == null || other !is Client)   // 코틀린의 is 는 자바의 instanceof 와 같다.
            return false
        return name == other.name && postalCode == other.postalCode
    }
}

class Client(val name: String, val postalCode: Int) {
    override fun hashCode(): Int = name.hashCode() * 31 + postalCode
}

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

class DelegatingCollection<T>(
    innerList: Collection<T> = ArrayList<T>()
) : Collection<T> by innerList()

object Payroll {
    val allEmployees = arrayListOf<Person>()
    fun calculateSalary() {
        for (person in allEmployees) {

        }
    }
}

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

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

-> A.bar()

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

-> User.newSubscribingUser("bob@gmail.com")

class Person(val name: String) {
    companion object Loader {
        fun fromJSON(jsonText: String): Person = ...
    }
}

// 아래 두가지 방법 모두 가능
-> Person.Loader.fromJSON("{name: 'Dmitry')"})
-> Person.fromJSON("{name: 'Dmitry')"})

interface JONSFactory<T> {
    fun fromJSON(jsonText: String) : T
}

class Person(val name: String) {
    companion object : JSONFactory<Person> {
        override fun fromJSON(jsonText: String) : Person = ...  // 동반 개체가 인터페이스를 구현한다.
    }
}

// 비즈니스 로직 모듈
class Person(val firstName: String, val lastName: String) {
    companion object {  // 비어있는 동반 객체 선언
    }
}

// 클라이언트/서버 통신 모듈
fun Person.Companion.fromJSON(json: String) : Person { // 확장 함수 선언, 동반 객체 기본 이름인 Companion 사용
}

-> Person.fromJSON(json)

val listener = object : MouseAdapter() {
    override fun mouseClicked(e: MouseEvent) {...}
    override fun mouseEntered(e: MouseEvent) {...}
}

fun countClicks(window: Window) {
    var clickCount = 0  // 로켤 변수 정의
    window.addMouseListener(object : MouseAdapter() {
        override fun mouseClicked(e: MouseEvent) {
            clickCount++    // 로컬 변수의 값을 변경
        }
    })
}