반응형
전달 값 없고 반환 값 없는 타입
fun main(){
printHello() // 함수 호출
}
/* 함수 정의 영역에 printHello 함수 정의
Unit = void */
fun printHello(){
println("Hello")
/* 반환 값이 없는 함수라면 return 구문 생략 */
//return
}
출력 결과
Hello
전달 값 없고 반환 값 있는 타입
fun main(){
println(getHello())
}
/* 함수에 반환 값이 있을 때 타입 정의해 주어야 함.*/
fun getHello() :String{
return "Hello"
}
출력 결과
Hello
전달 인자 있고 반환 값 있는 타입
fun main(){
println(sum(10,20))
}
fun sum(a: Int, b: Int) : {
return a + b
}
출력 결과
30
전달 인자 있고 반환 값있는 타입을 중괄호와 리턴 생략하여 작성
fun main(){
println(sum(10,20))
}
fun sum(a: Int, b: Int) : Int = a + b
출력 결과
30
조건문 이용하여 함수 정의
fun main(){
println(getBigger(50, 20))
println(getGrade(80))
}
fun getBigger(a: Int, b: Int): Int = if(a > b) a else b
fun getGrade(score: Int): String = when(score){
in 91..100 -> "A"
in 81 .. 90 ->"B"
in 71..80 -> "C"
else -> "D"
}
출력 결과
50
C
모든 인자 값에 기본 값이 적용 된 함수
호출 할 때 인자 값을 생략할 경우 기본적으로 사용할 기본 값을 설정할 수 있음
fun main(){
println(sumWithDefault()) // 전달 값 생략 -> 기본 값 출력
println(sumWithDefault(20)) //하나만 값 전달
println(sumWithDefault(20, 30)) //둘다 전달 ->기본 값 무시 되고 출력
println(sumWithDefault(b = 30)) //a는 기본 값 b는 전달 값으로
}
fun sumWithDefault(a: Int = 10, b: Int = 20) : Int{
return a + b
}
출력 결과
30
40
50
40
일부 인자 값에만 기본 값이 적용 된 함수
fun main(){
//println(sumWithDefault2()) a 인자 값은 반드시 전달해야 하고 전달 하지 않으면 호출 불가
println(sumWithDefault2(100))
}
fun sumWithDefault2(a: Int, b: Int = 20) : Int{
return a + b
}
출력 결과
100
가변 인자 : vararg 키워드 사용하여 선언
fun main(){
println(sumWithVargs(1,2,3))
println(sumWithVargs(1,2,3,4,5))
}
fun sumWithVargs(vararg nums: Int): Int{
var total = 0
for(num in nums){
total += num
}
return total
}
출력 결과
6
15
일반 인자와 가변 인자가 섞여있는 경우
fun mian(){
println(sumWithVargsWithBase(100, 1, 2, 3))
}
//가변인자는 일반인자 뒤에 작성해야 함.
fun sumWithVargsWithBase(base: Int, vararg nums: Int): Int{
var total = base
for(num in nums){
total += num
}
return total
}
출력 결과
106반응형
전개 연산자(*)를 사용하여 배열 또는 리스트 출력하기
배열 꼬는 리스트 이름 앞에 전개 연산자(*)를 사용해서 인자로 변경하여 함수 호출
전달 인자는 null 허용하지 않으므로 원시 타입의 배열로 변환해야 타입이 일치
fun main(){
/* list와 array는 null을 가질 수 있는 타입(코틀린에 정의 되어 있음)
가변인자 쪽에 선언된 타입은 null값이 들어 갈 수 없기 때문에 타입 불일치
-> list와 array를 null값이 포함되지 않는 타입으로 변환시켜주어야 함.
*/
var numList = listOf(1, 2, 3, 4, 5)
var objArr = arrayOf(1, 2, 3)
(1) integer[]
println(sumWithVargs(*objArr.toIntArray()))
println(sumWithVargs(*objArr.toIntArray()))
(2) int[]
var primArr = intArrayOf(1,2,3,4)
//int array로 만들었기 때문에 전개 연산자만 붙여주면 됨.
println(sumWithVargs(*primArr))
}
fun sumWithVargs(vararg nums: Int): Int{
var total = 0
for(num in nums){
total += num
}
return total
}
출력 결과
15
6
6
명명 인자
코틀린에서는 인자 값의 개수가 많다면 일일히 전달해야 할 인자 값의 순서와 타입을 기억하는 불편함을
해소하기 위해 매개변수의 이름과 인자값을 동시에 전달하는 형태로 함수를 호출할 수 있음
fun main(){
sayHelloTo("둘리","또치",100)
sayHelloTo(times = 2, to="도우넛", from="고길동")
sayHelloTo("짱구",times =3,to="철수")
//sayHelloTo(times=3,"희동이","또치") 호출 불가,순서를 유추할 수 없으면 명령 인자를 붙여서 사용해야함.
}
fun sayHelloTo(from: String, to: String, times: Int){
println("${from}씨가 ${to}에게 ${times}번 인사를 했습니다.")
}
출력 결과
둘리씨가 또치에게 100번 인사를 했습니다.
고길동씨가 도우넛에게 2번 인사를 했습니다.
짱구씨가 철수에게 3번 인사를 했습니다.
로컬 함수(지역 함수)
복잡한 작업을 수행하는 함수의 기능을 분할한 후 여러 함수로 나누어 구현할 때 사용할 수 있음(함수안에 함수 정의 가능) 단, 함수 내부에 정의한 로컬 함수는 외부에서는 사용할 수 없음
fun main(){
var result = outerFunc("Oter")
println(result)
println(outerFunc("하이"))
/* 로컬 함수는 외부에서 접근 불가능함
var result2 = localFunc("Local")*/
}
fun outerFunc(target: String): String{
fun localFunc(str: String): String{
return "Hello from local $str"
}
return localFunc(target)
//outerFunc("인자")를 가지고 로컬 함수 동작
}
출력 결과
Hello from local Oter
Hello from local 하이
람다식
람다식이란?
익명함수(이름 없는 함수)의 형태로 화살표 표기법을 사용함
람다식의 구성
val 또는 var 함수처럼 사용할 변수 : 람다식의 선언 자료형 = { 람다식의 매개변수 -> 람다식의 처리 내용}
1. 전체 모습
val plus: (Int, Int) -> Int = { x: Int, y:Int -> x + y}
2. :과 선언 자료형 생략
val plus = { x: Int, y:Int -> x + y}
3. 람다식 매개변수 자료형 생략
val plus: (Int, Int) -> Int = { x,y -> x + y}
4. 타입 추론 불가능으로 에러 발생
val plus: { x, y -> x + y}
fun main(){
//int값을 받아서 int값을 반환
val square: (Int) -> Int = { number: Int -> number * number }
//위의 함수를 아래와 같이 생략가능함
val square = { number: Int -> number * number }
//int값을 전달해서 전달 받은 값을 연산해서 반환함. 함수 타입 추론 가능
println(square(4))
var printHello: () -> Unit = { println("hello") }
//인자를 받지 않고 반환하지 않는 형태 -> { 수행 할 내용만 작성 }
printHello()
//타입 추론 가능하여 () -> Unit 생략 가능
printHello = { println("hello again") } // 함수 타입 추론 가능
printHello()
//val sum: (Int, Int) -> Int = { x:Int, y:Int -> x + y}
//val sum = { x:Int, y:Int -> x + y} //함수 타입 추론 가능
val sum: (Int, Int) -> Int = { x, y -> x + y} //매개변수 타입 추론 가능
// val sum = { x, y -> x + y} //매개변수와 함수 타입 둘 다 생략은 불가능ㅈ
println(sum(3,4))
/* it을 사용하면 명시한 인자명이 불필요하다.*/
val sayHelloTo : (String) -> Unit = { println("say hello to $it")} //string 값을 전달받아서 반환값이 없는 타입이다.
sayHelloTo("김철수")
/* it이 아니라 직접 명시한 인자명을 통해서도 접근 가능하다*/
val sayHelloTo2 = { target:String -> println("say hello to $target") }
sayHelloTo2("김영희")
}반응형