// 함수는 fun 으로 시작한다.
// 파라메터는 (파라메터명: 타입) 으로 쓴다
fun main(args: Array<String>) {
    // ;은 사용하지 않는다.
    // println은 System.out.println을 래핑한 함수이다.
    println(makeMessage1(1))
    println(makeMessage1(2))
    println(makeMessage2(1))
    println(makeMessage2(2))
}

// 리턴 타입은 : Type 형태로 쓴다
fun makeMessage1(msgType: Int) : String {
    return if (msgType == 1) "안녕하세요?" else "또 만났군요!"
}

// 아래와 같이 함수 선언과 동시에 반환값을 생략하고 대입문에 정의할 수 있다.
fun makeMessage2(msgType: Int) = if (msgType == 1) "날씨 좋죠?" else "참 맑군요!"

val a = 100
// 자동으로 변환되지 않는다.
val b: Long = a.toLong()
// toByte(), toShort(), toInt(), toLong(), toFloat(), toDouble(), toChar()

val s = """
    삶이 그대를 속일지라도
    슬퍼하거나 노하지 말라
    슬픈 날엔 참고 견디라
    즐거운 날이 오고야 말리니
    """

 // trimMargin() 여백 제거 문자를 전달하면 해당 문자까지 여백을 제거, default 문자는 "|"
val s = """
    >삶이 그대를 속일지라도
    >슬퍼하거나 노하지 말라
    >슬픈 날엔 참고 견디라
    >즐거운 날이 오고야 말리니
    """.trimMargin(">")

    val count = 77
    val s1 = "Count = $count"
    // 배열과 표현식의 경우는 중괄호({})를 앞뒤로 붙인다.
    val s2 = "$s1 의 길이는 ${s1.length}"
    println(s1)
    println(s2)

    val oneMillion = 1_000_000
    val creditCardNumber = 1234_5678_9012_3456
    val socialSecurityNumber = 999_99_9999
    val hexBytes = 0xff_fe_ad_de
    val bytes = 0b00000000_11111111_10101010_01011100
    println("$oneMillion, $creditCardNumber, $socialSecurityNumber, $hexBytes, $bytes")

    // arrayOf()를 사용하여 배열 생성
    val item = arrayOf("사과", "바나나", "키위")
    for (fruit in item) {
        println(fruit)
    }

    // Array클래스 생성자를 사용
    val num = Array<String>(5, { i -> (i * i).toString() })
    // 위와 동일한 코드
    val num2 = Array<String>(5) { i -> (i * i).toString() }
    // <String>은 생략 가능. 컴파일러가 추론할 수 있음
    for (item in num) {
        println(item)
    }

    // 기본 타입의 요소를 저장하는 별도의 클래스
    // IntArray, ByteArray, ShortArray, LongArray, FloatArray, DoubleArray, CharArray, BooleanArray
    // 위 클래스들은 코틀린 컴파일러가 컴파일할 때 자바의 기본 타입 배열로 변환한다.
    val intItem: IntArray = intArrayOf(1, 2, 3, 4, 5)
    val intItem2 = IntArray(5, { i -> (i * i) })
    val intItem3 = IntArray(5) { i -> (i * i) }
    
    // index를 사용하여 읽거나 쓸수 있다
    intItem[0] = intItem[1] + intItem[2]

	fun main(args: Array<String>) {
	    val m1 = Score(100, 200)
	    val m2 = Score(300, 400)
	    // 객체간 + 연산을 사용하면 plus 함수를 사용한다. plus함수를 오버로딩 하지 않으면 컴파일에러가 발생.
	    println(m1 + m2)
	    println(m1 * m2)
	}
	
	// data 키워드는 나중에 자세히 알아보자
	data class Score(val a: Int, val b: Int) {
	    // 연산자를 오버로딩 하는 함수는 앞에 operator 키워드를 붙여준다.
	    operator fun plus(other: Score): Score {
	        return Score(a + other.a, b + other.b)
	    }
	}
	
	// 확장 함수를 사용하여 아래와 같이 정의할 수도 있다.
	operator fun Score.times(other: Score): Score {
	    return Score(a * other.a, b * other.b)
	}

	operator fun Score.unaryMinus(): Score {
	    return Score(-a, -b)
	}
	
	operator fun Score.inc(): Score {
	    return Score(a + 1, b + 1)
	}

	fun main(args: Array<String>) {
	    val p1 = Customer("홍길동", "010-1111-2222")
	    val p2 = Customer("김선달", "010-1111-3333")
	    println(p1 < p2)
	    println(p1 > p2)
	
	}
	
	class Customer(val name: String, val phone: String) : Comparable<Customer> {
	    override fun compareTo(other: Customer): Int {
	        return compareValuesBy(this, other, Customer::name, Customer::phone)
	    }
	}

    val start = LocalDate.now()
    val end = start..start.plusDays(15)

    println(start.plusWeeks(1) in end)
    println(end)
    
    // 결과
    // true
    // 2017-09-14..2017-09-29 

	fun main(args: Array<String>) {
    	val instance = InvokeOperator("코틀린을")
    	instance("배우자")
    }
    
	class InvokeOperator(val message1: String) {
	    operator fun invoke(message2: String) {
	        println("$message1 $message2")
	    }
	}

    val b: String = "코틀린을 배우자"
    if(b is String) {
        println("String 타입")
    } else {
        println("String 타입아님")
    }

	open class A{}
	class B : A() {}

    val x = B()
    if(x is A) println("A type") else println("not A type")
    if(x is B) println("B type") else println("not B type")
    
    // 결과
    // String 타입
	 // A type
	 // B type

