클래스와 객체 — 생성자, 프로퍼티, 그리고 자바와 다른 점

// 주 생성자에서 프로퍼티 선언까지 한 번에
class User(val name: String, var age: Int)

// 자바로 치면 이만큼의 코드가 생략된 것
// - private 필드 2개
// - 생성자
// - getter 2개
// - setter 1개 (age만)

class User(name: String, age: Int) {
    // name과 age는 생성자 파라미터일 뿐, 프로퍼티가 아니다
    // init 블록이나 프로퍼티 초기화에서만 사용 가능
    val greeting = "안녕, $name"   // 여기서만 접근 가능

    // fun printName() = println(name)  // 컴파일 에러! 프로퍼티가 아님
}

class User(val name: String, val age: Int) {
    var email: String = ""

    // 보조 생성자 — 반드시 주 생성자를 호출해야 함
    constructor(name: String, age: Int, email: String) : this(name, age) {
        this.email = email
    }
}

// 기본값 파라미터로 보조 생성자 대체
class User(
    val name: String,
    val age: Int,
    var email: String = ""
)

class InitOrder(name: String) {
    val firstProperty = "첫 번째 프로퍼티: $name".also(::println)  // 1

    init {
        println("첫 번째 init 블록: $name")                       // 2
    }

    val secondProperty = "두 번째 프로퍼티: $name".also(::println) // 3

    init {
        println("두 번째 init 블록: $name")                       // 4
    }

    constructor(name: String, age: Int) : this(name) {
        println("보조 생성자: $name, $age")                       // 5
    }
}

InitOrder("코틀린", 5)
// 출력 순서:
// 첫 번째 프로퍼티: 코틀린
// 첫 번째 init 블록: 코틀린
// 두 번째 프로퍼티: 코틀린
// 두 번째 init 블록: 코틀린
// 보조 생성자: 코틀린, 5

class Person {
    // var은 getter + setter 자동 생성
    var name: String = "이름 없음"

    // val은 getter만 자동 생성
    val isAdult: Boolean
        get() = age >= 19     // 커스텀 getter

    var age: Int = 0
        set(value) {          // 커스텀 setter
            require(value >= 0) { "나이는 음수일 수 없습니다" }
            field = value     // field — backing field에 접근
        }
}

var counter: Int = 0
    set(value) {
        if (value >= 0) field = value  // field를 사용해 실제 값 저장
        // this.counter = value        // 이렇게 쓰면 setter 재귀 호출 → StackOverflow!
    }

// backing field 없음 — 값을 저장하지 않고 매번 계산
val isEmpty: Boolean
    get() = size == 0

// backing field 있음 — field를 사용하거나 기본 getter/setter를 쓸 때
var name: String = "기본값"

class UserService {
    // var만 가능, primitive 타입 불가
    lateinit var repository: UserRepository

    fun init() {
        repository = UserRepository()
    }

    fun findUser(id: Long): User {
        // 초기화 전 접근하면 UninitializedPropertyAccessException
        return repository.findById(id)
    }

    fun checkInit() {
        // 초기화 여부 확인
        if (::repository.isInitialized) {
            println("초기화됨")
        }
    }
}

class Config {
    // val만 가능, 첫 접근 시 한 번만 초기화
    val dbConnection: Connection by lazy {
        println("DB 연결 생성")  // 첫 접근 때만 실행
        DriverManager.getConnection("jdbc:...")
    }
}

// lazy의 스레드 안전 모드
val data1: String by lazy(LazyThreadSafetyMode.SYNCHRONIZED) {
    // 기본값 — 동기화됨
    "스레드 안전"
}

val data2: String by lazy(LazyThreadSafetyMode.NONE) {
    // 단일 스레드 환경에서 성능 향상
    "동기화 없음"
}

class Example {
    public val a = 1        // 어디서든 접근 (기본값)
    private val b = 2       // 이 클래스 내부에서만
    protected val c = 3     // 이 클래스 + 하위 클래스
    internal val d = 4      // 같은 모듈 내에서만
}

// 파일 최상위에서도 가시성 수정자 사용 가능
public fun publicFunction() { }       // 어디서든
private fun privateFunction() { }     // 이 파일 내에서만
internal fun internalFunction() { }   // 같은 모듈 내에서만
// protected는 최상위에서 사용 불가

// 생성자를 private으로 — 외부에서 직접 생성 불가
class Singleton private constructor() {
    companion object {
        val INSTANCE = Singleton()
    }
}

// 주 생성자에 가시성 수정자를 붙일 때 constructor 키워드 필수
class User internal constructor(val name: String)

class User(name: String) {
    var name: String = name
        private set          // setter만 private — 외부에서 변경 불가

    fun updateName(newName: String) {
        name = newName       // 클래스 내부에서는 변경 가능
    }
}

val user = User("코틀린")
println(user.name)           // OK — getter는 public
// user.name = "자바"        // 컴파일 에러 — setter는 private