Kotlin_Map / Class

Map

/**
 *
 * 반복문 https://androidtest.tistory.com/98
 *
 * Map - 키와 쌍으로 데이터가 저장되며, 정수를 사용한 인덱스 기반 처리 대신 키를 기반으로 데이터를 처리한다.
 * MutableMapOr , mapOf 함수를 사용해서 생성됨.
 * 키와 벨류를 정의하기 위해 to를 사용하고 있음.
 * to는 키워드 처럼 보이는데 내부적으로는 컴파일러가 "carrie".to(100) 이렇게 변환한다. - 애초에 작성시에 이렇게 해도 됨.
 * Pair 타입을 사용할 수도 있음
 *
 * 똑같은 key의 값을 추가하려고 하면 (추가는 +=) 해당 키의 벨류만 바뀐다.
 *
 * 키 값으로 값 가져올 수 있다.
 *
 * Map에서 값을 가져오는 함수
 * [] 인덱스 연산자 / getValue / getOrElse / getOrDefault
 *
 *
 * 변경 가능한 Map 의 변경자 함수
 * [] 인덱스 연산자 / += / put / putAll / getOrPut / remove / - / -= / clear
 * */

fun main() {

    // 읽기 전용 map 생성하기
    val customerGold = mapOf("carrie" to 99.999, "elli" to 99.877, "gom" to 99.888)
    val customerGold_1 = mapOf("carrie".to(100), "elli".to(99), "gom".to(100))
    val customerGold_2 = mapOf(Pair("carrie", 100), Pair("elli", 99), Pair("gom",100))

    println(customerGold)
    println(customerGold_1)
    println(customerGold_2)

    // 값 가져오기
    println(customerGold["carrie"])


    customerGold.forEach{ patron, balance ->
        println("${patron}, balance: ${"%.2f".format(balance)}")
    }
}

 

 

Class

https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.text/trim-indent.html

https://kotlinlang.org/docs/properties.html#getters-and-setters

public/ private/ protected / internal

 

 

/**
 * 클래스 Class
 * 1. 코틀린에서는 하나 또는 여러 개의 클래스를 정의할 수 있다.
 *    앱 규모 커짐에 따른 유지 보수 용이성을 고려하여 가급적이면 한 클래스에 하나를 만드는 게 좋다.
 *    {} 사용하여 클래스 몸체를 정의한다.
 *
 * companion Object를 사용하면 초기화 없이 클래스를 사용할 수 있음 - 유일한 방법임!
 * 즉, 클래스를 사용하는 방법으로는
 * 1. 초기화
 * 2. companion object로 만들기
 *
 * 상속을 사용하는 이유 : 기존 코드 재사용하기 위함. → 코드를 재활용하는데, 체계적으로 계층구조화 해서 사용하기 위해서
 *
 * 오버라이드 Parent: open Child: override
 * -  동일한 프로퍼티나 메소드를 재정의 할 때 필요한 키워드
 *
 * MainActivity를 보면 AppCompatActivity 를 상속 받는데, 이를 통해 start~ 이러한 함수들을 사용할 수 있다.
 *
 *
 * 오버로드 - 상속관계랑은 상관 없음.
 서 */

// 변수와 함수의 모음
class 클래스명
{
    // 초기화
    init {
        // 클래스를 초기화 하면 호출된다.
        // 클래스 초기화 == 메모리에 로드 한다.
        // 이 클래스 인스턴스가 된다.
    }
    var variagle:String ="" // 변수 - 프로퍼티
    // 클래스 scope

    fun function()  // 함수 - 메소드
    {
        var variable_local = ""
    }

}

//class Log{
//    fun d(param1:String, param2:String){
//        println("[$param1] : $param2")
//    }
//}

class Log{

    companion object{
        fun d(param1:String, param2:String){
            println("[$param1] : $param2")
        }
    }

}


class Happiness{

    companion object{
        var H = "happiness"
        fun laugh(){
            print("haha!")
        }
    }

}

