Kotlin 함수 완벽 가이드 | fun으로 시작하는 간결한 코드

Java 메서드보다 강력하고 유연한 Kotlin 함수 완전 정복

---

목차

1. 함수 기본 문법
2. 반환 타입과 Unit
3. Single Expression Function
4. Default Parameters (기본 매개변수)
5. Named Parameters (이름 있는 인자)
6. 가변 인자 (vararg)
7. Extension Functions (확장 함수)
8. Infix Functions
9. 지역 함수 (Local Functions)

---

들어가며

Java에서 메서드를 만들 때마다 느꼈던 불편함들:

// Java - 불편한 점들
public class MathUtils {
    // 1. 항상 클래스 안에 있어야 함
    public static int add(int a, int b) {
        return a + b;
    }
    
    // 2. 오버로딩으로 기본값 구현
    public static String greet(String name) {
        return greet(name, "Hello");
    }
    
    public static String greet(String name, String greeting) {
        return greeting + ", " + name + "!";
    }
    
    // 3. 유틸리티 메서드를 추가하려면 클래스 수정
    // String에 새 메서드를 추가할 수 없음
}

Kotlin은 이 모든 문제를 해결합니다:

// 1. 최상위 함수 - 클래스 불필요
fun add(a: Int, b: Int) = a + b

// 2. 기본 매개변수 - 오버로딩 불필요
fun greet(name: String, greeting: String = "Hello") = "$greeting, $name!"

// 3. 확장 함수 - 기존 클래스에 메서드 추가
fun String.addExclamation() = this + "!"

오늘 이 모든 것을 배워보겠습니다!

---

1. 함수 기본 문법

1.1 Java 메서드 vs Kotlin 함수

Java

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
    
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        int result = calc.add(10, 20);
        System.out.println(result);
    }
}

Kotlin

// 함수 선언
fun add(a: Int, b: Int): Int {
    return a + b
}

// 사용
fun main() {
    val result = add(10, 20)
    println(result)
}

1.2 함수 구조 분석

fun functionName(param1: Type1, param2: Type2): ReturnType {
    // 함수 본문
    return value
}

요소별 설명:

• fun: 함수 키워드 (function)
• functionName: 함수 이름
• param1: Type1: 매개변수명: 타입
• : ReturnType: 반환 타입
• return value: 반환값

1.3 기본 함수 예제

// 덧셈
fun add(a: Int, b: Int): Int {
    return a + b
}

// 곱셈
fun multiply(a: Int, b: Int): Int {
    return a * b
}

// 최댓값
fun max(a: Int, b: Int): Int {
    return if (a > b) a else b
}

// 절댓값
fun abs(number: Int): Int {
    return if (number >= 0) number else -number
}

// 사용
fun main() {
    println(add(10, 20))        // 30
    println(multiply(5, 6))     // 30
    println(max(10, 20))        // 20
    println(abs(-15))           // 15
}

1.4 최상위 함수 (Top-level Function)

Java - 항상 클래스 필요

public class StringUtils {
    public static boolean isEmpty(String str) {
        return str == null || str.isEmpty();
    }
}

// 사용
StringUtils.isEmpty("test");

Kotlin - 클래스 불필요

// StringUtils.kt 파일
fun isEmpty(str: String?): Boolean {
    return str == null || str.isEmpty()
}

// 사용 - 바로 호출
isEmpty("test")

파일 구조

// MathUtils.kt
fun add(a: Int, b: Int) = a + b
fun subtract(a: Int, b: Int) = a - b
fun multiply(a: Int, b: Int) = a * b

// Main.kt
fun main() {
    println(add(10, 20))
    println(subtract(30, 10))
    println(multiply(5, 6))
}

---

2. 반환 타입과 Unit

2.1 반환 타입 명시

// Int 반환
fun getAge(): Int {
    return 25
}

// String 반환
fun getName(): String {
    return "John"
}

// Boolean 반환
fun isAdult(age: Int): Boolean {
    return age >= 18
}

// List 반환
fun getNumbers(): List<Int> {
    return listOf(1, 2, 3, 4, 5)
}

2.2 Unit - Java의 void

Java

public void printMessage(String message) {
    System.out.println(message);
}

Kotlin

// Unit 명시 (생략 가능)
fun printMessage(message: String): Unit {
    println(message)
}

// Unit 생략 (권장)
fun printMessage(message: String) {
    println(message)
}

Unit의 특징:

