Kotlin 시작하기 | Java 개발자를 위한 첫 번째 Kotlin 코드

Java 개발자가 Kotlin을 배워야 하는 이유와 5분 만에 시작하는 방법

---

목차

1. 왜 Kotlin을 배워야 할까?
2. 개발 환경 설정
3. Hello World - Java vs Kotlin
4. 변수 선언 - val과 var
5. 기본 타입과 타입 추론
6. 문자열 처리
7. 첫 번째 프로그램 만들기

---

들어가며

저는 5년간 Java로 개발했습니다. Spring Boot, JPA, Stream API까지 다 익숙했죠. 그런데 팀에서 Kotlin 도입을 결정했고, 처음에는 "굳이?"라는 생각이 들었습니다.

하지만 첫 코드를 작성하고 놀랐습니다:

// Java - 20줄
public class User {
    private final Long id;
    private final String name;
    private final String email;
    
    public User(Long id, String name, String email) {
        this.id = id;
        this.name = name;
        this.email = email;
    }
    
    public Long getId() { return id; }
    public String getName() { return name; }
    public String getEmail() { return email; }
    
    @Override
    public boolean equals(Object o) { /* ... */ }
    
    @Override
    public int hashCode() { /* ... */ }
}

// Kotlin - 1줄
data class User(val id: Long, val name: String, val email: String)

20줄이 1줄로! 게다가 equals, hashCode, toString까지 자동 생성됩니다.

이 글을 읽고 나면:

• ✅ Kotlin 개발 환경을 설정할 수 있습니다
• ✅ 간단한 Kotlin 프로그램을 작성할 수 있습니다
• ✅ Java와 Kotlin의 차이를 이해할 수 있습니다

---

1. 왜 Kotlin을 배워야 할까?

1.1 간결함 (Conciseness)

Getter/Setter 자동 생성

// Java
public class Person {
    private String name;
    private int age;
    
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
}

// Kotlin
class Person {
    var name: String = ""
    var age: Int = 0
}
// 또는 더 간결하게
class Person(var name: String, var age: Int)

Null 체크

// Java
String result = null;
if (user != null) {
    if (user.getProfile() != null) {
        result = user.getProfile().getName();
    }
}
if (result == null) {
    result = "Unknown";
}

// Kotlin
val result = user?.profile?.name ?: "Unknown"

1.2 안전함 (Safety)

Null Safety

// 컴파일 오류 - null을 허용하지 않음
var name: String = "John"
name = null  // ❌ 컴파일 오류

// null 허용
var name: String? = "John"
name = null  // ✅ OK

스마트 캐스트

// Java - 명시적 캐스팅 필요
if (obj instanceof String) {
    String str = (String) obj;  // 캐스팅 필요
    System.out.println(str.length());
}

// Kotlin - 자동 캐스팅
if (obj is String) {
    println(obj.length)  // 자동으로 String 타입
}

1.3 상호운용성 (Interoperability)

// Java 라이브러리를 그대로 사용
import java.util.ArrayList
import java.time.LocalDateTime

val list = ArrayList<String>()
val now = LocalDateTime.now()

// Java 코드에서 Kotlin 호출 가능
// 100% 호환됨

1.4 공식 지원

• Android: 2019년부터 공식 언어
• Spring Boot: 5.0부터 공식 지원
• Gradle: Kotlin DSL 제공
• IntelliJ IDEA: JetBrains가 개발 (완벽한 지원)

---

2. 개발 환경 설정

2.1 IntelliJ IDEA 설치

Community Edition (무료)

1. https://www.jetbrains.com/idea/download/ 접속
2. Community Edition 다운로드
3. 설치 실행

Kotlin 플러그인

• IntelliJ IDEA에 기본 포함
• 별도 설치 불필요

2.2 첫 프로젝트 생성

1. New Project

File → New → Project

2. 프로젝트 설정

• Language: Kotlin
• Build System: Gradle Kotlin DSL (권장) 또는 Maven
• JDK: 11 이상 (17 권장)

3. 프로젝트 구조

my-kotlin-project/
├── src/
│   └── main/
│       └── kotlin/
│           └── Main.kt
├── build.gradle.kts
└── settings.gradle.kts

2.3 온라인 에디터 (설치 없이 시작)

Kotlin Playground

• 링크: https://play.kotlinlang.org/
• 브라우저에서 바로 실행
• 설치 불필요

---

3. Hello World - Java vs Kotlin

3.1 Java Hello World

// HelloWorld.java
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

3.2 Kotlin Hello World

