[Kotlin] 안드로이드 프로그래밍을 위한 코틀린 고급 문법

코틀린 3강으로 끝내기 - 2편 고급 문법을 보고 배운 내용을 정리하였습니다.

www.youtube.com/watch?v=Q5noYbbc9uc&list=PLxBf91VkJLZ_XosvQ5yJnJB3k3iho2XbV&index=3

---

Lamda

/*
1. Lamda
람다식은 value 처럼 다룰 수 있는 익명함수이다.
 1) 메소드의 파라미터로 넘겨줄수가 있다. fun maxBy(a :Int)
 2) return 값으로 사용할 수 있다.

람다의 기본정의
 val lamdaName : Type = {argumentList -> codeBody}
 */

val square : (Int) -> (Int) = {number -> number*number}
// val square = {number : Int -> number*number} 한곳에는 자료형 선언해줘야 타입추론 가능
val nameAge = {name : String , age : Int ->
    "my name is ${name} I'm ${age}."
}

fun main() {
    println(square(12))
    println(nameAge("Yeop",22))
    val a = "yeop said "
    println(a.pizzaIsGreat()) // 확장함수 사용
    // a의 문자열 내용과 확장함수의 내용이 합쳐짐

    println(extendString("john",32))

    println(calculateGrade(90))

    val lamda = {number :Double -> number == 4.3213}
    println(invokeLamda(lamda))
    println(invokeLamda({it>3.22}))
    //println(invokeLamda{it>3.22}) 마지막 파라미터가 람다식이면 ()생략가능
}


// 확장함수
val pizzaIsGreat : String .() -> String = {
    this + "Pizza is the best!"
} // String 함수를 확장, this는 String오브젝트를 가르킴

fun extendString(name : String, age : Int) : String{
    val introduceMyself : String.(Int) -> String = {"I am ${this} and ${it} years old."}
    // this -> 확장함수 부르는 오브젝트, it -> 파라미터 1개 일 때
    return name.introduceMyself(age) // 확장함수 사용
}

// 람다의 Return
val calculateGrade : (Int) -> String = {
    when(it){
        in 0..40 -> "fail"
        in 41..70 -> "pass"
        in 71..100 -> "perfect"
        else -> "Error"
    }
}

// 람다를 표현하는 여러가지 방법
fun invokeLamda(lamda : (Double) -> Boolean) : Boolean{
    return lamda(5.2343)
}

 

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

        // 1. Kotlin interface가 아닌 자바 인터페이스여야함
        // 2. 그 인터페이스는 딱 하나의 메소드만 가져야함

        button.setOnClickListener {

        } // 둘은 같은 함수이다.

 

Data Class

data class Ticket(val companyName : String, val name : String, var date: String, var seatNumber : Int)
// toString(), hashCode(), equals(), copy() 만들어짐
class Ticketnormal(val companyName : String, val name : String, var date: String, var seatNumber : Int)

fun main(){
   val ticketA = Ticket("koreanAir","han","2020-01-01",14)
    val ticketB = Ticketnormal("koreanAir","han","2020-01-01",14)

    println(ticketA)
    println(ticketB)
}

data class는 보기쉽게 출력된 것을 확인할 수 있음, 관리 용이

 

Companion Object ( Java의 Static과 유사 )

class Book private constructor(val id : Int , val name : String){
    // 다른 곳에서 사용불가..(private)

    companion object BookFactory : IdProvider{
        override fun getId(): Int {
            return 444
        }
        val myBook = "new book"

        fun create() = Book(getId(), myBook)
    }
    // private 메소드나 인자 사용가능, 이름 지정안하면 Companion
}

interface  IdProvider {
    fun getId() : Int
}
fun main(){
    val book = Book.BookFactory.create()
    // 객체를 생성하지 않아도 사용가능..(스태틱과 유사)
    // Companion 생략가능 (이름 미지정)
    println("${book.id} ${book.name}")
}

 

object

object CarFactory{
    val cars = mutableListOf<Car>()
    fun makeCar(horsePower : Int) : Car{
        val car = Car(horsePower)
        cars.add(car)
        return car
    }
} // 싱글톤 패턴 (객체가 한번만 만들어짐)

data class Car(val horsePower : Int)

fun main(){
    val car = CarFactory.makeCar(10)
    val car2 = CarFactory.makeCar(200)
    // 하나의 객체를 이용

    println(car)
    println(car2)
    println(CarFactory.cars.size.toString())
}