// Unit은 실제로 값을 반환함 (싱글톤 객체)
fun doSomething(): Unit {
    println("Done")
    return Unit  // 생략 가능
}

// 변수에 할당 가능
val result: Unit = printMessage("Hello")
println(result)  // kotlin.Unit

2.3 Nothing - 절대 반환하지 않음

// 항상 예외를 던짐
fun fail(message: String): Nothing {
    throw IllegalArgumentException(message)
}

// 무한 루프
fun infiniteLoop(): Nothing {
    while (true) {
        println("Running...")
    }
}

// 사용
fun validateAge(age: Int) {
    if (age < 0) {
        fail("나이는 음수일 수 없습니다")
    }
    println("나이: $age")
}

---

3. Single Expression Function

3.1 기본 형태

일반 함수

fun double(x: Int): Int {
    return x * 2
}

Single Expression Function

fun double(x: Int): Int = x * 2

// 타입 추론
fun double(x: Int) = x * 2

3.2 언제 사용할까?

// ✅ 좋은 예 - 간단한 계산
fun add(a: Int, b: Int) = a + b
fun multiply(a: Int, b: Int) = a * b
fun square(x: Int) = x * x

// ✅ 좋은 예 - 간단한 조건
fun max(a: Int, b: Int) = if (a > b) a else b
fun isEven(n: Int) = n % 2 == 0
fun isAdult(age: Int) = age >= 18

// ✅ 좋은 예 - 간단한 변환
fun toUpperCase(str: String) = str.uppercase()
fun getLength(str: String) = str.length

// ❌ 나쁜 예 - 복잡한 로직
fun complexCalculation(x: Int) = 
    if (x > 0) x * 2 + 10 else if (x < 0) x * 3 - 5 else 0
// 이런 경우는 일반 함수로 작성하는 게 가독성이 좋음

3.3 실전 예제

// 문자열 처리
fun isEmpty(str: String) = str.isEmpty()
fun isNotEmpty(str: String) = str.isNotEmpty()
fun capitalize(str: String) = str.replaceFirstChar { it.uppercase() }

// 숫자 처리
fun isPositive(n: Int) = n > 0
fun isNegative(n: Int) = n < 0
fun isZero(n: Int) = n == 0

// 변환
fun celsiusToFahrenheit(celsius: Double) = celsius * 9/5 + 32
fun fahrenheitToCelsius(fahrenheit: Double) = (fahrenheit - 32) * 5/9

// 사용
fun main() {
    println(isEmpty(""))           // true
    println(isPositive(10))        // true
    println(celsiusToFahrenheit(25.0))  // 77.0
}

3.4 when을 사용한 Single Expression

fun getGrade(score: Int) = when {
    score >= 90 -> "A"
    score >= 80 -> "B"
    score >= 70 -> "C"
    score >= 60 -> "D"
    else -> "F"
}

fun getDayType(day: String) = when (day) {
    "토", "일" -> "주말"
    else -> "평일"
}

// 사용
fun main() {
    println(getGrade(85))      // B
    println(getDayType("토"))  // 주말
}

---

4. Default Parameters (기본 매개변수)

4.1 Java의 문제점

Java - 오버로딩 필요

public String greet(String name) {
    return greet(name, "Hello");
}

public String greet(String name, String greeting) {
    return greet(name, greeting, "!");
}

public String greet(String name, String greeting, String suffix) {
    return greeting + " " + name + suffix;
}

// 3개의 메서드 필요!

4.2 Kotlin의 해결책

fun greet(
    name: String,
    greeting: String = "Hello",
    suffix: String = "!"
): String {
    return "$greeting $name$suffix"
}

// 사용 - 다양한 방법
fun main() {
    println(greet("John"))                    // Hello John!
    println(greet("John", "Hi"))              // Hi John!
    println(greet("John", "Hey", "?"))        // Hey John?
}

4.3 기본값 활용 패턴

설정 함수

fun connectDatabase(
    host: String,
    port: Int = 5432,
    username: String = "admin",
    password: String = "",
    timeout: Int = 30
) {
    println("연결: $host:$port")
    println("사용자: $username")
    println("타임아웃: $timeout초")
}

// 사용
connectDatabase("localhost")
connectDatabase("localhost", 3306, "root")

로깅 함수

fun log(
    message: String,
    level: String = "INFO",
    timestamp: Boolean = true
) {
    val time = if (timestamp) "[${System.currentTimeMillis()}] " else ""
    println("$time[$level] $message")
}

