둔필승총

제어문

if문

- java와 같은 형태로 사용 가능함 

- 코틀린에서는 if문을 하나의 표현식으로 간주하며, 값을 반환한다. 변수의 대입문에 식처럼 사용이 가능하다.

(아래와 같이 a>b이면 a가 result에 대입, else에 해당하면 b가 result에 대입된다)

val result = if(a>b) a else b

- 조건에 따라 여러 표현식을 실행해야 하는 경우,
블록의 마지막 값이 반환된다.(if문 내의 블럭 내에 여러 줄의 식이 있다면 리턴값은 마지막줄이 된다.)

--> Kotlin에서는 삼항 연산자를 지원하지 않으므로 이를 if문으로 구현할 수 있는 것이다. 

val a = -9
val b = -11
val max = if(a>b){
    println("$a is larger than $b ")
    println("max variable holds value of a")
    a
}else{
    println("$b is larger than $a")
    b
}

when 문

- Switch 구문에 대응하는 구문, 실행해야할 구문은 화살표 뒤에 해당. when구문은 표현식으로 사용될 수 있다.

val x = readLine()!!
when (x) {
    1 -> print("x == 1")
    2 -> print("x == 2")
    else -> { // Note the block
        print("x is neither 1 nor 2")
    }
}

- when문을 조건문으로 사용한 경우

val start = 0
val end = 100
val score = 60

when(score){
    in 90..end->println("우수함")
    50->println("평균임")
    in start..end -> println("범위에 있음")
    else -> println("범위를 벗어남")
}

for문

- For each 구문과 비슷

1. 배열에 있는 값을 가져다가 반복할 수 있다

val numbers = arrayOf(1,2,3,4,5)
for(num in numbers){
    println(num)
}

2. index를 기반으로도 반복할 수 있다

val numbers = arrayOf(1,2,3,4,5)
for(index in numbers.indicies){
    println("number at $index is ${numbers[index]}")
}

여기서 indicies는 arrayOf안에 있는 원소들의 index를 의미한다

3. for 내부도 표현하는 방법 여러가지