// Main.kt
fun main() {
    println("Hello, World!")
}

차이점:

• ✅ public 키워드 불필요 (기본이 public)
• ✅ static 불필요 (최상위 함수)
• ✅ String[] args 생략 가능
• ✅ System.out.println → println
• ✅ 세미콜론(;) 생략 가능
• ✅ 클래스 불필요

3.3 실행하기

IntelliJ IDEA

1. Main.kt 파일 열기
2. main 함수 옆 녹색 화살표 클릭
3. "Run MainKt" 선택

또는 단축키

• Mac: Ctrl + Shift + R
• Windows/Linux: Shift + F10

출력 결과

Hello, World!

3.4 인자가 있는 main 함수

fun main(args: Array<String>) {
    println("Hello, ${args.getOrNull(0) ?: "World"}!")
}

실행

# 명령줄 인자 전달
$ kotlin Main.kt John
Hello, John!

---

4. 변수 선언 - val과 var

4.1 Java의 변수 선언

// 변경 가능
String name = "John";
name = "Jane";  // OK

// 변경 불가 (final)
final String name = "John";
name = "Jane";  // ❌ 컴파일 오류

4.2 Kotlin의 val (불변)

val name = "John"  // 타입 추론: String
name = "Jane"  // ❌ 컴파일 오류

// Java의 final과 동일
val age = 25
val price = 10000L
val isActive = true

특징:

• 읽기 전용 (read-only)
• 한 번만 할당 가능
• 권장 방식 (불변성)

4.3 Kotlin의 var (가변)

var name = "John"
name = "Jane"  // ✅ OK

var count = 0
count = count + 1  // ✅ OK
count++  // ✅ OK

특징:

• 변경 가능 (mutable)
• 필요한 경우에만 사용

4.4 val vs var 선택 기준

// ✅ 좋은 예: val 우선 사용
val name = "John"
val age = 25
val email = "john@example.com"

// 필요한 경우에만 var
var counter = 0
repeat(10) {
    counter++
}

// ❌ 나쁜 예: 불필요한 var 사용
var name = "John"  // 변경하지 않는다면 val 사용
var age = 25       // 변경하지 않는다면 val 사용

규칙:

1. 기본적으로 val 사용
2. 변경이 필요하면 var 사용
3. 불변성(Immutability)은 버그를 줄임

4.5 늦은 초기화

// ❌ 컴파일 오류 - 초기화 필요
val name: String
println(name)

// ✅ 늦은 초기화
val name: String
if (condition) {
    name = "John"
} else {
    name = "Jane"
}
println(name)  // OK

// lateinit (나중에 초기화)
lateinit var database: Database
// ... 나중에 초기화
database = DatabaseFactory.create()

---

5. 기본 타입과 타입 추론

5.1 Java vs Kotlin 기본 타입

Java Kotlin 예시

byte	Byte	val b: Byte = 1
short	Short	val s: Short = 10
int	Int	val i: Int = 100
long	Long	val l: Long = 1000L
float	Float	val f: Float = 3.14f
double	Double	val d: Double = 3.14
char	Char	val c: Char = 'A'
boolean	Boolean	val b: Boolean = true

5.2 타입 추론 (Type Inference)

// 명시적 타입 선언
val name: String = "John"
val age: Int = 25
val price: Double = 10.5

// 타입 추론 (권장)
val name = "John"      // String 추론
val age = 25           // Int 추론
val price = 10.5       // Double 추론
val isActive = true    // Boolean 추론

언제 타입을 명시할까?

// 추론이 명확한 경우 - 생략
val count = 0
val name = "John"

// 추론이 애매한 경우 - 명시
val number: Long = 100  // Int가 아닌 Long
val price: Float = 10.0f  // Double이 아닌 Float

// 초기화를 나중에 하는 경우 - 명시
val result: String
result = calculateResult()

5.3 숫자 타입

// Int (기본)
val a = 100

// Long
val b = 100L
val c: Long = 100

// Double (기본 소수)
val d = 3.14

// Float
val e = 3.14f
val f: Float = 3.14f

// 언더스코어로 가독성 향상
val million = 1_000_000
val billion = 1_000_000_000L
val creditCard = 1234_5678_9012_3456L

5.4 타입 변환

// Java - 암시적 변환 가능
int a = 100;
long b = a;  // OK

// Kotlin - 명시적 변환 필요
val a: Int = 100
val b: Long = a.toLong()  // 명시적 변환