// 사용
log("서버 시작")                     // [timestamp][INFO] 서버 시작
log("오류 발생", "ERROR")            // [timestamp][ERROR] 오류 발생
log("디버그 메시지", "DEBUG", false)  // [DEBUG] 디버그 메시지

UI 컴포넌트

fun createButton(
    text: String,
    width: Int = 100,
    height: Int = 40,
    enabled: Boolean = true,
    color: String = "blue"
) {
    println("버튼: $text ($width x $height) - $color")
}

// 사용
createButton("확인")
createButton("취소", width = 150)
createButton("삭제", enabled = false, color = "red")

4.4 주의사항

// ❌ 기본값이 있는 매개변수가 앞에 오면 불편함
fun greet(greeting: String = "Hello", name: String) = "$greeting $name"

greet("John")  // ❌ 컴파일 오류
greet("Hi", "John")  // ✅ OK (불편함)

// ✅ 기본값은 뒤쪽 매개변수에
fun greet(name: String, greeting: String = "Hello") = "$greeting $name"

greet("John")  // ✅ OK
greet("John", "Hi")  // ✅ OK

---

5. Named Parameters (이름 있는 인자)

5.1 가독성 향상

위치 기반 (헷갈림)

createUser("john@example.com", "John", 25, true, "Seoul")
// 무엇이 무엇인지 알기 어려움

이름 지정 (명확함)

createUser(
    email = "john@example.com",
    name = "John",
    age = 25,
    isActive = true,
    city = "Seoul"
)
// 각 값의 의미가 명확함

5.2 순서 변경 가능

fun createUser(
    name: String,
    email: String,
    age: Int
) {
    println("이름: $name, 이메일: $email, 나이: $age")
}

// 순서를 바꿔도 OK
createUser(
    email = "john@example.com",
    age = 25,
    name = "John"
)

5.3 기본값과 조합

fun sendEmail(
    to: String,
    subject: String,
    body: String,
    cc: String? = null,
    bcc: String? = null,
    priority: String = "normal",
    attachments: List<String> = emptyList()
) {
    println("To: $to")
    println("Subject: $subject")
    println("Body: $body")
    if (cc != null) println("CC: $cc")
    if (bcc != null) println("BCC: $bcc")
    println("Priority: $priority")
}

// 필수 값만 전달
sendEmail(
    to = "john@example.com",
    subject = "안녕하세요",
    body = "메일 내용입니다."
)

// 필요한 선택적 값만 추가
sendEmail(
    to = "john@example.com",
    subject = "중요",
    body = "긴급 사항",
    priority = "high",
    cc = "manager@example.com"
)

5.4 실전 패턴

빌더 패턴 대체

// Java 빌더 패턴
User.builder()
    .name("John")
    .email("john@example.com")
    .age(25)
    .city("Seoul")
    .build()

// Kotlin Named Parameters (더 간단)
User(
    name = "John",
    email = "john@example.com",
    age = 25,
    city = "Seoul"
)

설정 함수

fun configureServer(
    host: String = "localhost",
    port: Int = 8080,
    ssl: Boolean = false,
    maxConnections: Int = 100,
    timeout: Int = 30,
    debug: Boolean = false
) {
    // 설정 적용
}

// 필요한 것만 변경
configureServer(
    port = 9090,
    ssl = true,
    debug = true
)

5.5 혼합 사용

fun createProduct(
    name: String,
    price: Int,
    category: String = "기타",
    stock: Int = 0
) {
    println("상품: $name, 가격: $price, 카테고리: $category, 재고: $stock")
}

// 위치 + 이름 혼합
createProduct("노트북", 1500000, stock = 10)
createProduct("마우스", 30000, category = "전자제품")

// 주의: 위치 기반 인자는 Named 인자보다 앞에 와야 함
createProduct("키보드", price = 80000, stock = 5)  // ❌ 오류
createProduct("키보드", 80000, stock = 5)          // ✅ OK

---

6. 가변 인자 (vararg)

6.1 Java의 가변 인자

// Java
public int sum(int... numbers) {
    int total = 0;
    for (int num : numbers) {
        total += num;
    }
    return total;
}

// 사용
sum(1, 2, 3);
sum(1, 2, 3, 4, 5);

6.2 Kotlin의 vararg

fun sum(vararg numbers: Int): Int {
    var total = 0
    for (num in numbers) {
        total += num
    }
    return total
}

// 또는 더 간결하게
fun sum(vararg numbers: Int) = numbers.sum()