// 나는 상속을 할 수 있다 라는 의미로 앞에 open 키워드를 붙여야 한다.
open class Parent{
    var money = 10000

    // 자식한테 오버라이드가 되려면 프로퍼티와 메서드 앞에서 open 이 붙어야 된다.
    open var house = "청주 100평 아파트"
    open fun showHouse()
    {
        Log.d("Parent","house ${house}")
    }

}

// 상속 받기 - 상속 받은 값을 사용하려면 초기화 해야 한다.
class Child : Parent(){

    override var house = "청주 10평 오피스텔"
    fun showMoney(){
        // 상속받으면 그대로 Parent 클래스의 프로퍼티와 메서드를 내것처럼 사용할 수 있다.
        Log.d("Child","money ${money}")
    }

    override fun showHouse()
    {
        Log.d("Child","house ${house}")
    }

}

// 오버로드
class Son{

    fun getNumber():Int {
        return 1
    }

    fun getNumber(param: String) : Int {
        return 2
    }
}


fun main() {
    val name = "carrie"
    val healthPoints = 100
    val isBlessed = true
    val isImmortal = false

    val player = Player()

    // 클래스의 사용 - init 함수 호출
    var cls = 클래스명()
    cls.variagle
    cls.function()

    // companion Object 아닐 때
    // var log = Log()
    // log.d("carrie","log")

    Happiness.laugh()

    // child 초기화
    var child = Child()
    child.showMoney()

    //override  사용
    var parent = Parent()
    var over_child = Child()

    parent.showHouse()
    over_child.showHouse()


}

 

var / val  - setter의 유무

/**
 * 속성의 게터와 세터.
 * : 우리가 정의한 각 속성에 대해 필드와 게터가 자동 생성되며, 경우에 따라 세터도 자동 생성된다.
 * 필드 - 속성의 데이터가 저장되는 곳.
 *
 * 게터와 세터 오버라이딩
 * 다폴트로 있는데 getter, setter를 커스텀 할 수 있다.
 * 디폴트 : 코틀린에서는 필드명 자체가 게터 세터 역할을 함
 * 커스텀 : 필드 field
 *
 *
 * constructor, init 둘 다 초기화 인데, 실행은 init → constructor 순서로 된다.
 *
 * trimIndent{}
 *
 *
 * 기본 default 주요 생성자
 * class Student
 * class Student{}
 * class Student() {}
 *
 *
 *
 *
 * * */

fun main() {
    val carrie = Student("carrie", 24)
    val elli = Student(null, 24, 2.0f)
    val john = Student("john", 20,1.0f)

    // carrie.realScore = 3.3f

    carrie.showStatus()
    elli.showStatus()
    john.showStatus()


}


// 주요생성자 인자를 이용해서 필드 초기화
//class Student(name: String?, age:Int, score:Float = 1.0f)
//{
//    val realName: String = name ?:"guest"
//    val email: String = "${realName}@school.org"
//    val joinedAge: Int = age
//    var realScore: Float = score
//
//    fun showStatus()
//    {
//        val status = """
//            ===   학생 재학 증명 ===
//            이름: ${realName}
//            나이: ${joinedAge}
//            학점: ${realScore}
//            이메일: ${email}
//            ======================
//        """.trimIndent()
//
//        println(status)
//    }
//
//}


//  인자인 동시에 필드화
class Student(val name: String?,val age:Int, var score:Float = 1.0f)
{
    val email: String = "${name}@school.org"

    // var 에 커스텀 getter, setter
    var description: String? = null
        get() = field ?: "null 이구나"
        set(value){
            if(!value.isNullOrEmpty())
                field = value
        }

    fun showStatus()
    {
        val status = """
            ===   학생 재학 증명 ===
            이름: ${name}
            나이: ${age}
            학점: ${this.score}
            이메일: ${email}
            설명: ${description}
            ====================== 
        """.trimIndent()

        println(status)
    }

}

 

 