val s1: String? = null
val s2: String = null // Error: Kotlin: Null can not be a value of a non-null type String
val s3: String = s1 // Error: Kotlin: Type mismatch: inferred type is String? but String was expected

 var a: String? = "코틀린을 배우자"
 // a가 널이 아닌 경우 substring을 호출하고 호출한 결과가 널이 아닌 경우 length를 호출
 println(a?.substring(5)?.length)

 var a: String? = "코틀린을 배우자"
 val b = a?.length ?: 0 // val b: Int = if (a != null) a.length else 0
 println(b)

 // s2를 nullable string으로 캐스팅. s2가 String타입에 부적합한경우 ClassCastException이 발생
 val s1: String? = s2 as String?
 
 // s2가 String타입에 부적합하더라도 ClassCastException이 발생하지 않고 null 값이 반환
 val s1: String? = s2 as? String?

	 val result = if (param == 1) {
	 	"one"
	 } else if (param == 2) {
	 	"two"
	 } else {
	 	"three"
	 }

fun main(args: Array<String>) {
    whenUsage(2, 50, "서울시")
}

fun whenUsage(inputType: Int, score: Int, city: String) {
    // -------------- #1
    when (inputType) {
        // 값 -> 실행 코드 블록 형태로 작성
        1 -> println("type-1")
        // , 를 사용하여 여러 조건을 검사할 수 있다
        2, 3 -> println("type-2,3")
        // 모두 일치하지 않는 경우 else의 -> 코드를 실행한다.
        // 자바의 break는 필요 없다
        else -> {
            println("미확인")
        }
    }

    // --------------- #2
    when (inputType) {
        // 함수를 실행하여 그 결과를 검사할 수도 있다
        checkInputType(inputType) -> {
            println("타입정상")
        }
        else -> println("타입 비정상")
    }

    // --------------- #3
    val start = 0
    val end = 100
    when (score) {
        // in연산자와 범위 연산자 ..을 사용하여 검사할 수 있다.
        in start..(end / 4) -> println("우수함")
        50 -> println("평균임")
        in start..end -> println("범위에 있음")
        else -> println("범위를 벗어남")
    }

    // ---------------- #4
    // 결과를 변수에 대입할 수 있다.
    val isSeoul = when (city) {
        // is 연산자를 사용하여 타입을 확인할 수 있다.
        is String -> city.startsWith("서울")
        // 값을 대입하는 경우 else가 없으면 컴파일 에러가 발생한다
        else -> false
    }
    println(isSeoul)

    // ----------------- #5
    // if-else 문처럼도 사용가능하다.
    when {
        city.length == 0 -> println("도시명을 입력하세요")
        city.substring(0, 2).equals("서울") -> println("서울이군요")
        else -> println(city)
    }
}