// 사용
fun main() {
    println(sum(1, 2, 3))           // 6
    println(sum(1, 2, 3, 4, 5))     // 15
    println(sum(10))                // 10
    println(sum())                  // 0
}

6.3 Spread Operator (*)

fun printAll(vararg messages: String) {
    for (msg in messages) {
        println(msg)
    }
}

fun main() {
    // 배열을 vararg로 전달
    val messages = arrayOf("Hello", "World", "Kotlin")
    printAll(*messages)  // * (spread operator)
    
    // 혼합 사용
    printAll("시작", *messages, "끝")
}

6.4 여러 매개변수와 함께 사용

// vararg는 한 함수에 하나만 가능
fun createList(name: String, vararg items: String): List<String> {
    println("리스트 이름: $name")
    return items.toList()
}

// 사용
val fruits = createList("과일", "사과", "바나나", "딸기")
println(fruits)  // [사과, 바나나, 딸기]

// vararg가 마지막이 아니면 Named Parameters 필요
fun format(vararg values: Any, separator: String = ", "): String {
    return values.joinToString(separator)
}

// 사용
println(format(1, 2, 3, separator = " | "))  // 1 | 2 | 3

6.5 실전 예제

로깅

fun log(level: String, vararg messages: Any) {
    println("[$level] ${messages.joinToString(" ")}")
}

log("INFO", "서버", "시작됨", "포트:", 8080)
log("ERROR", "연결", "실패")

SQL 빌더

fun select(vararg columns: String, from: String): String {
    val cols = if (columns.isEmpty()) "*" else columns.joinToString(", ")
    return "SELECT $cols FROM $from"
}

println(select("name", "age", from = "users"))
// SELECT name, age FROM users

println(select(from = "products"))
// SELECT * FROM products

문자열 연결

fun concat(separator: String = "", vararg strings: String): String {
    return strings.joinToString(separator)
}

println(concat("사과", "바나나", "딸기"))
println(concat(" | ", "Java", "Kotlin", "Python"))

---

7. Extension Functions (확장 함수)

7.1 개념

기존 클래스에 새로운 함수를 추가하는 기능입니다.

Java의 한계

// String 클래스에 메서드를 추가할 수 없음
// Wrapper 클래스나 Utils 클래스 필요
public class StringUtils {
    public static String addExclamation(String str) {
        return str + "!";
    }
}

// 사용
StringUtils.addExclamation("Hello");  // 불편함

Kotlin의 해결책

// String에 메서드 추가!
fun String.addExclamation(): String {
    return this + "!"
}

// 사용 - 마치 원래 있던 메서드처럼
"Hello".addExclamation()  // Hello!

7.2 기본 문법

fun ReceiverType.functionName(params): ReturnType {
    // this는 ReceiverType 인스턴스
    return result
}

예제

// Int에 제곱 함수 추가
fun Int.square(): Int {
    return this * this
}

// String에 반복 함수 추가
fun String.repeat(n: Int): String {
    return this.repeat(n)
}

// 사용
println(5.square())        // 25
println("Ha".repeat(3))    // HaHaHa

7.3 실용적인 확장 함수

문자열 처리

// 이메일 검증
fun String.isValidEmail(): Boolean {
    return this.contains("@") && this.contains(".")
}

// 전화번호 포맷
fun String.formatPhoneNumber(): String {
    return this.replace(Regex("[^0-9]"), "")
        .chunked(4)
        .joinToString("-")
}

// 첫 글자만 대문자
fun String.capitalize(): String {
    return this.replaceFirstChar { it.uppercase() }
}

// 사용
println("test@example.com".isValidEmail())     // true
println("01012345678".formatPhoneNumber())     // 0101-2345-678
println("hello".capitalize())                  // Hello

숫자 처리

// 짝수 판별
fun Int.isEven(): Boolean = this % 2 == 0

// 홀수 판별
fun Int.isOdd(): Boolean = this % 2 != 0

// 양수 판별
fun Int.isPositive(): Boolean = this > 0

// 금액 포맷
fun Int.toMoneyFormat(): String = "%,d원".format(this)

// 사용
println(10.isEven())           // true
println(7.isOdd())             // true
println(50000.toMoneyFormat()) // 50,000원

컬렉션 처리

// 안전한 두 번째 요소 가져오기
fun <T> List<T>.secondOrNull(): T? {
    return if (this.size >= 2) this[1] else null
}

