함수

왜 함수 내 함수 사용 이유

파라미터?

 

왜 패키지  이유

모듈별로 구분, 협업에 용이

 

왜 자바에는 없는 코틀린의 기능(범위: '..' 'unitl' ',') (소속: 'in')

 

Kotlin 함수의 예

import kotlin.math.PI // kotlin.math 패키지에서 PI 상수를 가져옴
fun circleArea(radius: Double): Double {  //함수의 정의
	return PI*radius*radius
}
fun main() {
	print("Enter radius: ")
	val radius = readLine()!!.toDouble() 
    println("Circle area: ${circleArea(radius)}")
}

fun circleArea(radius: Double): Double
  1          2              3           4             5

1 함수의 정의가 뒤에 나옴을 명시 

2 함수의 이름

3 첫번째 파라미터

4 첫번째 파라미터의 타입

5 반환값의 타입

 

Kotlin 함수의 특징 (1)

• 파라미터의 타입은 항상 지정해야 한다. 

fun circleArea(radius: Double): Double // (O)
fun circleArea(radius) : Double // (X)

 

• 반환값이 없는 경우만 반환값의 타입을 생략할 수 있다.
• C의 void 함수에 해당하며 이는 Kotlin에서는 Unit이라는 타입의 생략임

fun prompt(name: String) {
	println("*** Hello, $name! ***") 
}
fun prompt(name: String): Unit { //위 함수와 동일
	println("*** Hello, $name! ***") 
}

 

Kotlin 함수의 특징 (2)

• 파라미터의 값은 수정이 불가능 하다.
• 파라미터는 val(불변) 변수의 특성을 가짐

fun foo(bar: Int) : Int {
	bar += 1 // Error
	return bar
}

 

• 위함수는다음과같이수정해야함

fun foo(bar: Int) : Int { 
	val baz = bar + 1 //새로운 변수 baz
	return baz 
}

 

식 하나가 본문인 함수

• 식 하나로 표현이 가능한 함수의 경우 return을 생략하고 =로 함수 선언과본문을연결할수있음

fun circleArea(radius: Double): Double = PI * radius * radius

• 식에서 반환값의 타입이 유추가 가능한 경우 반환 타입 생략가능

fun circleArea(radius: Double) = PI * radius * radius

 

함수의 호출

• 다음의 함수를 호출할 때

fun rectangleArea(width: Double, height: Double) = width * height

• 다음의 세가지 형태가 모두 가능하며 동일한 의미이다.

rectangleArea(w, h)
rectangleArea(width = w, height = h)
rectangleArea(height = h, width = w)

• 즉 파라미터의 이름으로 인자를 전달할 수 있다.

 

함수의 오버로딩

• 오버로딩: 동일한 이름의 함수를 파라미터 타입의 변이에 따라 여러 버전으로 정의하는 프로그래밍

• fun readInt() = readLine()!!.toInt()
• fun readInt(radix: Int) = readLine()!!.toInt(radix) // 두함수 동시 정의 가능

 

• 함수 호출시 오버로딩 해소 규칙

1 파라미터의 개수와 타입을 기준으로 호출할 수 있는 모든 함수를 찾는다

2 덜 구체적인 함수를 제외시킨다. 어떤함수의 파라미터 타입이 다른  함수에 비하여 포괄적일 경우 이를 제외한다.

이 과정을 하나의 함수가 남을 때까지 반복한다.

3 하나가 남으면 해당 함수를 호출한다. 두개 이상이 남으면 컴파일 에러를 발생시킨다.

 

함수 오버로딩의 예

• 함수들의 정의

1 fun mul(a: Int, b: Int) = a * b
2 fun mul(a: Int, b: Int, c: Int) = a * b * c 
3 fun mul(s: String, n: Int) = s.repeat(n) 
4 fun mul(o: Any, n: Int) = Array(n) { o }

• mul(1, 2) //1
• mul(1L, 2) //4 
• mul("0", 3) //3
• mul("0" as Any, 3) //4

 Any 란?

• 모든 객체의 최상위 타입

• 가장 포괄적인 개념의 타입

• as Any 란?

• 문자열 "0"을 상위 개념인 Any 타입으로 생각하고 호출을 수행

 