fun checkInputType(inputType: Int): Int {
    // 아래 식은 inputType in 1..2 로 변경할 수 있다. 
    if (inputType >= 1 && inputType < 3) {
        return inputType
    }
    return -1
}

// in 연산자를 사용하여 반복을 처리
val item1 = listOf("사과", "바나나", "키위")
for (item in item1) {
    println(item)
}

// index를 사용하여 반복
val item2 = listOf("사과", "바나나", "키위")
for (index in item2.indices) {
    println("item at $index is ${item2[index]}")
}

// array도 동일하게 사용 가능
val item3 = arrayOf("사과", "바나나", "키위")
for (index in item3.indices) {
    println("item at $index is ${item3[index]}")
}

// 1부터 100까지 반복
for (i in 1..100) {
    print(i)
}

// 1부터 100까지 반복. 100은 제외
for (i in 1 until 100) {
    print(i)
}

// 2부터 10까지 반복. i는 2씩 증가
for (i in 2..10 step 2) {
    print(i)
}

// 10부터 1까지 1씩 감소
for (i in 10 downTo 1) {
    print(i)
}

val items = listOf("사과", "바나나", "키위")
var index = 0
while (index < items.size) {
    println("item at $index is ${items[index]}")
    index++
}
    
index = 0
do {
    println("item at $index is ${items[index]}")
    index++
} while (index < items.size)

fun min(valueLeft: Int, valueRight: Int): Int {
	return if(valueLeft < valueRight) valueLeft else valueRight
}

// 코틀린에서 if는 표현식으로 간주하므로 대입문에 바로 추가 가능
// min 함수의 리턴 타입이 생략되어 있지만 컴파일러가 추론하므로, 에러가 생기지 않는다.
fun min(valueLeft: Int, valueRight: Int) = if(valueLeft < valueRight) valueLeft else valueRight


// 매개변수의 기본값을 정의할 수도 있다.
fun min(valueLeft: Int = 0, valueRight: Int = 0) = if(valueLeft < valueRight) valueLeft else valueRight

// 사용 예시
min(100,50)
min(100) // valueRight는 기본값인 0이됨
min() // valueLeft, valueRight 모두 0
min(valueLeft=50, valueRight=100) // 지명인자(named argument)를 사용하여 값을 전달
min(valueRight=100, valueLeft=50) // 지명인자를 사용하야 정의된 순서와 무관하게 전달
min(valueLeft=50) // 지명인자와 기본값을 사용하여 호출

// 가변인자를 배열로 받아 arrayList를 생성하여 저장한 후 반환
fun <T> newList(vararg ts: T): List<T> {
    val result = ArrayList<T>()
    // 아래 for문은 아래 연산자 오버로딩 함수로 변경 가능하다
    // result += ts
    for (t in ts) {
        result.add(t)
    }
    return result
}


val list = newList(1, 2, 3)