// 랜덤 요소
fun <T> List<T>.random(): T {
    return this[kotlin.random.Random.nextInt(this.size)]
}

// 사용
val list = listOf(1, 2, 3, 4, 5)
println(list.secondOrNull())  // 2

val fruits = listOf("사과", "바나나", "딸기")
println(fruits.random())      // 랜덤 과일

7.4 Nullable 리시버

// String?에 대한 확장 함수
fun String?.isNullOrEmpty(): Boolean {
    return this == null || this.isEmpty()
}

// 사용
val str: String? = null
println(str.isNullOrEmpty())  // true

val str2 = ""
println(str2.isNullOrEmpty())  // true

7.5 제네릭 확장 함수

// 모든 타입에 적용 가능한 확장 함수
fun <T> T.print(): T {
    println(this)
    return this
}

// 체이닝 가능
"Hello"
    .print()           // Hello 출력
    .uppercase()
    .print()           // HELLO 출력

7.6 주의사항

// ❌ Extension Function은 오버라이드 불가
open class Parent
class Child : Parent()

fun Parent.show() = println("Parent")
fun Child.show() = println("Child")

val child: Parent = Child()
child.show()  // Parent (정적으로 결정됨)

// ❌ private 멤버 접근 불가
class User(private val id: Long)

fun User.getId(): Long {
    return this.id  // ❌ 컴파일 오류
}

---

8. Infix Functions

8.1 중위 함수란?

점(.)과 괄호 없이 호출할 수 있는 함수입니다.

일반 함수

fun Int.plus(other: Int): Int {
    return this + other
}

// 사용
val result = 10.plus(20)

Infix 함수

infix fun Int.plus(other: Int): Int {
    return this + other
}

// 사용 - 더 자연스러움
val result = 10 plus 20

8.2 조건

1. 멤버 함수 또는 확장 함수
2. 매개변수가 정확히 하나
3. vararg, 기본값 불가

// ✅ OK
infix fun Int.times(other: Int) = this * other

// ❌ 매개변수 2개
infix fun add(a: Int, b: Int) = a + b

// ❌ 기본값
infix fun Int.multiply(other: Int = 2) = this * other

8.3 실전 예제

단위 변환

infix fun Int.minutes(seconds: Int): Int {
    return this * 60 + seconds
}

val time = 5 minutes 30  // 330초

페어 생성 (Kotlin 내장)

// to는 infix 함수
val pair = "name" to "John"  // Pair("name", "John")
val map = mapOf(
    "name" to "John",
    "age" to 25
)

조건 체크

infix fun Int.isGreaterThan(other: Int) = this > other
infix fun String.contains(substring: String) = this.contains(substring)

if (10 isGreaterThan 5) {
    println("10이 5보다 큼")
}

if ("Hello" contains "ell") {
    println("포함됨")
}

DSL 스타일

class Condition(val value: Boolean)

infix fun Boolean.and(other: Boolean) = Condition(this && other)
infix fun Boolean.or(other: Boolean) = Condition(this || other)

val isValid = (age > 18) and (hasLicense == true)

8.4 가독성

// ✅ 좋은 예 - 읽기 쉬움
val map = mapOf("key" to "value")
val range = 1 until 10

// ❌ 나쁜 예 - 너무 창의적
infix fun Int.boom(other: Int) = this * other
val result = 5 boom 3  // 의미 불명확

---

9. 지역 함수 (Local Functions)

9.1 개념

함수 안에 함수를 정의할 수 있습니다.

fun processUser(user: User) {
    // 지역 함수
    fun validate() {
        if (user.name.isEmpty()) {
            throw IllegalArgumentException("이름이 비어있습니다")
        }
        if (user.age < 0) {
            throw IllegalArgumentException("나이가 음수입니다")
        }
    }
    
    // 지역 함수 호출
    validate()
    
    // 실제 처리
    println("사용자 처리: ${user.name}")
}

9.2 중복 코드 제거

개선 전

fun saveUser(user: User) {
    if (user.name.isEmpty()) {
        throw IllegalArgumentException("이름 필수")
    }
    if (user.email.isEmpty()) {
        throw IllegalArgumentException("이메일 필수")
    }
    // 저장 로직
}

개선 후

fun saveUser(user: User) {
    fun validate(value: String, fieldName: String) {
        if (value.isEmpty()) {
            throw IllegalArgumentException("$fieldName 필수")
        }
    }
    
    validate(user.name, "이름")
    validate(user.email, "이메일")
    
    // 저장 로직
}