함수의 디폴트 파라미터

fun readInt(radix: Int = 10) = readLine!!.toInt(radix)

• 위 함수는 파라미터가 주어지지 않으면 자동으로 10을 파라미터로 갖는다.

val decimalInt = readInt()
val decimalInt2 = readInt(10) // 위와 동일한 호출
val hexInt = readInt(16)

 

 

 

함수의 가시성

• public 함수

예) public fun readInt(): Int = readLine()!!.toInt()

• 프로젝트의 어디서나 해당 함수 호출 가능
• 가시성 선언이 없는 함수는 디폴트로 public으로 선언됨

fun readInt():Int=readLine()!!.toInt() //위와 같은 선언

• internal 함수

예) internal fun readInt(): Int = readLine()!!.toInt()

• 함께 컴파일되는 모듈 안에서만 호출 가능

• private 함수

예) private fun readInt(): Int = readLine()!!.toInt()

• 같은파일 안에서만 호출가능

 

 

함수 내 함수

• 함수 안에 함수 정의 가능

• 함수를 감싸는 블록에서만 호출 가능

• 함수 내의 변수에 접근 가능

fun main(args: Array<String>) { 
   fun swap(i: Int, j: Int): String {
	 val chars = args[0].toCharArray() 
     	 val tmp = chars[i]
	 chars[i] = chars[j]
	 chars[j] = tmp
	 return chars.concatToString() 
    }

	println(swap(0, args[0].lastIndex)) 
}

---

패키지 

• 코틀린 프로그램을 계층화하여 체계적으로 관리하는 방법

• 코틀린 코드를 담고 있는 디렉토리 구조와 일치한다.

package foo.bar.util
fun readInt(radix: Int) = readLine()!!.toInt(radix)

• 위 readInt() 함수는 디렉토리 구조상 foo/bar/util디렉토리에 저장되며 foo패키지내의 bar패키지내의 util패키지에 속하게 된다.

 

동일 패키지에서의 함수 호출

• 동일 패키지의 함수는 import 없이 호출할 수 있다.

 

다른 패키지의 함수 호출

• 함수의 이름에 패키지 이름까지 모두 붙여서 호출한다.

• 파일 앞쪽에 import 문을 통하여 호출할 함수를 미리 적어 놓으면 함수 이름만으로 호출이 가능하다.

 

import ... as ...

• 다른패키지에있는동일한이름의함수를호출할때

import foo.readInt as fooReadInt
import bar.readInt as barReadInt

fun main() {
	val n = fooReadInt()
	val m = barReadInt() 
}

 

패키지 전체 임포트

• 패키지내의 모든 선언을 임포트 할 때

import kotlin.math.* // kotlin.math 패키지 안의 모든 선언 import

• 전체 import는 구체적 import에 비하여 우선 순위가 떨어진다.

import foo.readInt 
import bar.*

fun main() {
	val n=readInt()		// foo.readInt()를 호출
}				// (bar 패키지에 readInt()함수는 우선 순위가 밀린다)

 

---

 

if문

• C언어 / Java언어의 if 문과 비슷

• fun max(a: Int, b: Int): Int { 
	if (a > b) return a
	else return b 
   }

fun main(args: Array<String>) { 
	if (args.isNotEmpty()) {
		val message = "Hello, ${args[0]}"
		println(message) 
       } 
    	else {
		println() 
	}
}

• 조건문은 반드시 Boolean 타입이어야 함

• C언어의 경우 정수형 조건문

 

식 표현을 위한 if~else문

• C언어의 ? : 연산을 Kotlin에서는 if else로 표현

fun max(a:Int,b:Int)=if(a>b) a else b

• 식 표현에 여러 줄 연산을 포함할 수도 있다. 이 경우 마지막 문장의 값을 이용

 

• fun main() {
	val s = readLine()!! 
    	val i = s.indexOf("/")
	val result = if (i >= 0) {
	 val a = s.substring(0, i).toInt() 
       	 val b = s.substring(i + 1).toInt() 
       	 (a/b).toString()
	} else ""

	println(result)
}

 

if 문에서 식과 return문 혼용하기

• 아래 프로그램은 정상적으로 컴파일 된다.