val e = arrayOf(7, 8, 9) // Int 타입의 요소 3개를 저장한 배열 생성
val list2 = newList(1, 2, 3, *e, 5) // 1,2,3,7,8,9,5 를 가진 ArrayList 생성
// *e는 배열의 요소를 하나씩 가져와서 인자로 전달하라는 의미. *를 확산(spread)연산자라고함

  class Customer() {
      fun checkId() {..}
  }
  // 인스턴스를 생성(Customer())하여 호출
  Customer().checkId()

	fun main(args: Array<String>) {
	    println(calcCombination(45, 6)) // 로또 복권이 모든 조합 가능한 번호 개수 출력
	}
	
	fun calcCombination(whole:Int, selected: Int): Double {
	    if (selected > whole || selected <= 0 || whole <= 0) {
	        return -1.0
	    } else if (selected == whole) {
	        return 1.0
	    }
	    
	    // 함수 내부에 factorial을 계산하는 지역함수를 정의하여 사용
	    // 지역 함수에서는 자신을 포함하는 외부 함수의 인자나 변수를 그냥 사용할 수 있다.(여기서는 안썻지만...)
	    fun calcFactorial(num: Int): Double {
	        var total: Double = 1.0
	        for (i in num downTo 1) {
	            total *= i
	        }
	        return total
	    }
	
	    return calcFactorial(whole) / (calcFactorial(whole - selected) * calcFactorial(selected))
	}

    // 코틀린 MutableList 클래스를 상속받지 않고 추가로 swap 기능을 하는 함수를 확장
    fun <T> MutableList<T>.swap(index1: Int, index2: Int) {
        val tmp = this[index1]   // this는 MutableList의 객체를 나타냄
        this[index1] = this[index2]
        this[index2] = tmp
    }


    // 사용예시
    val l = mutableListOf(1, 2, 3)
    l.swap(0, 2)

 // Int 클래스에 정의되어 있는 shl 함수 예시
 infix fun shl(bitCount: Int): Int {
     ...
 }
 val a = 8
 // a+8은 (a+8)로 괄호를 씌우지 않아도 됨. shr()함수 호출보다 +연산자의 우선순위가 더 높음.
 println(a+8 shr 2)

	fun main(args: Array<String>) {
	    println(calcFactorial(10000))
	
	    println(getFibonacciNumber(10000, BigInteger("1"), BigInteger("0")))
	}
	
	// 아래 함수는 tailrec와 무관하게 컴파일 후 재귀함수 형태로 보여진다.
	tailrec fun calcFactorial(num: Int): Double {
	    if (num == 1) {
	        return 1.0
	    }
	    else {
	        return (num * calcFactorial(num -1)).toDouble()
	    }
	}
	
	// 아래 함수는 tailrec 키워드 여부에 따라 컴파일 후 재귀함수형태 or while루프(tailrec키워드가 있는 경우) 형태로 변경된다.
	tailrec fun getFibonacciNumber(n: Int, a: BigInteger, b:BigInteger): BigInteger {
	    if(n==0) {
	        return b
	    } else {
	        return getFibonacciNumber(n - 1, a + b, a)
	    }
	}

// 클래스 이름의 첫 자는 대문자
class Friend {}

// 본체가 없는 경우 {}도 생략이 가능하나.. 이렇게 쓸일이 없을듯.
class Friend

fun main(args: Array<String>) {

    val f1 = Friend1()
    f1.name = "박문수"
    f1.tel = "010-123-4567"
    f1.type = 5
    println(f1.name + "," + f1.tel + "," + f1.type)

    val f2 = Friend2()
    f2.name = "홍길동"
    f2.tel = "010-456-4567"
    f2.type = 5 // set() 함수가 실행되므로 4값이 들어간다.
    println(f2.name + "," + f2.tel + "," + f2.type)


    // named argument를 사용하여 생성자의 인자를 전달
    val f3 = Friend3(tel = "010-678-1234", name = "김선달", type = 5)
    println(f3.name + "," + f3.tel + "," + f3.type)

    val f4 = Friend4("전신주", "010-1111-1234", 3)
    println(f4.name + "," + f4.tel + "," + f4.type)
    
    
    // 실행 결과
    박문수,010-123-4567,5
    홍길동,010-456-4567,4
    김선달,010-678-1234,4
    전신주,010-1111-1234,3
}