late lazy

 

https://www.youtube.com/watch?v=I-TksKaou1Q

 

 

컴파일러는 초기화 블록에서 속성을 사용하는 함수와 비교하면서까지 속성의 초기화 순서를 검사하지는 않는다. 따라서 속서을 사용하는 함수를 호출하는 초기화 블록을 정의할 때는 해당 함수를 호출하기 전에 그런 속서이 초기화되도록 코드를 작성해야한다.

import java.io.BufferedReader
import java.io.IOException
import java.io.InputStreamReader

/**
 * lateinit : 늦은 초기화
 * by lazy : 게으른 초기화(프라퍼티 위임 초기화)
 * Val 같은 경우는 단 한번의 초기화만 하니까,
 *
 * lateinit
 * >> 지금 당장 null 로 두고 싶지 않은데, 디폴트로 다른 기본 적인 것을 하기에는 조금 까다롭다. 그래서 등장한 것이 바로 lateinit!!
 * >> 의도적으로 변수 프로퍼티의 초기화를 지연시키는 것
 *
 * init block :
 * 주요 생성자의 value - parameter나 프러퍼티 파라미터를 사용하여 초기화 / init { 초기화 코드 }
 *
 * secondary constructors :
 * 2차 생성자를 한 개 이상 더 정의할 수 있음 / 주요 생성자, 다른 2차 생성자를 호출하여 초기화를 위임할 수 있음
 *
 *
 * */


enum class Monster {
    WaterMon, FireMon, EarthMon, WindMon
}

enum class Clan{
    DarkSide, LightSide
}

class Player(){

    // lateinit - 지금 우리가 null이든 기본 값이든 아무 것도 초기화 안해도 error 내지 않겠다! 나중에 정말로 값 부여 될텐데 그때부터 쓰겠다.
    lateinit var nick: String // = ""

//    init {
//
//    }
    lateinit var leadMonster:Monster // = Monster.EarthMon

    // 진영
    // 초기화를 단 한번 필요로 하는 시점에 그때 딱 하겠다. by lazy!
    val clan:Clan by lazy{
        // Clan을 결정 초기화 코드 블록.
        this.selectClan()
    } // = null // Clan.DarkSide

    // 진영 고르는 함수
    private fun selectClan(): Clan {

        var mySide: Clan = Clan.DarkSide

        try {
            // Clan 이라고 하는 열거형 클래스에는, static에 버금가는 함수들을 가지고 있음.
            Clan.values().forEach {
                print("${it.ordinal}: ${it.name} 진영 \t")
            }

            print("Player 진영을 선택 : ")

            // 개행 문자를 버퍼에 넣어 두었다가, 하나의 문자열로 하나의 행을 던져주는 함수
            val br: BufferedReader = BufferedReader(
                InputStreamReader(System.`in`)
            )

            val sel = br.readLine()
            if (sel == "1") mySide = Clan.LightSide
        }catch (e: IOException){
            e.printStackTrace()
        }
        return mySide
    }
}


class Professor(_name: String, _age:Int = 30){

    var name: String? = null
    val age: Int = _age

    init{
        // 주요생성자의 초기화 블록
        // init 블록 앞에 있는 프로퍼티 사용 가능 init 블록 뒤에 있어도 실행은 되지만 주의가 필요함.
        name = if(_name.isNotEmpty() && _name.isNotBlank()) _name.toUpperCase() else "Guest"
        println("$name 교수님 ($age) 인스턴스")
    }

    var major: String = "인문학"

    // 괄호 안에는 프로퍼티가 아닌 벨류 값만 들어갈 수 있음
    constructor(_name : String, _age: Int, _major: String)
    : this(_name, _age)
    {
        // this.name = _name
        // this.age = _age
        this.major = _major
    }
}





fun main() {
    val p1 = Professor("david", 39) // p.c.
    val p2 = Professor("alice") // p.c.

    val p3 = Professor("park",45,"경제학") // 2차 생성자
}