for(i in 1..3){}
for(i in 0..10 step 2){} // 2씩 건너띄면서 i 증가
for(i in 10 downTo 0 step 2{}
for(i in 1 until 10){}
repeate(10){} // 10번 반복해

val numbers = arrayOf(2,4,6,8,10)
    for(index in numbers.indices step 2){
        println(numbers[index])
    }
//2 6 10 출력됨

while 문 : java와 동일 -> do while도 쓸 수 있다.

    var x = 10
    while(x>0){
        println(x)
        x--
    }

fun main(){
    val items = listOf("사과","오렌지","김태헌")
    var index = 0
    do{
        println("${index}에 있는 item은 ${items[index]}이다.")
        index++
    }while(index<items.size)
}

Break구문

: 가장 가까이의 반복문을 벗어난다

- Labeled break -> 반복문을 한꺼번에 벗어나고 싶을때 사용

   -> 반복문에 label을 붙여주면 된다. label은 label명@을 붙여서 표시해준다.

    first@ for(i in 1..4){
        second@ for(j in 1..2){
            println("i= $i j= $j")
            if(i==2)
                break@second
        }
    }
    	// i= 1 j= 1
	// i= 1 j= 2
	// i= 2 j= 1
	// i= 3 j= 1
	// i= 3 j= 2
	// i= 4 j= 1
	// i= 4 j= 2

각 반복문마다 label 붙여주는 것도 가능하다.

-->(주의) break@first -> 공백이 있으면 안된다.

Continue 구문

: 이 구문을 만나면 아래의 구문 실행 생략하고 제어를 반복문으로 옮기는 경우

- Labeled continue : Labeled break문과 비슷하다 (반복문 사용할때 유용하게 사용된다)

here@ for (i in 1..5){
    for(j in 1..4){
        if(i==3||j==2)
            continue@here
        println("i=$i; j=$j")
    }
}

Functions 함수

fun 함수(인수1:자료형1, 인수2:자료형2, ...) : 반환자료형 {} 

인자 생략 가능,반환값이 없는 경우 Unit 및 생략가능

fun main(){
    fun greet(str:String):Unit{
        println(str)
    }
    greet("201811177 김태헌")
}

-> 코틀린에서의 인자는 immutable variable( val에 해당-> 변경 불가 )

반환값이 없는 경우 Unit사용해도 된다.

- 간단한 값을 반환하는 경우 { } 생략 가능

fun main(){
    fun greet(str:String):Unit{
        println(str)
    }
    // greet("201811177 김태헌")
    fun getName(firstName:String, lastName:String):String = "$firstName $lastName"
    println(getName("김","태헌"))
}

디폴트 매개변수

- 매개변수의 값을 입력하지 않으면 디폴트 값을 가지게 된다.

--> 함수 오버로딩과 비슷한 효과를 낼 수 있다

첫번째 인자는 default, 두번째 인자는 새로운 값을 주고싶을때?

--> 매개변수의 이름을 사용하면 매개변수의 위치에 상관없이 사용 가능함

fun main(args:Array<String>){
    foo('x',2) //x 2
    foo() // a 15
    foo('y')// y 15
    foo(number=234) // a 234
}
fun foo(letter:Char='a',number:Int = 15){
    println("$letter $number")
}

함수의 다양한 종류

infix 함수 : 함수의 중위적 표현 가능

ex> shift 연산자는 일반 함수였는데 연산자처럼 호출이 가능했음

infix함수이면 p.createPyramid(4)라고 해도 되지만 p createPyramid 4 이렇게 호출도 가능

class Structure(){
    infix fun createPyramid(rows:Int){
        var k=0
        for(i in 1..rows){
            k=0
            for(space in 1..rows-i){
                print(" ")
            }
            while(k!=2*i-1){
                print("* ")
                ++k
            }
            println()
        }
    }
}
fun main(){
    val p = Structure()
    p createPyramid 4 //p.createPyramid(4)와 동일
}

재귀함수(Recursive Function) : 무한 루프에 빠지지 않도록 주의해서 사용

fun factorial(n:Int):Long {
	return if(n==1) n.toLong() else n*factorial(n-1)
}

-> 함수가 계속 stack에 쌓여서 stack overflow를 자주 발생시킨다 -> 코틀린에서는 이를 해결하기 위해 꼬리 재귀 함수(Tail Recursive Function)이라는 것이 있다.

꼬리 재귀 함수(Tail Recursive Function)

: 기존의 재귀함수는 모든 재귀 호출이 완료될 때까지는 결과를 얻을 수 없었으나, 꼬리 재귀에서는 계산이 먼저 수행되고, 재귀 호출이 수행되는 구조

- 컴파일러가 stackoverflow가 발생하지 않도록 효율적인 순환 기반의 버전으로 최적화한 것이다.

꼬리 재귀는 '재귀 호출이 끝나면 아무 일도 하지 않고 결과만 바로 반환되도록 하는' 방법이다. 이 방식을 사용하면 이전 함수의 상태를 유지하지도 않고 추가 연산을 하지도 않아서 스택이 넘쳐나는 문제를 해결할 수 있게 된다.

val eps = 1E-15 // 10^-15
tailrec fun findFixPoint(x:Double = 1.0) : Double
 = if(Math.abs(x-Math.cos(x))<eps)x else findFixPoint(Math.cos(x))
 // 꼬리 재귀함수는 아래처럼 순환구조가 되는 형식으로 만들어진다.
private fun findFixPoint():Double{
	var x=1.0
    while(true){
    	val y = Math.cos(x)
        if(Math.abs(x-y)<eps) return x
        x = Math.cos(x)
    }
}

https://joooing.tistory.com/entry/%EC%9E%AC%EA%B7%80-%E2%86%92-%EA%BC%AC%EB%A6%AC-%EC%9E%AC%EA%B7%80-Tail-Recursion

일반 재귀는 값을 받으면, 그 값에 연산을 하고 다른 함수에게 전달을 해줬었다. 하지만 꼬리재귀는 '아무것도 하지 않고' 값을 전달한다.

예제. 꼬리재귀 함수

--> 꼬리 재귀 함수를 사용해서 피보나치 수열의 n번째 항을 반환하는 fibonacci 함수를 만들어주세요.

import java.math.BigInteger
fun main(){
    val n=10000
    val first = BigInteger("0")
    val second = BigInteger("1")
    println(fibonacci(n,first,second))
}

fun fibonacci(n:Int,a:BigInteger,b:BigInteger):BigInteger{
    return if(n==0) a else fibonacci(n-1,b,a+b)
}

stackoverflow를 해결하려면 순환구조로 바꾸어 줘야 한다.

import java.math.BigInteger
fun main(){
    val n=10000
    val first = BigInteger("0")
    val second = BigInteger("1")
    println(fibonacci(n,first,second))
}

tailrec fun fibonacci(n:Int,a:BigInteger,b:BigInteger):BigInteger{
    return if(n==0) a else fibonacci(n-1,b,a+b)
}

람다 함수(Lambda)

- Kotlin에서는 함수 반환 자료형 생략도 가능했고 블록도 생략해서 함수를 하나의 변수처럼 표현할 수 있었다.

fun add(x:Int,y:Int):Int{
    return x+y
}
fun add2(x:Int,y:Int) = x+y

한번 사용하고 마는 함수들 이름도 필요한가..?

- 람다 함수 : 익명 함수를 간결하게 표현할 수 있는 방법

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

함수가 일반 타입처럼 사용된다. 

- 코틀린의 람다식

- 형식 : { 매개변수 -> 함수내용 }

- 람다 함수는 항상 { } 로 감싸서 표현

- 인수 목록을 나열하고 -> 이후에 본문 위치

- 인자는 ( ) 로 감싸지 않음

- 인자는 형식 추론이 가능하므로 타입 생략 가능

- 함수 반환값은 함수 내용의 마지막 표현식(함수 반환값이 있다면)

- 변수에 람다식을 저장하고, 변수를 일반 함수처럼 사용

  - 변수에 대입하지 않으면 이후 람다 함수를 사용할 수 없음 -> 정의된 이후에 사용할 수 없다.

   -----> 이런 경우

     - 람다 함수 뒤에 ()를 추가하여 함수 호출

     - Run() 함수에 대입해도 바로 함수가 호출되어 실행

{println("Hello")}()
run{println("World")}

fun main(){
    val add = {x:Int,y:Int->x+y} //타입 추론
    val add2:(Int,Int)->Int = {x,y -> x+y} //타입 명시적으로 줌
    println(add(10,20))
    println(add2(10,20))
    val add3 = {x:Int,y:Int -> println(x+y)} //반환안하고 출력
    add3(10,20)
    
    println({x:Int,y:Int->x+y}(10,20))
}

SAM(Single Abstract Method) 변환

- 추상 메서드 하나를 인수로 사용할 때만 대신 함수 인수 전달

코틀린에서는 추상 메소드 하나를 인수로 사용할 때는 함수를 인수로 전달하면 편하다. 자바로 작성된 메소드가 하나인 인터페이스를 구현할 때는 대신 함수를 작성할 수 있다.

안드로이드에서는 버튼의 클릭 이벤트를 구현할 때 onClick() 추상 메소드만을 가지는 View.OnClickListener 인터페이스를 구현한다.

버튼을 클릭했을 때 실행되는 함수들은 onClickListener라는 interface에 정의되어 있다. 

자바에서는 changeBtn 객체에 setOnClickListener라는 함수를 통해서 interface객체를 입력으로 넣어주게 되는데 onClickListener라는 것은 인터페이스이니까 인터페이스를 구현하는 방법은 여러가지가 있다. 여기서는 익명클래스에 객체를 만들어서 사용하는 경우이다. 익명 클래스로 만들어도 클래스의 이름은 없지만 인터페이스이니까 인터페이스에 정의된 abstract method를 구현해 준다. 

Java

changeBtn.setOnClickListener(new View.OnClickListener() {
	@Override
    public void onClick(View v){
    	changeBtn.setBackgroundColor(Color.CYAN);
    }
});

Kotlin

changeBtn.setOnClickListener{
	view->changeBtn.setBackgroundColor(Color.CYAN)
}
// 구현되는 인터페이스 내에 추상메서드가 딱 하나만 가지고 있을때 객체 대신 람다함수를 인자로 전달

-> 인터페이스에 추상메서드가 하나일때만 쎈 변환 적용.

view라는 인자도 함수내에서 사용안하면 _ 사용하거나 생략할 수 있다.

changeBtn.setOnClickListener{
	_->changeBtn.setBackgroundColor(Color.CYAN)
}

changeBtn.setOnClickListener{
	changeBtn.setBackgroundColor(Color.CYAN)
}

인수를 사용해야될 필요가 있으면 it이라는 키워드를 사용하면 된다. it은 생략된 객체를 접근할 때 사용할 수 있다.

changeBtn.setOnClickListener{
	it.visibility = View.INVISIBLE
}

람다식의 인수가 하나인 경우는 it(view) 로 인수 접근 ---> 여러개인 경우 안됨

- 인터페이스에서 추상메서드는 하나인데 추상메서드의 인자가 여러개 있는경우?

--> 인자를 나열해주면 된다

Kotlin

changeBtn.setOnTouchListener{
	v,event-> // 인자 나열
    changeBtn.setBackgroundColor(Color.CYAN) //함수 본문
    false //반환
}

- 함수를 인자로 전달했었다

함수도 타입, 값으로도 대입이 된다.

- 함수 타입의 변수 선언 : 함수 타입 변수에서는 리턴을 쓰지 않고, 마지막 줄이 반환됨

val functionType1 : () -> Unit
val functionType2 : (Int) -> Unit
val functionType3 : (Int, String) -> String

functionType1 = { println("greenjoa")}
functionType2 = {age-> println("나이")}
functionType3 = {age,name->println("나이") "나이"}

High - Order Function

- 함수의 인수로 함수나 람다식을 받거나 반환할 수 있는 함수

확장 함수

- 클래스에 새로운 함수를 추가

  - 기존 방식은 상속을 통해 새로운 클래스를 만들고, 함수 추가

  - 확장함수는 클래스 밖에서 정의된 클래스의 멤버 함수

     - 멤버 함수를 오버로딩한 경우 확장 함수가 호출됨

  - ex> string의 처음과 마지막 문자 삭제 함수 -> string클래스에 존재하지 않는 함수

fun String.removeFirstLastChar():String = this.substring(1,this.length-1) // String내의 substring함수

예제>

fun calculate(x:Int, y:Int,func:(Int,Int)->Int):Int{
    return func(x,y)
}

fun String.removeFirstLastChar():String = this.substring(1,this.length-1)

fun main(){
    println(calculate(10,20){x,y->x+y})
    println(calculate(10,20){x,y->x*y})
    println(calculate(10,20){x,y->if(x>y)x else y})

    println("HelloWorld".removeFirstLastChar())
}

코틀린은 안드로이드 애플리케이션 공식 개발언어이다. 안드로이드 애플리케이션은 자바와 코틀린으로 개발할 수 있다.

코틀린의 특징
- 코틀린 컴파일러는 JVM(자바 가상머신)에서 실행되는 자바 바이트 코드(클래스 파일)를 생성하므로,

자바와 완벽하게 호환되는 크로스 플랫폼을 지원
  - 자바 애플리케이션이 실행 가능한 환경이면 코틀린 애플리케이션도 실행 가능
  - 다음과 같은 애플리케이션 작성 가능
    - 네이티브 애플리케이션
    - 웹 브라우저에서 실행되는 자바스크립트
    - 서버에서 실행되는 Http 서블릿
    - 구글 안드로이드 애플리케이션
- 객체지향 프로그래밍 지원
- 함수형 프로그래밍 지원함
- 문법과 코드 간결

- 코틀린 개발 IDE : IntelliJ, Android Studio, Eclipse, Compiler

기본타입

- 코틀린에서 모든 것이 객체 : 멤버함수나 프로퍼티 호출할 수 있다
- Numbers(Byte,Short,Int,Long,Float,Double), Character(Char), Boolean, Array, String

- Char가 코틀린에서는 숫자형이 아니다

• Numbers
  • 10진수 : 123
  • 16진수 : 0x0F
  • 2진수 : 0b00000010101001
  • 8진수는 지원하지 않는다
• Long : 123L
• Double : 123.9, 123.3e10
• Float : 13.4f
• Underscores( _ ) : 숫자가 길어서 실수할 수 있어서 구분자를 주는 것
  • val oneMillion = 1_000_000
  • val creditCardNumber = 1234_5678_3456L

- Explicit Conversions

  - 작은 타입은 큰 타입의 하위 타입이 아니다 -> 작은 타입에서 큰 타입으로 대입이 안된다(서로간에 상속관계가 없다)

모든 숫자 데이터 클래스는 Number라는 추상 클래스를 상속하고 있다
val a:Int =1
val b:Long = a //오류

val a:Int =1
val b:Long = a.toLong()

<타입 변환 함수들>
toByte() toShort() toInt() toLong() toFloat() toDouble() toChar()

- 산술 연산에서는 묵시적 변환이 이루어짐
val num = 1L + 3 // Long + Int => Long

• Characters
  • char는 숫자로 취급되지 않음, 비교도 하면 안됨 ex> char c ==1 (오류)

변수 및 상수

- 클래스의 멤버 변수 및 전역 변수는 반드시 선언하면서 초기화해야 함

- 지역 변수의 경우, 선언 후 사용 가능하다(단, 초기화가 되어 있지 않으면 사용할 때 에러 발생함)

변수(Variable, mutable variable)

형식 : var variable:Type = value 

var a: Int = 7

var b: Double = 10.5

상수(Value, immutable variable) => Java에서는 final 키워드에 해당한다

형식 : val variable:Type = value

val variable:Type = value
val a: Int = 7
val b: Double = 10.5

숫자 타입
val a = 100 // 자동 추론(Int) -> 생략 가능
val b:Long = a // 숫자 타입간 변환 자동으로 해주지 않음, Int타입에서 Long타입으로 변환 안된다. 꼭 명시적으로 형변환 해줘야함
val b:Long = a.toLong() // 변환 함수 사용
val b:Long = a + 1L // 표현식을 Long 타입으로 변환 
val b:Long = a+3.5 // 에러난다

문자열 : String 타입

// Escape string
val s1 = "hello\nworld"
// Raw String -> 입력형태 그대로 출력한다 (""" """ 사용)
val s2 = """hello world"""
Raw String에는 trim이라는 기능을 사용할 수 있다.
trimIndent() -> 들여쓰기 했던것을 지우겠다.
trimMargin(">") -> 파라미터로 준 기호(여기서는 >)까지 trim하겠다.

String 타입을 숫자로 변환하고 싶으면 명시적으로 변환함수를 호출해주면 된다.
toInt() , toDouble()
변수나 상수 출력할때는 $기호를 사용하고 변수명을 주면 된다.

${표현식}--> 계산이 된다.

문자열 비교
== : java의 equals()와 동일

모든 변수는 null을 허용하지 않음
- 객체의 생성과 동시에 초기화해야 함
- Null을 허용하려면 물음표(?)를 추가해야 함
- 타입을 생략할 수 없음

var str:String? = "hihello"
str = null (가능)

val a:String //오류
val b:String? = null
var c:String // 오류
var d:String? = null

Variable Nullable
- Lateinit 키워드로 나중에 초기화 가능 -> 쓰기전에 초기화 꼭 해주기
- Var 변수에만 사용 가능
- Null 값으로 초기화할 수 없음
- 초기화 전에는 사용할 수 없음
- Int, Long, Double, Float 등 기본 데이터 타입에는 사용할 수 없음

lateinit var c: String
c="Hello"
println(c)

- Lazy로 늦은 초기화
- Val 에 사용하여 늦은 초기화
- 초기화 블록에 초기화에 필요한 코드 작성
- 처음 호출될 때 초기화 블록의 코드가 실행됨
- 마지막 줄에는 초기화할 값을 명시함

val str:String by lazy{
	print("초기화")
	"Hello"
}

이렇게 되면 처음에는
println(str) 하면 초기화Hello
그다음에 println(str) 하면 Hello출력됨

같은 String 타입이여도 Null값을 가질 수 있는 타입과 가질 수 없는 타입으로 구분이 된다.
두 타입은 같은 타입이여도 대입이 되지 않는다.
!!: Null값이 아님을 보증(!!)
- 변수 뒤에 !!를 추가하면 null값이 아님을 보증 -> 아닐 경우 에러

val name:String? = "greenjoa"
val name2:String = name //오류
val name3:String? = name // OK
val name4:String = name!! // OK

변수 및 상수: Variable Nullable
안전한 호출(?.)
- Null 값이 아닌 경우에만 호출

val str:String? = null
var upperCase = if(str!=null) str else null // null

upperCase.toUpperCase() // 에러

-> String값이 될거라고 예상했지만 지금은 null값이기 때문에 멤버함수 호출 불가-> if문으로 해서 해결
upperCase = str?.toUpperCase() // null -> str이 null값이 아니면 뒤에부분 실행해서 반환하고 아니면 그냥 str반환

엘비스(Elvis) 연산자 (?:) -> null일 경우 default값을 지정할때 사용
- Null이 아닌 기본 값을 반환하고 싶을 때 사용
val str:String? = null
var upperCase = str?.toUpperCase() ?:"초기화하시오" --> str이 null값인 경우 "초기화하시오"구분을 넣겠다
// 꼭 ?.이랑같이 쓸 필요는 없음

var upperCase = str?:"초기화하시오"

배열
Array클래스
- Array<String>과 같이 제너릭 타입으로 나타냄
- 배열은 크기를 변경할 수 없음
배열 생성 - arrayOf 함수
- val item: Array<Any> = arrayOf(1,"바나나",false)  

//자바에서 object타입에 해당, 꺼낼때는 어떤 type인지 모르니까 typecasting해서 사용하자
- val item:Array<String> = arrayOf("사과", "바나나", "키위") 
빈 배열 생성도 가능
// val arr = arrayOfNulls<Int>(10)

배열 생성 - Array 생성자 // 생성자에는 배열의 크기와 init이라고 하는 함수가 인자로 들어감, 각 원소는 init함수에 의해서 초기화 됨

val item2 = Array<String>(5) { i->(i*i).toString() } // 람다 함수
	item2[0] = item[1]
	for(fruit in item2){
		println(fruit)
}

앞선 것은 제너릭 타입
기본 타입 요소를 저장하는 배열 클래스 // 이것도 array타입, 생성자 둘다 가능하다.

val item: IntArray = intArrayOf(1,2,3,4,5)
val item2: IntArray(5) { j->(j*j) }
	for(num in item2){
		println(num)
}

ByteArray, ShortArray, IntArray, LongArray, FloatArray,... 등등 사용가능

연산자
- 연산자와 연산자 오버로딩
: 내부적으로 연산자 오버로딩(overloading)한 함수를 사용해서 연산을 처리
a+b // a.plus(b) // a와b의 값을 더한다

=> 6개가 된다는 의미는 다른 타입과는 덧셈 연산이 안된다는것을 의미한다.
연산자 오버로딩을 클래스에 오버로딩해서 만들면 된다.

-단항 연산자
+a, -a, !a, ++a, a++, --a, a--
-복합 대입 연산자
a+=b
a-=b
a*=b
a/=b
a%=b
-비트 연산자 - 오버로딩하고 있지 않음
그냥 함수를 호출해서 사용한다.
8 shr 2
8 shl 4
infix라는 키워드를 가지고 있어서 연산자 처럼 사용할 수 있다.

- 논리 연산자
and, or, not 기호 연산자도 사용가능한데 기능은 살짝 다름
and 연산자는 단락평가를 하지 않는 연산
&&은 단락평가를 적용해서 연산을 한다
- 동등 비교 연산자 
=== : 오버로딩 안됨(참조값이 같은지 판단)

in 연산자
- 특정 객체가 컬렉션에 저장되어 있는지 확인
범위(..) 연산자
- a..b : a에서 b까지의 범위 값이 생성 => a.rangeTo(b) 코드로 변환

val start = LocalDate.now()
val end = start..start.plusDays(15)
println(start.plusWeeks(1) in end) // 있으면 true 없으면 false -> 여기서는 true

- 인덱스 연산자
a[i] -> a.get(i)

- invoke 연산자 : 객체를 통한 함수 호출
invoke 오버로딩하면 클래스의 instance를 함수처럼 사용할 수 있다. 

- 타입 확인 연산자 : is, !is

입출력
- 출력 : println 함수 사용
- 입력 : readline함수-> 한 라인을 입력받음
타입 바꾸고 싶으면 명시적으로 toInt() 이런거 쓰면된다.

아니면 Java패키지 import해서 java.util.Scanner쓰면 된다.
치환 연산자 사용하면 됨(스캐너 객체 생성에만 주의)

print("Enter text: ")
val stringInput = readLine()!!
println("You entered: $stringInput")

//자바의 Scanner 객체 사용(import java.util.Scanner)
val reader = Scanner(System.`in`)
print("Enter a number: ")
var integer:Int = reader.nextInt()
println("You entered: $integer")

난수 발생

// 1. Java의 Random 클래스 사용
// Java.util.random 클래스 import 해야 함
val num = Random().nextInt(10)
// 2. Kotlin에서의 사용
val num = (0..10).random()

코틀린 이란?

- Jetbrains 사에서 개발 하였다 (Android Studio를 다운받을때 사용한 곳)

- 2017년에 안드로이드 공식지원언어로 채택되었다 (원래 Java밖에 없었는데 Kotlin이 추가됨)

코틀린이 좋은 이유

- 문법이 간결하며, 표현력이 좋다

- Null safe 언어이다

- 기존 라이브러리와 상호운용성이 좋다 (자바와 100% 호환이 된다)

코틀린에서 변수 선언하는 방법

1. var/val 변수명 = 값

var은 variable의 축약어, val은 valuable의 축약어

둘 중에 아무거나 고르는 것이 아니라 서로 차이가 있다.

var은 마음대로 원하는 것을 넣을 수 있다.

val은 한 번 넣으면 바꿀 수 없는 변수 선언명.

var num = 10
val hello = "안녕하세요"

2. var/val 변수 : 자료형 = 값

var number1 : Int = 20
var hello1 : String = "Hello"
var point1 : Double = 3.4

2가지 변수 선언법에서 알 수 있는것은 코틀린은 2번과 같이 자료형을 적어주지 않을경우 알아서 자료형을 정한다.

코틀린에서 프로그램이 작동하는 곳

: 실행되는 부분의 코드는 다음과 같다.

fun main(args:Array<String>){

    
}

여기 안에 코드를 입력하면 된다.

Run을 실행하고 싶은데 안보이는 경우가 있을 수 있다. 이럴때는 [File]->[Settings]에서 Deployment를 검색해서 둘 다 체크해주면 된다. 

변수 활용 

var a = 1+2+3+4+5
var b = "1"
var c = b.toInt()//b를 int로 바꾼값이 저장됨
var d = b.toFloat()//d에는 1.0이 있음

var e = "John"
var i = "My name is $e Nice to meet you"

fun main(array:Array<String>){
    println(a)
    println(b)
    println(c)
    println(d)
    println(e)
    println(i)
}

3번째 줄에서 toInt()와 4번째 줄의 toFloat()는 각각 int와 float로 바꾸어주는 것이다. 

그리고 변수 e는 John으로 들어가있고 i 문자열에서 $e를 써서 대입할 수 있다.

//var abc : Int = null
var abc1 : Int? = null

자료형 뒤에 ?를 붙이면 null을 가질 수 있는 자료형이 된다.

함수

함수
 -어떤 input을 넣어주면 어떤 output 나오는 것

함수를 선언하는 방법
fun 함수명 (변수명: 타입, 변수명: 타입....) : 반환형{
  함수내용
  return 반환값
}

fun plus(first:Int,second:Int):Int{
    val result : Int = first+second
    return result
}

fun main(array:Array<String>){
    val result = plus(5,10)
    println(result)

    val result2 = plus(first=20,second=30)
    println(result2)
}

디폴트 값을 갖는 함수 만들기

fun plusFive(first:Int,second:Int=5):Int{
    val result:Int = first+second
    return result
}

main에서 plusFive함수를 실행하면 된다. second인수를 주지않으면 자동으로 디폴트 값인 5가 들어가서 계산된다.

반환값이 없는 함수 만들기

fun printPlus(first:Int,second:Int):Unit{
    val result:Int =first+second
    println(result)
}

반환값 입력받는 공간에 Unit으로 두면 반환값 없이도 함수를 만들 수 있다. Unit은 생략이 가능하다.

위와 같은 사실에서 우리는 main함수에 대해서 유추해 볼 수 있다. 

fun main(array:Array<String>){

여기서 array변수는 Array<String> 타입의 변수라는 것을 알 수 있다. 그리고 이 함수에는 반환값이 없다는 것도 알 수 있다.

간단하게 함수를 선언하는 방법

fun plusShort(first:Int, second:Int) = first+second

가변인자를 갖는 함수 선언하는 방법

fun plusMany(vararg numbers: Int) {
    for (number in numbers){
        println(number)
    }
}

fun main(array: Array<String>) {
    plusMany(1,2,3)
}

내부 함수 : 함수 안에 함수가 있다.

fun showMyPlus(first:Int,second:Int):Int{
    fun plus(first:Int,second:Int):Int{
        return first+second
    }
    return plus(first,second)
}