class Friend1 {
    // 생성자 정의가 없어 기본 생성자가 자동으로 생성된다

    // 아래의 속성들은 자동으로 getter/setter가 생성된다.
    var name: String = ""
    var tel: String = ""
    var type: Int = 4
}

class Friend2 {
    var name: String = ""
    var tel: String = ""

    // 아래와 같이 커스텀 세터를 정의할 수 있다
    var type: Int = 4
        set(value: Int) {
            // set 함수에서 해당 속성을 액세스 하려면 field 키워드를 사용한다
            if(value < 4) field = value else field = 4
        }
}

// 생성자를 아래와 같의 정의 할 수 있다. 아래 코드와 동일하다
// class Friend3 constructor(var name: String, var tel: String, var type: Int)
// 기본 생성자에서는 constructor 키워드를 생략할 수 있다
// private 와 같은 접근 제한자를 사용하는 경우 constructor 키워드를 생략할 수 없다.
class Friend3 (var name: String, var tel: String, var type: Int)
{
    // 초기화 블록을 사용하여 속성의 값을 초기화 할 수 있다.
    init {
        type = if(type < 4) type else 4
    }
}

class Friend4 {
    var name: String
    var tel: String
    var type: Int

    // java 처럼 보조 생성자를 정의할 수 있다.
    constructor(name: String, tel: String, type: Int) {
        this.name = name
        this.tel = tel
        this.type = if(type < 4) type else 4
    }
}

class Friend2 {
...
	// 멤버 함수 정의
	fun printName(): Unit = println(this.name)
}

