클래스

질문

객체와 구조체의 차이점은?

클래스는 상속지원&참조 형식, 구조체는 값 형식, 상속 및 메소드 지원 하지 않음.

 

함수가 자료구조 안으로 들어오면 어떤 장점이 생기는가?

 

왜 정보 은닉은 객체 기반에서만 가능한가?

 

밖에서 사용 할 수 없게 선언

var time:Double
private Set

 

 

4클래스란?

변수와 메소드를 가지는 타입을 정의하는 단위

클래스 선언
class Person{
//프로퍼티
var firstName: String = "" 
var familyName: String = "" 
var age: Int = 0

//메소드
fun fullName() = "$firstName $familyName"

fun showMe() {
	println("${fullName()}: $age")
    }
}


객체의 생성

val person = Person()// person이라는 객체의 참조자변수가 새롭게 생성한 Person객체를 가리킴

person.firstName = "John" 
person.familyName = "Doe" 
person.age = 25
person.showMe() // John Doe: 25

 

생성자

class Person(firstName: String, familyName: String) { 
	val fullName = "$firstName $familyName"
}
fun main() {
    val person = Person("John", "Doe")
    println(person.fullName)
}

 

init블록

하나의 식으로 표현하기 힘든 초기화 로직을 실행해야 할 때는 init 블록을 사용한다.

class Person(fullName: String) {
    val firstName: String
    val familyName: String
    init {
        val names = fullName.split(" ")
        if (names.size != 2) {
            throw java.lang.IllegalArgumentException ("Invalid name: $fullName")
        }
        firstName = names[0]
        familyName = names[1]
    }
}

fun main() {
    val person = Person("John Doe")
    println(person.firstName)
}

프로퍼티

프로퍼티는  반드시 초기화되어야 한다.

class Person(fullName: String) { 
    val firstName: String
    val familyName: String
    init {
        val names = fullName.split(" ")
        if (names.size == 2) { // names의 크기가 2가 아닐경우
            firstName = names[0] // firstName, familyName이 초기화 되지않으므로 error 발생
            familyName = names[1]
        }
    }
}

주생성자와 부생성자

주생성자

• 주생성자 파라미터는 프로퍼티 초기화나 init 블록 안에서만 사용할 수 있음.

class Person(firstName: String, familyName: String) {
    val fullName = "$firstName $familyName"
    fun printFirstName() {
        println(firstName) // Error: firstName is not available here
        }
    }

• 생성자 파라미터 정의 앞에 val이나 var를 붙이면 파라미터를 프로퍼티로 만들 수 있다.