9.3 외부 변수 접근

fun calculatePrice(quantity: Int, basePrice: Int): Int {
    var discount = 0
    
    fun applyDiscount(percentage: Int) {
        discount = basePrice * percentage / 100
    }
    
    when {
        quantity >= 100 -> applyDiscount(20)
        quantity >= 50 -> applyDiscount(10)
        quantity >= 10 -> applyDiscount(5)
    }
    
    return quantity * basePrice - discount
}

9.4 언제 사용할까?

// ✅ 좋은 예 - 반복되는 검증 로직
fun registerUser(name: String, email: String, password: String) {
    fun validate(value: String, field: String, minLength: Int) {
        if (value.length < minLength) {
            throw IllegalArgumentException(
                "$field는 최소 $minLength자 이상이어야 합니다"
            )
        }
    }
    
    validate(name, "이름", 2)
    validate(email, "이메일", 5)
    validate(password, "비밀번호", 8)
    
    // 등록 로직
}

// ❌ 나쁜 예 - 너무 복잡한 지역 함수
fun complexProcess() {
    fun helper1() {
        fun helper2() {
            fun helper3() {
                // 너무 깊음
            }
        }
    }
}

---

마치며

핵심 요약

Kotlin 함수의 특징

1. 간결함: Single Expression Function으로 한 줄에
2. 유연함: Default Parameters로 오버로딩 불필요
3. 명확함: Named Parameters로 가독성 향상
4. 확장성: Extension Functions로 기존 클래스 확장

Java vs Kotlin 비교

기능 Java Kotlin

최상위 함수	❌ 클래스 필요	✅ 가능
기본 매개변수	❌ 오버로딩	✅ Default Parameters
이름 있는 인자	❌ 불가능	✅ Named Parameters
확장 메서드	❌ 불가능	✅ Extension Functions
단일 표현식	❌ 불가능	✅ = 사용

Best Practices

• ✅ 간단한 함수는 Single Expression
• ✅ 기본값이 있으면 Default Parameters
• ✅ 매개변수 많으면 Named Parameters
• ✅ 유틸리티 함수는 Extension Functions
• ✅ 최상위 함수 적극 활용

실전 연습 문제

1. 온도 변환 함수

fun celsiusToFahrenheit(celsius: Double) = celsius * 9/5 + 32
fun fahrenheitToCelsius(fahrenheit: Double) = (fahrenheit - 32) * 5/9

// 확장 함수로 만들기
fun Double.toFahrenheit() = this * 9/5 + 32
fun Double.toCelsius() = (this - 32) * 5/9

// 사용
println(25.0.toFahrenheit())  // 77.0

2. 리스트 유틸리티

// 안전한 첫 번째와 마지막 요소
fun <T> List<T>.firstOrDefault(default: T) = 
    if (isEmpty()) default else first()

fun <T> List<T>.lastOrDefault(default: T) = 
    if (isEmpty()) default else last()

// 사용
val empty = emptyList<Int>()
println(empty.firstOrDefault(0))  // 0

3. 문자열 검증

fun String.isValidPassword(
    minLength: Int = 8,
    requireUpperCase: Boolean = true,
    requireNumber: Boolean = true
): Boolean {
    if (length < minLength) return false
    if (requireUpperCase && none { it.isUpperCase() }) return false
    if (requireNumber && none { it.isDigit() }) return false
    return true
}

// 사용
println("Password123".isValidPassword())  // true
println("pass".isValidPassword())          // false

다음 학습

3편: Kotlin 클래스 기초

• Primary Constructor
• Property
• Data Class
• Object와 Companion Object

관련 주제

• 고차 함수 (Higher-order Functions)
• 람다 표현식
• 함수 타입
• 인라인 함수

---

함께 보면 좋은 글

▶ Kotlin 시작하기 | Java 개발자를 위한 첫 번째 Kotlin 코드
▶ Kotlin 클래스 기초 | Java보다 80% 간결한 클래스 작성법
▶ Kotlin 람다와 고차함수 | 함수형 프로그래밍 입문

---

참고 자료

• Kotlin 공식 문서 - Functions: https://kotlinlang.org/docs/functions.html
• Kotlin 공식 문서 - Extensions: https://kotlinlang.org/docs/extensions.html
• Kotlin in Action (Chapter 3: Functions)
• Baeldung Kotlin Functions: https://www.baeldung.com/kotlin/functions