fun main(args: Array<String>) {
	val f2 = Friend2()
	// 인스턴스.함수명() 으로 호출
	f2.printName()
}

 open class Father(nameF: String, ageF: Int)
 // 상속관계는 콜론(:)을 사용한다
 // 서브 클래스에서는 슈퍼클래스의 속성도 초기화해주어야 한다.
 class Child(nameC: String, ageC: Int) : Father(nameC, ageC)
 
 // 서브 클래스에 기본 생성자가 정의되지 않고 보조 생성자가 정의된 경우에는 : 과 super키워드를 
 // 사용하여 슈퍼 클래스의 속성을 초기화 한다.
 class Child : Father {
     constructor(nameC: String, ageC: Int) : super(nameC, ageC)
 }

	 open class Father(nameF: String, ageF: Int) {
	    
	    // 속성의 경우도 상속이 가능하다. open 키워드를 사용해야 한다.
	    open val height: Int = 170
	
	    // 속성의 경우도 상속이 가능하다. open 키워드를 사용해야 한다.
	    open var weight: Int = 70
	    
	    // 서브 클래스에서 오버라이딩을 하게 하려면 open 키워드를 사용해야 한다
	    open fun sleep() {}
	    fun looseWeight() {}
	}
	
	class Child : Father {
	    constructor(nameC: String, ageC: Int) : super(nameC, ageC)
	    
	    // 서브 클래스에서는 override 키워드를 사용해야 한다.
	    // val로 정의된 속성은 var로 override 가능하다.
	    override var height: Int = 180
	    
	    // var로 정의된 속성은 val로 override 할 수 없다.
	    // 슈퍼 클래스에 var 속성으로 정의되면 setter가 추가로 생성되어 있게된다. 서브 클래스에서 val로 override하게 되면 슈퍼클래스의
	    // setter가 무의미해진다.
	 // override val weight: Int = 65
	    
	    // 서브 클래스에서는 override 키워드를 사용해야한다
	    override fun sleep() {}
	}

	interface PlayMusic {
	    var musicalInstrument: String
	    fun play()
	    fun stop() {
	        println("stop")
	    }
	}
	
	// 클래스를 상속할때처럼 : 을 사용한다. 클래스 상속처럼 ()를 붙이지는 않는다.
	class Professional(override var musicalInstrument: String) : PlayMusic {
	    override fun play() {
	
	    }
	}

 open class MusicType {
	    open fun sing() {}
	    open fun play() {
	        println("play MusicType")
	    }
	}
	
	interface PlayMusic2 {
	    var musicalInstrument: String
	    fun play() {
	        println("play PlayMusic2")
	    }
	}
	
	// ,을 사용하여 상속과 구현을 나열하면 된다.
	class Professional2(override var musicalInstrument: String) : MusicType(), PlayMusic2 {
	    override fun sing() {}
	    override fun play() {
	    	 // 인터페이스와 슈퍼클래스에 동일 이름의 메서드가 정의되어 있는 경우 super<타입> 키워드를 사용해서 참조하면 된다.
	        super<MusicType>.play()
	    }
	}

	abstract class PlayMusic3 {
	    val musicalInstrument: String = "피아노"
	    abstract fun play()
	    fun sing() {}
	}
	
	class Professional3() : PlayMusic3() {
	    // abstract 멤버 함수를 반드시 오버라이딩 해야 한다.
	    override fun play(){}
	}

	object StateManager {
	    var msgNumber: Int = 0
	    var msgContent: String = ""
	
	    fun storeMessage() {
	        // 데이터를 저장하는 코드
	        println("메시지 번호 = $msgNumber, 내용 = $msgContent")
	    }
	}
	
	fun main(args: Array<String>) {
	    for (i in 1..10){
	        StateManager.msgNumber += 1
	        StateManager.msgContent = StateManager.msgNumber.toString() + "번째 메시지"
	        StateManager.storeMessage()
	    }
	}

 	class Outer() {
 		object InnerObject {
 			var count: Int = 0
 			fun printCount() {
 				println(count)
 			}
 		}
 	}
 	
 	// 아래와 같이 사용 가능하다.
 	Outer.InnerObject.printCount()

 	fun main(args: Array<String>) {
 		OuterClass.printMsg()
 		val m = OuterClass.create()
 		m.printMyClass()
 	}
 	
 	class OuterClass {
 	   private constructor()
 		companion object ComObj { // ComObj는 companion object의 이름이다. 생략할 수 있다.
 			fun printMsg() {
 				println("동반 객체의 함수가 호출됨")
 			}
 			// 동반 객체에서는 private 멤버도 액세스 할 수 있다.
 			fun create(): OuterClass = OuterClass()
 		}
 		
 		fun printMyClass() {
 			println("팩토리 객체의 함수가 호출됨")
 		}
 	}

 	fun countClicks(window: Window) {
 		var count = 0
 		window.addMouseListener(
 		   // 매번 새로운 객체가 생성된다. 싱글톤이 아니다.
 			object : MouseAdapter() {
 				override fun mouseClicked(e: MouseEvent) {
 					count++
 				}
 				override fun mouseEntered(e: MouseEvent) {
 					..
 				}
 			}
 		}
 	}

	class ClassOuter {
	    private val bar: Int = 1
	    class Nested {
	        fun funcNested() = 2 // fun funcNested() = bar 는 에러이다.
	    }
	
	    inner class Inner {
	        fun funcInner() = bar
	    }
	}
	
	fun main(args: Array<String>) {
	    val result1 = ClassOuter.Nested().funcNested()
	    println(result1) // 2가 출력
	
	    val result2 = ClassOuter().Inner().funcInner()
	    println(result2) // 1이 출력
	}

 
    data class Friend7(val name: String, val age: Int, val tel: String)
     
     
    fun main(args: Array<String>) {
	    val test = Friend7("이름", 10, "010-1111-2222")
	    println(test)
	
	    // 아래 java로 변환된 코드로 이해하자. 
	    // test객체의 속성을 추출하여 좌측의 변수에 대입한다.
	    val (fname, fage, ftel) = test
	    println("$fname, $fage, $ftel")
	}

	open class Figure() {
	    open fun draw() {}
	    open fun fill() {}
	}
	
	class Rectangle() : Figure() {
	    override fun draw() {
	        println("Draw rectangle")
	    }
	
	    override fun fill() = println("Fill rectangle")
	}
	
	class Circle() : Figure() {
	    override fun draw() = println("Draw circle")
	
	    override fun fill() = println("Fill circle")
	}
	
	class Window(val figure: Figure) {
	    fun drawFigure() {
	        figure.draw()
	    }
	
	    fun fillFigure() {
	        figure.fill()
	    }
	}
	
	fun main(args: Array<String>) {
	    val r = Rectangle()
	    val c = Circle()
	
	    // 클래스의 상속과 다형성으로 위임 구현
	    Window(r).drawFigure()
	    Window(r).fillFigure()
	    Window(c).drawFigure()
	    Window(c).fillFigure()
	
	}

	interface Figure1 {
	    fun draw() {}
	    fun fill() {}
	}
	
	class Rectangle1() : Figure1 {
	    override fun draw() {
	        println("Draw rectangle")
	    }
	
	    override fun fill() = println("Fill rectangle")
	}
	
	class Circle1() : Figure1 {
	    override fun draw() = println("Draw circle")
	
	    override fun fill() = println("Fill circle")
	}
	
	// Window클래스(delegate)에서는 위임을 받아 실행되는 인스턴스의 함수를 호출하는 코드가 필요 없다.
	// 함수를 오버라이딩 할 수도 있다.
	class Window1(val figure: Figure1) : Figure1 by figure {}
	
	fun main(args: Array<String>) {
	    val r = Rectangle1()
	    val c = Circle1()
	
	    Window1(r).draw()
	    Window1(r).fill()
	    Window1(c).draw()
	    Window1(c).fill()
	}