class Person(val firstName: String, val familyName: String) { ...

 

부생성자

하나 이상의 생성자를 정의하고 싶을 때는 fun 함수 대신 constructor라는 예약어로 추가 생성자를 정의한다.

class Person {
val fullName: String
constructor(firstName: String, familyName: String):
    this("$firstName $familyName") 
    constructor(fullName: String) {
        this.fullName = fullName
    }
}

constructor예약어로 생성한건 부생성자!

this():기본생성자에게 위임. 첫번째 보조 생성자에서 사용

this.fullName: 직접 할당. 두번째 보조 생성자에 사용

 

멤버 가시성

클래스 내부 프로퍼티, 메소드마다 가시성 설정 가능하다.

• public: 멤버를 어디서나 볼 수 있다. (디폴트)

• internal: 컴파일 모듈 내부에서만 멤버를 볼 수 있다.

• protected: 멤버가 속한 클래스와 그 하위 클래스에서 볼 수 있다.

• private: 멤버가 속한 클래서 내부에서만 볼 수 있다. 

 

예제

class Person(private val firstName: String, private val familyName: String) {
    fun fullName() = "$firstName $familyName"
}
• firstName과 familyName은 클래스 밖에서는 볼 수 없다. 
• fullName()은 어디서나 볼 수 있다

 

주생성자 가시성

• 주생성자에 public외의 가시성을 주고 싶을 경우

class Empty private constructor() { 
    fun showMe() = println("Empty")
}

• Empty의 유일한 생성자가 private이므로 class 외부에서 인스턴스화 할 수 없음

 

nedsted class: 클래스 안에 클래스를 선언할 수 있다.

class Person (val id: Id, val age: Int) {
    class Id(val firstName: String, val familyName: String)
    fun showMe() = println("${id.firstName} ${id.familyName}, $age")
}

fun main() {
    val id = Person.Id("John", "Doe") 
    val person = Person(id, 25)
    person.showMe()
}

 

inner class

내포된 클래스에 inner를 선언하면 내부 클래스 (inner class)가 되어 내부 인스턴스가 외부 인스턴스 1개에 소속되게 된다.

• 내부 인스턴스는 자신이 소속된 외부 인스턴스의 멤버에 접근할 수 있다.

• 내부 인스턴스 생성시 자신이 소속된 외부 인스턴스를 명시해야 한다.

class Person(val firstName: String, val familyName: String) { 
    inner class Possession(val description: String) {
        fun showOwner() = println(fullName()) 
    }
    private fun fullName() = "$firstName $familyName" 
}

fun main() {
    val person = Person("John", Doe")
    val wallet = person.Possession("Wallet") 
    wallet.showOwner() // John Doe
}

class Person(val firstName: String, val familyName: String) { 
    inner class Possession(val description: String) {
        fun showOwner() = println(fullName())
        fun getOwner() = this@Person // 외부 Person 인스턴스를 반환
    }
    val myWallet = Possession("Wallet") // this.Possession("Wallet")과 같음 
    fun fullName() = "$firstName $familyName"
}

 

local class

함수 내에 class를 정의할 경우 

지역 클래스는 자신을 둘러싼 코드의 멤버에 접근 가능하다.

fun main() { 
    var x = 1
    class Counter {
        fun increment() {
            x++ //자신을 둘러싼 코드의 멤버
        }
    }
    Counter().increment()
    println(x)    // 2
}

 

---

null

정의: 아무것도 참조하지 않는 참조값의 특별한 상태

• null에 대해서 멤버 접근을 시도하면 NullPointerException이 발생

• 컴파일시간에 파악이 되지 않아 최악의에러 중 하나로 간주

• Kotlin에서는 일반 참조형에는 null을 담을 수 없다.

fun isLetterString(s: String): Boolean { 
    if (s.isEmpty()) return false
    for (ch in s) {
        if (!ch.isLetter()) return false 
    }
    return true 
}
fun main() { 
    println(isLetterString("abc"))    // Ok
    println(isLetterString(null))    // 컴파일 에러
}

 

널이 될 수 있는 타입 (nullable)

참조자의 타입 뒤에 ?(물음표)를 붙인다.

널이 될 수 있는 타입의 변수를 일반 타입변수에 대입하면 null가능성 때문에 컴파일 에러가 발생한다.

fun isBooleanString(s: String?) = s == "false" || s == "true"

fun main() { 
    println(isBooleanString(null))     // Ok
    val s: String? = "abc"             // Ok
    val ss: String = s                 //Error: type mismatch
}

 

널이 될 수 있는 타입에 대한 멤버접근

• 널이 될 수 있는 타입은 기본타입의 멤버접근 등의 연산을 바로 수행하려 할 경우 컴파일 에러가 발생한다.

fun isLetterString(s: String?): Boolean {
    if (s.isEmpty()) return false       // Error
    for (ch in s) {                     // Error 
        if (!ch.isLetter()) return false
    }
    return true
}

 

널가능성 제거를 통한 스마트캐스트

• 프로그램 흐름에서 null인 경우가 논리적으로 배제되면 컴파일러는 이를 인지하고 널 가능성을 제거하고 컴파일한다.

fun isLetterString(s: String?): Boolean {
    if (s == null) return false
    //이 시점부터 s가 null이 아님이 명백
    if (s.isEmpty()) return false
    for (ch in s) {
        if (!ch.isLetter()) return false
    }
    return true
}

 

조건문 내에서의 스마트 캐스트

when, 루프에서의 조건 검사

fun describeNumber(n: Int?) = when {
    null -> "null"
    n >= 0 && n <= 10 -> "small"
    n >= 11 && n <= 100 -> "large"
    else -> "out of range"
}

||나 &&연산의 스마트 캐스트

fun isSingleChar(s: String?) = s != null && s.length == 1

 

객체의 가변 프로퍼티와 스마트 캐스트

• 객체의 가변 프로퍼티는 스마트캐스트가 불가능 하다.

• 프로그램 다른 어떤곳에서 값을 바꿀 수 있기 때문

 

class MyString { 
    var str: String?
    fun isStrEmpty(): Boolean { 
        if (str == null) return true
        if (str.isEmpty()) return true
        else return false         // Error
        }

 

널 아님 단언연산자(!!)

• 널이 될 수 있는 타입에 대하여 프로그래머가 널이 아니라고 확언해 주는 연산자

• 그럼에도 불구하고 널이었을 경우 KotlinNullPointerException이 발생한다.

• 널 아님 단언연산자는 반드시 필요한 경우를 제외하고는 사용하지말 것

• 예) fun readInt() = readLine()!!.toInt()

• readLine()은null을반환할수있다.

• 위문장도피할수있으면피하는것이좋다.

• 위예에서readInt()의반환형은Int이다.(널이될수없음)

 

 

안전한 호출 연산자

• 예) fun readInt() = readLine()?.toInt()

• 수신객체가 널이 아닌경우에는 의미있는 일을 하고, 널인 경우에는 널을 반환한다.

• 위의 예제에서 readLine()이 널을 반환하면 toInt() 작업을 하지 않고 전체 문장이 null을 반환함

• 결과적으로 readInt()는 널을 반환할 수도 있게 되어 반환 타입이 Int?가 됨

 

엘비스 연산자

연산자 왼쪽의 값이 null인 경우 연산자 오른쪽 값으로 치환한다.

• fun readInt() = readLine()?.toInt() ?: 0

• 위에서 readLine()이 null인 경우 readLine()?.toInt() 값이 null이된다. 이 때 이 null을 ?: 0이 0으로 치환한다.

• 결과적으로 readInt()는 null을 반환할 가능성이 없어지므로 반환형이 Int가 된다.

fun sayHello(name: String?) {
	println("Hello, " + (name ?: "Unknown"))
}
fun main() {
	sayHello("John") // Hello, John
	sayHello(null) // Hello, Unknown
}

 

실습코드

class Car(
    val name:String,
    var speed: Double=0.0) {
    var distance: Double? = 0.0
}


class Track{
    private val cars = Array<Car?>(8){_->null}
    private var numCars:Int = 0
    private var time:Double =0.0