// 변환 함수들
val i: Int = 10
val l: Long = i.toLong()
val d: Double = i.toDouble()
val s: String = i.toString()
val f: Float = i.toFloat()

5.5 String

// 기본 선언
val name: String = "John"
val empty: String = ""

// 다중 라인 문자열
val address = """
    서울시 강남구
    테헤란로 123
    ABC빌딩 5층
""".trimIndent()

// 문자열 비교
val a = "Hello"
val b = "Hello"
println(a == b)  // true (내용 비교)
println(a === b)  // true (참조 비교)

// Java와 다른 점
// Java: ==는 참조 비교, equals()가 내용 비교
// Kotlin: ==는 내용 비교, ===가 참조 비교

---

6. 문자열 처리

6.1 문자열 템플릿 (String Template)

Java

String name = "John";
int age = 25;
String message = "My name is " + name + " and I am " + age + " years old.";

Kotlin

val name = "John"
val age = 25
val message = "My name is $name and I am $age years old."

6.2 표현식 포함

val a = 10
val b = 20

// 변수
println("a = $a")

// 표현식
println("sum = ${a + b}")
println("max = ${if (a > b) a else b}")

// 프로퍼티 접근
val user = User("John", 25)
println("Name: ${user.name}, Age: ${user.age}")

// 함수 호출
println("Length: ${name.length}")
println("Upper: ${name.uppercase()}")

6.3 중괄호 {} 사용 규칙

val name = "John"

// 단순 변수 - 중괄호 생략 가능
println("Hello $name")

// 프로퍼티 접근 - 중괄호 권장
println("Length: ${name.length}")  // ✅ 권장
println("Length: $name.length")    // ⚠️ 동작하지만 헷갈림

// 표현식 - 중괄호 필수
println("Result: ${a + b}")

6.4 Raw String (다중 라인)

// Java
String json = "{\n" +
              "  \"name\": \"John\",\n" +
              "  \"age\": 25\n" +
              "}";

// Kotlin
val json = """
{
  "name": "John",
  "age": 25
}
""".trimIndent()

// 마진 제거
val html = """
    |<html>
    |  <body>
    |    <h1>Hello</h1>
    |  </body>
    |</html>
""".trimMargin()

6.5 문자열 함수

val str = "Hello, Kotlin!"

// 길이
println(str.length)  // 14

// 대소문자
println(str.uppercase())  // HELLO, KOTLIN!
println(str.lowercase())  // hello, kotlin!

// 포함 여부
println(str.contains("Kotlin"))  // true
println(str.startsWith("Hello"))  // true
println(str.endsWith("!"))  // true

// 치환
println(str.replace("Kotlin", "World"))  // Hello, World!

// 분할
val parts = str.split(", ")  // [Hello, Kotlin!]

// 자르기
println(str.substring(0, 5))  // Hello
println(str.take(5))  // Hello
println(str.drop(7))  // Kotlin!

// 공백 제거
val text = "  Hello  "
println(text.trim())  // Hello

---

7. 첫 번째 프로그램 만들기

7.1 간단한 계산기

fun main() {
    println("=== 간단한 계산기 ===")
    
    val a = 10
    val b = 3
    
    println("a = $a")
    println("b = $b")
    println()
    
    println("덧셈: ${a + b}")
    println("뺄셈: ${a - b}")
    println("곱셈: ${a * b}")
    println("나눗셈: ${a / b}")
    println("나머지: ${a % b}")
}

실행 결과

=== 간단한 계산기 ===
a = 10
b = 3

덧셈: 13
뺄셈: 7
곱셈: 30
나눗셈: 3
나머지: 1

7.2 사용자 정보 출력

fun main() {
    val name = "홍길동"
    val age = 28
    val city = "서울"
    val isStudent = false
    
    println("=== 사용자 정보 ===")
    println("이름: $name")
    println("나이: $age세")
    println("거주지: $city")
    println("학생 여부: ${if (isStudent) "예" else "아니오"}")
    
    // 내년 나이
    val nextYearAge = age + 1
    println("내년 나이: $nextYearAge세")
    
    // 성인 여부
    val isAdult = age >= 20
    println("성인 여부: ${if (isAdult) "성인" else "미성년자"}")
}

7.3 쇼핑몰 가격 계산