// enum 키워드를 사용한다
enum class Friendtype {
    SCHOOL, COMPANY, SNS, OTHERS
}

fun getFriendTypeName(friend: Friendtype) =
        when (friend) {
            Friendtype.SCHOOL -> "학교 친구"
            Friendtype.COMPANY -> "회사 친구"
            Friendtype.SNS -> "SNS 친구"
            Friendtype.OTHERS -> "기타 친구"
        }


fun main(args: Array<String>) {
    println(Friendtype.SCHOOL)
    // 0부터 시작한다.
    println(Friendtype.SCHOOL.ordinal)
    println(Friendtype.COMPANY.ordinal)
    // name이라는 기본 속성이 있다.
    println(Friendtype.COMPANY.name)
    println(Friendtype.valueOf("COMPANY"))

    // values() : 모든 항목의 이름을 배열로 반환한다.
    val friends = Friendtype.values()

    for (item in friends) {
        println(item)
    }

    println(getFriendTypeName(Friendtype.OTHERS))
}

// 아래와 같이 enum 클래스 항목의 속성을 우리가 정의할 수도 있다.
enum class RGBColor(val r: Int, val g: Int, val b: Int) {
    RED(255, 0, 0), ORANGE(255, 165, 0), YELLOW(255, 255, 0), GREEN(0, 255, 0), BLUE(0, 0, 255),
    INDIGO(75, 0, 130), VIOLET(238, 130, 238);  // enum클래스의 멤버 함수를 정의하는 경우 세미콜론(;)을 써야한다.

    fun rgbValue() = (r * 256 + g) * 256 + b
}

// 코틀린 1.1 이전에는 하위 클래스가 중첩되어야 했으나, 현재는 아래와 같이 사용할 수 있다.
sealed class Expr
data class Const(val number: Double) : Expr()
data class Sum(val e1: Expr, val e2: Expr) : Expr()
object NotANumber : Expr()