    fun getTime():Double{
        return time
    }

    fun addCar(c:Car){
        cars[numCars]=c
        numCars++
    }

    fun timePassed(t:Double){
        for(i:Int in 0 until numCars) {
            val c: Car? = cars[i]
            c?.distance = c?.distance?.plus(t * c.speed)
        }

        time +=t
    }
    fun removeCar(num:Int){
        cars[num] =null
    }

}

fun main() {
    val track = Track()
    val a = Car("Alpha")
    track.addCar(a)
    val b = Car("Bravo",30.0)
    track.addCar(b)

    while (true){
        track.timePassed(1.0)
        a.speed=a.speed+1.0
        if ((a.distance?:0.0)> (b.distance?:0.0)){
            println("${a.name} passed ${b.name} at ${track.getTime()}")
            break
        }
    }

}

2번줄에 ?를 써야하는 이유
나중에 distance에 null 할당할수 있음

8,9,10번줄에 private인 이유
cars, numCars, time 변수는 Track 클래스 내부에서만 사용되어야 하기 때문에 private로 선언

42번줄 if(a.distance > b.distance)아닌 이유
이 부분에서 a.distance와 b.distance는 둘 다 nullable한 Double? 타입으로 선언되었습니다.
nullable 변수를 직접 비교할 때 ?: 연산자를 사용하면 null 값이 있는 경우 기본값을 지정할 수 있습니다.
즉, a.distance ?: 0.0와 b.distance ?: 0.0는 각각 a.distance와
b.distance 값이 null인 경우 0.0을 사용합니다.
따라서 이 부분은 a.distance와 b.distance 중 하나라도 null이면 0.0으로 간주하고 비교합니다.
이것이 원하는 동작이 아니라면, null인 경우를 따로 처리해야 합니다. 예를 들어,
a.distance와 b.distance가 null이면 비교를 스킵하도록 할 수 있습니다.