fun renamePackage(fullName: String, newName: String): String {
	val i = fullName.lastIndexOf('.') // 마지막 . 위치를 찾음
	val prefix = if (i >= 0) fullName.substring(0, i + 1) else return newName 
	return prefix + newName

}

 

범위 타입

• 범위 (range)를 표현하기 위한 타입

val chars = 'a' .. 'h' // 'a'에서 'h'까지의 모든 문자 
val two_digits = 10 .. 99 // 10부터 99까지의 모든 정수 
val zero2One = 0.0 .. 1.0 // 0부터 1까지의 모든 부동소수점 수

• in 연산: 특정 값이 범위에 포함되는지를 판단하는 연산

val num = readLine()!!.toInt()
println(num in 10..99) // num>=10 && num<=99
println (num !in 10 .. 99) // !(num in 10 .. 99)
println("def" in "abc" .. "xyz") // 문자열도 비교 가능하므로 범위 가능

 

until, downTo, step

 

• until

val twoDigits = 10 until 100 // 10 .. 99와 같음. 100은 포함되지 않음

 

• downTo: 범위에 아래로 내려가는 방향성을 추가 (진행 타입)

println(5 in 10 downTo 1) // true
println(5 in 10 .. 1)	 // false: 빈 진행임
println(5 in 1 downTo 10) // false: 빈 진행임

 

• step: 진행의 간격을 지정 (반드시 양수여야 함)

• 1..10 step3 //1,4,7,10
• 15 downTo 9 step 2 //15,13,11,9

 

문자열, 배열과 범위

문자열.substring()에 범위 사용하기

"Hello, World".substring(1 .. 4) // ello
"Hello, World".substring(1 until 4) // ell
"Hello, World".substring(1, 4) // ell: substring(1 until 4)와 같은 동작

 

• 배열.sliceArray()에 범위 사용하기

IntArray(10) { it*it }.sliceArray(2 .. 5) // 4, 9, 16, 25
IntArray(10) { it*it }.sliceArray(2 until 5) // 4, 9, 16

 

in/!in을 배열, 문자열 등에 사용하기

• in/!in은 배열, 문자열 등에 원소가 있는지를 파악할 때 사용 가능 

• val numbers = intArrayOf(3, 7, 2, 1)
• val text = "Hello!"
• println(2 in numbers) //true
• println(9 !in numbers) //true
• println(4 in numbers) //false
• println('a' in text) //false
• println('H' in text) //true
• println('h' !in text) //true

 

when 구문

• if...elseif...elseif...의 깔끔한 대안

fun hexDigit(n: Int): Char {
	if(n in 0 .. 9) return '0' + n
	else if (n in 10 .. 15) return 'A' + n – 10
	else return '?'
}

fun hexDigit(n: Int): Char { 
	when {
		n in 0 .. 9 -> return '0' + n
		n in 10 .. 15 -> return 'A' + n – 10 
       		else -> return '?'
 		} 
}

• when을식으로사용가능

fun hexDigit(n: Int) = when { 
	n in 0 .. 9 -> '0' + n
	n in 10 .. 15 -> 'A' + n – 10
 	else -> '?'
}

• when의 대상 특정

fun hexDigit(n: Int) = when(n) {
	in 0 .. 9 -> '0' + n
	in 10 .. 15 -> 'A' + n – 10 
    else -> '?'
}

 

do-while문

fun main() { 
    var sum = 0
    do {
        val num = readLine()!!.toInt() 
        sum += num
    } while (num != 0)
    println("Sum: $sum") 
}

 

while문

fun main() {
    val num = Random.nextInt(1, 101) 
    var guess = 0
    while (guess != num) {
        guess = readLine!!.toInt()
        if (guess < num) 
            println("Too small")
        else if (guess > num) 
            println("Too big") } 
        }
    println("Right: it's $num")
}

 

for문

fun main() {
    val a=IntArray(10){it*it} //0,1,4,9,16,... 
    var sum = 0
    for (x in a) { // x는 iteration마다 불변 변수로 작동 (val) 
        sum+=x
    }
    println("Sum: $sum")
}

 