// when에 else가 필요 없다.
fun eval(expr: Expr): Double = when(expr) {
    is Const -> expr.number
    is Sum -> eval(expr.e1) + eval(expr.e2)
    NotANumber -> Double.NaN
    // the `else` clause is not required because we've covered all the cases
}

// 기존 형태의 덧셈 함수
fun sum1(a: Int, b: Int): Int{
    return a + b
}

// 코틀린의 대입문 형태로 정의된 뎃셈 함수
fun sum2(a: Int, b: Int): Int = a + b

fun main(args: Array<String>) {
    println("합계는 ${sum1(10, 20)} 입니다.")
    println("합계는 ${sum2(10, 20)} 입니다.")

    // 람다식으로 작성된 덧셈 함수 #1
    val sum3: (Int, Int) -> Int = {x, y -> x + y}
    println("합계는 ${sum3(10, 20)} 입니다.")

    // 람다식으로 작성된 뎃셈함수 #2
    val sum4 = {a:Int, b:Int -> a + b}
    println("합계는 ${sum3(10, 20)} 입니다.")

}

button.setOnClickListener(new OnClickListener() {
	@Override
	public void onClick(View view) {
		/* 버튼 클랙시 실행될 코드 */
	}
}

button.setOnClickListener { view -> /* 버튼 클랙시 실행될 코드 */ }

val list = listOf(1, 2, 3, 4, 5)
// 하나의 매개변수만 갖는 람다식의 경우 기본으로 생성되는 it으로 매개 변수를 대체할 수 있다.
println(list.filter { it % 2 == 0})

// 각각의 요소에 10을 더한 값을 갖는 새로운 list를 생성하고 출력
println(list.map {it + 10})


data class Friend (val name: String, val age: Int, val tel: String)

val fr = listOf(Friend("김선달", 30, "010-1111-2222"), Friend("홍길동", 25, "010-2222-3333"))
// list에서 30세 이상인 친구의 이름만 출력
// 객체의 멤버(속성이나 함수)는 클래스이름::멤버이름의 형태로 참조가 가능하다.
println(fr.filter {it.age >= 30}.map(Friend::name))

println(fr.filter { it.age >= 30})

// 위 코드를 익명함수를 사용하면 다음과 같이 작성할 수 있다.
println(fr.filter(fun (friend) = friend.age >= 30))

println(
	fr.filter(
		fun (friend): Boolean {
			return friend.age >= 30
		)
	)
}

    val value: Int = 100
    val list2 = listOf(1, 2, 3, 4, 5)
    println(list2.map {it + value})
    println(list2.map(fun (it): Int { return it + value}))

val sum3: (Int, Int) -> Int = {x, y -> x + y}

fun calc(value1: Int, value2: Int, execCode: (Int, Int) -> Int): Int {
    return execCode(value1, value2)
}

fun main(args: Array<String>) {
    val v1 = calc(2, 7, {a, b -> a * b})
    val v2 = calc(2, 7, {a, b -> a + b})
    val v3 = calc(2, 7, {a, b -> a - b})

    println(v1)
    println(v2)
    println(v3)
}

inline fun calc(value1: Int, value2: Int, execCode: (Int, Int) -> Int): Int {
    return execCode(value1, value2)
}

inline fun makeMoney(lambda1: () -> Int, noinline lambda2: (Int) -> Unit) {
	// 실행될 코드
}

throw MyException("예외 발생!")

try {
	// 실행중 예외가 발생할 수 있는 코드
} catch (e: SomeException) {
   // SomeException이 발생한 경우 처리하는 코드
} finally {
   // finally 블록은 생략 가능하다.
}

val err: Int? = try { parseInt(vale)}
					catch (e: NumberFormatException) { null }

val s = fr.name ?: throw IllegalArgumentException("이름을 입력하세요")

val err = fr.name ?: fail("이름을 입력하세요)

fun fail(message: String): Nothing {
	throw IllegalArgumentException(message)
}