fun main() {
    println("=== 쇼핑몰 가격 계산 ===")
    
    val productName = "무선 이어폰"
    val price = 89_000
    val quantity = 2
    val shippingFee = 3_000
    
    val subtotal = price * quantity
    val total = subtotal + shippingFee
    val discount = 10_000
    val finalPrice = total - discount
    
    println("상품명: $productName")
    println("개당 가격: ${formatPrice(price)}원")
    println("수량: ${quantity}개")
    println()
    println("소계: ${formatPrice(subtotal)}원")
    println("배송비: ${formatPrice(shippingFee)}원")
    println("할인: -${formatPrice(discount)}원")
    println("최종 금액: ${formatPrice(finalPrice)}원")
}

fun formatPrice(price: Int): String {
    return "%,d".format(price)
}

실행 결과

=== 쇼핑몰 가격 계산 ===
상품명: 무선 이어폰
개당 가격: 89,000원
수량: 2개

소계: 178,000원
배송비: 3,000원
할인: -10,000원
최종 금액: 171,000원

7.4 Java와 Kotlin 비교 - 완전한 예제

Java

public class UserInfo {
    public static void main(String[] args) {
        String name = "John";
        int age = 25;
        String email = "john@example.com";
        boolean isPremium = true;
        
        System.out.println("=== User Information ===");
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
        System.out.println("Email: " + email);
        System.out.println("Premium: " + (isPremium ? "Yes" : "No"));
        
        int nextYearAge = age + 1;
        System.out.println("Next year: " + nextYearAge);
    }
}

Kotlin

fun main() {
    val name = "John"
    val age = 25
    val email = "john@example.com"
    val isPremium = true
    
    println("=== User Information ===")
    println("Name: $name")
    println("Age: $age")
    println("Email: $email")
    println("Premium: ${if (isPremium) "Yes" else "No"}")
    
    val nextYearAge = age + 1
    println("Next year: $nextYearAge")
}

차이점 정리:

• 줄 수: Java 18줄 → Kotlin 14줄
• 문자열 연결: + → String Template $
• 삼항 연산자: ? : → if expression
• 세미콜론: 필수 → 선택사항

---

마치며

핵심 요약

Kotlin의 첫인상

1. 간결함: Java보다 훨씬 적은 코드
2. 안전함: Null Safety, 타입 안전성
3. 쉬움: 타입 추론, 문자열 템플릿
4. 호환성: Java 라이브러리 그대로 사용

오늘 배운 것

• ✅ IntelliJ IDEA로 Kotlin 프로젝트 생성
• ✅ fun main() - 간단한 Hello World
• ✅ val (불변), var (가변)
• ✅ 타입 추론으로 간결한 코드
• ✅ 문자열 템플릿 $변수, ${표현식}

Java 개발자를 위한 팁

// Java 습관 버리기
val name: String = "John"  // ❌ 불필요한 타입 명시
val name = "John"          // ✅ 타입 추론 활용

// val 우선, var는 필요할 때만
var count = 0  // 변경이 필요한 경우
val name = "John"  // 대부분의 경우

// 세미콜론 생략
val x = 10;  // ❌ 불필요
val x = 10   // ✅ 간결하게

// 문자열 연결은 템플릿으로
"Hello " + name  // ❌ Java 스타일
"Hello $name"    // ✅ Kotlin 스타일

다음 학습 내容

2편: Kotlin 함수 완벽 가이드

• 함수 선언과 호출
• Named Parameters & Default Parameters
• Single Expression Function
• Extension Functions

연습 과제

1. 자신의 정보(이름, 나이, 직업)를 출력하는 프로그램 작성
2. BMI 계산기 만들기 (체중, 키 입력)
3. 섭씨를 화씨로 변환하는 프로그램 작성

// BMI 계산기 예제
fun main() {
    val weight = 70.5  // kg
    val height = 1.75  // m
    val bmi = weight / (height * height)
    
    println("체중: ${weight}kg")
    println("키: ${height}m")
    println("BMI: ${"%.2f".format(bmi)}")
}

유용한 리소스

공식 문서

• Kotlin 공식 사이트: https://kotlinlang.org/
• 튜토리얼: https://kotlinlang.org/docs/tutorials/
• Kotlin Koans: https://play.kotlinlang.org/koans

추천 도서

• "Kotlin in Action" by Dmitry Jemerov
• "Head First Kotlin" by Dawn Griffiths

커뮤니티

• Kotlin Slack: https://surveys.jetbrains.com/s3/kotlin-slack-sign-up
• Reddit: r/Kotlin
• Stack Overflow: [kotlin] 태그

---

시리즈 목록

1. Kotlin 시작하기 ← 현재 글
2. Kotlin 함수 완벽 가이드
3. Kotlin 클래스 기초
4. Kotlin Null Safety 완벽 가이드