"it"은 람다 표현식 내에서 현재 처리 중인 요소를 나타내는 특수한 키워드. 이 문맥에서 "it"은 정수 배열 a의 개별 요소를 가리킵니다. 람다 표현식 { it * it }은 배열 a의 요소를 해당 인덱스의 제곱에 기반하여 초기화하는 데 사용

배열 index를 이용한 for문

val a = Int Array(10) { it*it }

for (i in 0 .. a.lastIndex) { 
    if (i % 2 == 0) { 
        a[i]*=2
    }
}

 

break문

import kotlin.random.*
fun main() {
    val num = Random.nextInt(1, 101) 
    while (true) {
        val guess = readLine()!!.toInt()
        if (guess < num) println("Small") 
        else if (guess > num) println("Big") 
        else break
    }
    println("Right: It's $num")
}

import kotlin.random.*
fun main() {
    val num = Random.nextInt(1, 101) 
    while (true) {
        val guess = readLine()!!.toInt()
        
        val message =
            if (guess < num) "Small
            else if (guess > num) "Big"
            else break
        println(message)
    }
    println("Right: It's $num")
}

 

continue문

fun countLetters(text: String): IntArray {
    val counts = IntArray('z' – 'a' + 1)
    for (char in text) {
        val charLower = char.toLowerCase() 
        if (charLower !in 'a' .. 'z') continue
        counts[charLower – 'a']++ 
    } 
    return counts
}

 

내포된 루프와 레이블
• break와 continue 문은 가장 안쪽의 루프에 적용

• 이를바깥쪽루프에적용시키고싶을때레이블사용

fun indexOf(subarray: IntArray, array: IntArray): Int { 
    outerLoop@ for (i in array.indices) {
        for (j in subarray.indices) {
            if (subarray[j] != array[i + j]) continue@outerLoop
        }
    return i 
    } 
    return -1
}

 

예외 던지기

함수의 비정상적인 상황 발생시 throw 문을 통하여 예외를 던질 수 있다.

fun parseIntNumberInBinary(s: String): Int { 
    var num = 0
    if (s.length !in 1..31) throw NumberFormatException("Not a Number: $s")
    for (c in s) {
        if (c !in '0' .. '1') throw NumberFormatException("Not a Number: $s")
            num=num*2+(c–'0') 
        }
    return num
}

 

try-catch 문으로 예외 처리하기
• 안에서 던진 예외를 try-catch 문으로 처리할 수 있다.

• 던져진 예외가 try 문으로 처리되지 않으면 프로그램이 예외로 인해 비정상 종료된다.

fun readInt(default: int): Int { 
    try {
        return readLine()!!.toInt()
    } catch (e: NumberFormatException) {
        return default
    }
}

try-catch 문을 식처럼 이용하기

• if 문처럼 try-catch문도 식처럼 사용할 수 있다.

fun readInt(default: Int) = try { 
    readLine()!!.toInt()
} catch (e: NumberFormatException) {
    default
}

 

finally 구문을 통해서 자원 정리 하기

• finally 구문에 있는 문장들은 예외 발생 여부와 관계없이 무조건 수행된다.

• try 구문 안에서 사용한 자원을 정리할 때 유용하다.

fun readInt(default: Int) = try { 
    readLine()!!.toInt()
}   finally {
    println("자원 정리")
}

 

 

 

실습

import java.io.BufferedReader
import java.io.FileReader
import java.io.FileNotFoundException
import java.io.IOException




fun main() {
    var fd: BufferedReader? = null

    try {
        fd = BufferedReader(FileReader("students.txt"))
        val numStudents = fd.readLine().toInt() //3

        for (i in 0 until numStudents) {
            try {
                val name = fd.readLine() ?: ""
                val point = fd.readLine().toInt()
                fun printGrade(){
                    val grade = when {
                        point >= 90 -> "A"
                        point in 80 until 90 -> "B"
                        point in 70 until 80 -> "C"
                        point in 60 until 70 -> "D"
                        else -> "F"
                    }
                    println("$name has grade $grade")
                }
                printGrade()

            }
            catch (e2: IOException) {
                println("File I/O Error")
            }

        }
    } catch (e1: FileNotFoundException) {
        println("File Not Found.")
    }finally {
        fd?.close()
    }
}