# 관련링크 - [재생목록](https://www.youtube.com/playlist?list=PLE0hRBClSk5J2rbJIVv_3nvKma3D1_u-g) # 1강 : 코틀린 개발환경 세팅 - [25 02 13, p 14039, 1강, 코틀린 개발환경 세팅](https://youtu.be/Pj6jx-ZmdMA) - [GITHUB - 리포지터리](https://github.com/jhs512/kotlin-exam-2025-02-13) - [커밋](https://github.com/jhs512/kotlin-exam-2025-02-13/commit/8ae7911) - ![img](https://i.postimg.cc/ZKZzCNVk/image.png) # 2강 : 코틀린은 자바와 100% 호환되는 조금 더 진보된 언어이다. - [25 02 13, p 14039, 2강, 코틀린은 자바와 100% 호환되는 조금 더 진보된 언어이다.](https://youtu.be/e2Z141lxlHM) - [커밋](https://github.com/jhs512/kotlin-exam-2025-02-13/commit/1c03990) ## 설명 - 자바와 코틀린은 서로 100% 호환이 된다.(거의 100%) # 3강 : 변수 선언과 기본 출력 - [25 02 13, p 14039, 3강, 변수 선언과 기본 출력](https://youtu.be/lQUBV4bFR4o) **설명:** 자바와 코틀린에서 변수를 선언하고 출력하는 기본 예제입니다. 코틀린은 `val`(불변)과 `var`(가변)을 사용하며, `System.out.println()` 대신 `println()`을 사용합니다. ## **자바 코드** ```java public class Main { public static void main(String[] args) { final int number = 10; // 정수형 변수 선언 String message = "Hello, Java!"; // 문자열 변수 선언 System.out.println("Number: " + number); System.out.println("Message: " + message); } } ``` ## **코틀린 코드** ```kotlin fun main() { val number = 10 // 불변 변수 선언 (val) var message = "Hello, Kotlin!" // 문자열 변수 선언 println("Number: $number") println("Message: $message") } ``` # 4강 : 조건문 (if-else) - [25 02 13, p 14039, 4강, 조건문 (if-else)](https://youtu.be/Kk3NT7_0j5Y) **설명:** 자바와 코틀린에서 `if-else` 문을 사용하는 방법을 비교합니다. 코틀린에서는 `if` 문이 표현식(expression)으로 사용할 수 있습니다. 코틀린에는 삼항연산자가 없습니다. ## **자바 코드** ```java public class Main { public static void main(String[] args) { int number = 15; if (number % 2 == 0) { System.out.println("Even Number"); } else { System.out.println("Odd Number"); } } } ``` ## **코틀린 코드** ```kotlin fun main() { val number = 15 // if-else를 표현식으로 사용 가능 val result = if (number % 2 == 0) "Even Number" else "Odd Number" println(result) } ``` # 5강 : 반복문 (for) - [25 02 13, p 14039, 5강, 반복문 (for)](https://youtu.be/33-L4FD_XDs) **설명:** 자바와 코틀린에서 `for` 반복문을 사용하는 방법을 비교합니다. 코틀린은 `for-in` 문법을 제공하며, `until` 키워드를 사용하여 범위를 지정할 수 있습니다. ## **자바 코드** ```java public class Main { public static void main(String[] args) { for (int i = 0; i < 5; i++) { System.out.println("Count: " + i); } } } ``` ## **코틀린 코드** ```kotlin fun main() { for (i in 0 until 5) { // 0부터 4까지 반복 println("Count: $i") } } ``` # 6강 : 함수 선언과 호출 - [25 02 13, p 14039, 6강, 함수 선언과 호출](https://youtu.be/GZjtmRqa2q8) **설명:** 자바와 코틀린에서 함수를 선언하고 호출하는 방법을 비교합니다. 코틀린은 `fun` 키워드를 사용하며, 반환 타입을 함수 선언 끝에 적습니다. ## **자바 코드** ```java public class Main { public static void main(String[] args) { int result = add(5, 10); System.out.println("Result: " + result); } public static int add(int a, int b) { return a + b; } } ``` ## **코틀린 코드** ```kotlin fun main() { val result = add(5, 10) println("Result: $result") } fun add(a: Int, b: Int): Int { return a + b } ``` # 7강 : 클래스와 객체 - [25 02 13, p 14039, 7강, 클래스와 객체](https://youtu.be/QHP9XAl-LA4) **설명:** 자바와 코틀린에서 클래스를 선언하고 객체를 생성하는 방법을 비교합니다. 코틀린은 `class` 키워드를 사용하며, 생성자 정의를 간결하게 할 수 있습니다. ## **자바 코드** ```java class Person { String name; // 생성자 public Person(String name) { this.name = name; } public void greet() { System.out.println("Hello, my name is " + name); } } public class Main { public static void main(String[] args) { Person person = new Person("Alice"); person.greet(); } } ``` ## **코틀린 코드** ```kotlin class Person(val name: String) { fun greet() { println("Hello, my name is $name") } } fun main() { val person = Person("Alice") person.greet() } ``` # 8강 : 리스트(List) 사용 - [25 02 13, p 14039, 8강, 리스트(List) 사용](https://youtu.be/KPCvqoJPVN0) **설명:** 자바와 코틀린에서 리스트를 다루는 방법을 비교합니다. 코틀린에서는 `listOf()`를 사용하여 불변 리스트를 만들고, `mutableListOf()`를 사용하여 가변 리스트를 만듭니다. ## **자바 코드** ```java import java.util.ArrayList; import java.util.List; public class Main { public static void main(String[] args) { List names = new ArrayList<>(); names.add("Alice"); names.add("Bob"); names.add("Charlie"); for (String name : names) { System.out.println(name); } } } ``` ## **코틀린 코드** ```kotlin fun main() { val names = listOf("Alice", "Bob", "Charlie") // 불변 리스트 for (name in names) { println(name) } } ``` # 9강 : 맵(Map) 사용 - [25 02 13, p 14039, 9강, 맵(Map) 사용](https://youtu.be/R1-z2GwVSTU) **설명:** 자바와 코틀린에서 `Map`을 사용하는 방법을 비교합니다. 코틀린에서는 `mapOf()`를 사용하여 불변 맵을 만들고, `mutableMapOf()`를 사용하여 가변 맵을 만들 수 있습니다. ## **자바 코드** ```java import java.util.HashMap; import java.util.Map; public class Main { public static void main(String[] args) { Map ages = new HashMap<>(); ages.put("Alice", 25); ages.put("Bob", 30); ages.put("Charlie", 35); for (Map.Entry entry : ages.entrySet()) { System.out.println(entry.getKey() + " is " + entry.getValue() + " years old."); } } } ``` ## **코틀린 코드** ```kotlin fun main() { val ages = mapOf("Alice" to 25, "Bob" to 30, "Charlie" to 35) // 불변 맵 for ((name, age) in ages) { println("$name is $age years old.") } } ``` # 10강 : 널(null) 처리 - [25 02 13, p 14039, 10강, 널(null) 처리](https://youtu.be/NWWnuOSuvq4) **설명:** 자바와 코틀린에서 `null`을 처리하는 방법을 비교합니다. 코틀린은 `?`을 사용하여 nullable 타입을 명시하고, `?.` 연산자를 사용하여 안전하게 접근합니다. ## **자바 코드** ```java public class Main { public static void main(String[] args) { String name = null; if (name != null) { System.out.println(name.length()); } else { System.out.println("Name is null"); } // 자바에서 안전하게 함수 호출하려면 이렇게 해야 함 Person person = new Person(); if ( person != null && person.leftArm != null && person.leftArm.hand != null ) person.leftArm.hand.grab(); } } ``` ## **코틀린 코드** ```kotlin fun main() { val name: String? = null // nullable 타입 println(name?.length ?: "Name is null") // 안전한 호출 연산자와 엘비스 연산자 사용 val person:Person? = Person() // 코틀린에서는 안전하게 함수 호출하려면 이렇게만 해도 됩니다. person?.leftArm?.hand?.grab(); } ``` # 11강 : 람다 표현식 - [25 02 13, p 14039, 11강, 람다 표현식](https://youtu.be/q9p7vsAWdb4) **설명:** 자바와 코틀린에서 람다 표현식을 사용하는 방법을 비교합니다. 코틀린은 `it`을 사용하여 단일 매개변수를 간단하게 참조할 수 있습니다. ## **자바 코드** ```java import java.util.Arrays; import java.util.List; public class Main { public static void main(String[] args) { List names = Arrays.asList("Alice", "Bob", "Charlie"); names.forEach(name -> System.out.println("Hello, " + name)); } } ``` ## **코틀린 코드** ```kotlin fun main() { val names = listOf("Alice", "Bob", "Charlie") names.forEach { println("Hello, $it") } } ``` # 12강 : 데이터 클래스 (Data Class) - [25 02 13, p 14039, 12강, 데이터 클래스 (Data Class)](https://youtu.be/W4sjn8mxjQY) **설명:** 코틀린에서는 `data class`를 사용하여 자동으로 `equals()`, `hashCode()`, `toString()`을 생성할 수 있습니다. 자바에서는 이를 직접 구현해야 합니다. ## **자바 코드** ```java import java.util.Objects; public class Person { private String name; private int age; public Person(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public int getAge() { return age; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Person person = (Person) o; return age == person.age && Objects.equals(name, person.name); } @Override public int hashCode() { return Objects.hash(name, age); } @Override public String toString() { return "Person{name='" + name + "', age=" + age + "}"; } } ``` ## **코틀린 코드** ```kotlin data class Person(val name: String, val age: Int) fun main() { val person = Person("Alice", 30) println(person) // 자동 생성된 toString() 사용 } ``` # 13강 : 확장 함수 (Extension Function) - [25 02 13, p 14039, 13강, 확장 함수 (Extension Function)](https://youtu.be/YIf1dE0vEZM) **설명:** 코틀린에서는 기존 클래스에 새로운 함수를 추가할 수 있는 **확장 함수** 기능을 제공합니다. 자바에서는 별도의 유틸리티 클래스를 만들어야 합니다. ## **자바 코드** ```java public class StringUtils { public static String greet(String name) { return "Hello, " + name + "!"; } } public class Main { public static void main(String[] args) { System.out.println(StringUtils.greet("Alice")); } } ``` ## **코틀린 코드** ```kotlin fun String.greet(): String { return "Hello, $this!" } fun main() { println("Alice".greet()) // 확장 함수 사용 } ``` # 14강 : 기본 매개변수 (Default Parameter) - [25 02 14, p 14039, 14강, 기본 매개변수 (Default Parameter)](https://youtu.be/TUeH6KFeLeQ) **설명:** 코틀린에서는 **기본 매개변수** 를 제공하여 오버로딩 없이 기본값을 설정할 수 있습니다. 자바에서는 오버로딩을 사용해야 합니다. ## **자바 코드** ```java public class Greeting { public static void sayHello() { sayHello("Guest"); // 기본값 제공 } public static void sayHello(String name) { System.out.println("Hello, " + name); } public static void main(String[] args) { sayHello(); sayHello("Alice"); } } ``` ## **코틀린 코드** ```kotlin fun sayHello(name: String = "Guest") { println("Hello, $name") } fun main() { sayHello() // 기본값 사용 sayHello("Alice") } ``` # 15강 : 객체 싱글톤 (Singleton) - [25 02 14, p 14039, 15강, 객체 싱글톤 (Singleton)](https://youtu.be/EPh2WQ6uX1Y) **설명:** 코틀린은 `object` 키워드를 사용하여 간단하게 싱글톤을 만들 수 있습니다. 자바에서는 `static` 키워드나 `enum`을 활용해야 합니다. ## **자바 코드** ```java public class Singleton { private static final Singleton INSTANCE = new Singleton(); private Singleton() {} public static Singleton getInstance() { return INSTANCE; } public void showMessage() { System.out.println("Hello from Singleton!"); } public static void main(String[] args) { Singleton.getInstance().showMessage(); } } ``` ## **코틀린 코드** ```kotlin object Singleton { fun showMessage() { println("Hello from Singleton!") } } fun main() { Singleton.showMessage() } ``` # 16강 : 문자열 템플릿 (String Template) - [25 02 14, p 14039, 16강, 문자열 템플릿 (String Template)](https://youtu.be/Ey8oKSkaAFQ) **설명:** 코틀린은 문자열 내부에 변수 값을 쉽게 삽입할 수 있는 **문자열 템플릿** 기능을 제공합니다. 자바에서는 `+` 연산자나 `String.format()`을 사용해야 합니다. ## **자바 코드** ```java public class Main { public static void main(String[] args) { String name = "Alice"; int age = 25; System.out.println("My name is " + name + " and I am " + age + " years old."); } } ``` ## **코틀린 코드** ```kotlin fun main() { val name = "Alice" val age = 25 println("My name is $name and I am $age years old.") // 문자열 템플릿 사용 } ``` # 17강 : 예외 처리 (Try-Catch) - [25 02 14, p 14039, 17강, 예외 처리 (Try-Catch)](https://youtu.be/jS5ueAF4jqc) **설명:** 자바와 코틀린의 예외 처리는 유사하지만, 코틀린에서는 `try`를 표현식으로 사용할 수 있습니다. 또한, `checked exception`이 없기 때문에 `throws` 선언이 필요 없습니다. ## **자바 코드** ```java import java.io.File; import java.io.IOException; import java.nio.file.Files; import java.nio.file.StandardCopyOption; public class Main { public static void main(String[] args) { try { copy("a.txt", "a_copy.txt"); } catch (IOException e) { throw new RuntimeException(e); } } public static void copy(String source, String target) throws IOException { Files.copy(new File(source).toPath(), new File(target).toPath(), StandardCopyOption.REPLACE_EXISTING); } } ``` ## **코틀린 코드** ```kotlin import java.io.File import java.nio.file.Files import java.nio.file.StandardCopyOption fun main() { copy("a.txt", "a_copy.txt") } fun copy(source: String, target: String) { Files.copy(File(source).toPath(), File(target).toPath(), StandardCopyOption.REPLACE_EXISTING) } ``` # 18강 : when 문 (Switch 대체) - [25 02 14, p 14039, 18강, when 문 (Switch 대체)](https://youtu.be/8Whh3X4wKj8) **설명:** 코틀린의 `when` 문은 자바의 `switch` 문을 대체하며, 표현식으로 사용할 수도 있습니다. `else`는 기본적으로 `default` 역할을 합니다. ## **자바 코드** ```java public class Main { public static void main(String[] args) { int day = 3; String dayName; switch (day) { case 1: dayName = "Monday"; break; case 2: dayName = "Tuesday"; break; case 3: dayName = "Wednesday"; break; default: dayName = "Invalid Day"; } System.out.println("Day: " + dayName); } } ``` ## **코틀린 코드** ```kotlin fun main() { val day = 3 val dayName = when (day) { 1 -> "Monday" 2 -> "Tuesday" 3 -> "Wednesday" else -> "Invalid Day" } println("Day: $dayName") } ``` # 19강 : 컬렉션 필터링 (Filtering Collections) - [25 02 14, p 14039, 19강, 컬렉션 필터링 (Filtering Collections)](https://youtu.be/JbJ3n0oeCCI) **설명:** 코틀린에서는 `filter` 함수를 사용하여 간결하게 리스트를 필터링할 수 있습니다. 자바에서는 `Stream API`를 활용해야 합니다. ## **자바 코드** ```java import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; public class Main { public static void main(String[] args) { List numbers = Arrays.asList(1, 2, 3, 4, 5, 6); List evenNumbers = numbers.stream() .filter(n -> n % 2 == 0) .collect(Collectors.toList()); System.out.println(evenNumbers); } } ``` ## **코틀린 코드** ```kotlin fun main() { val numbers = listOf(1, 2, 3, 4, 5, 6) val evenNumbers = numbers.filter { it % 2 == 0 } println(evenNumbers) } ``` # 20강 : forEach와 map (리스트 변환) - [25 02 14, p 14039, 20강, forEach와 map (리스트 변환)](https://youtu.be/Plcyqc27myE) **설명:** 자바에서는 `Stream API`를 사용해야 하지만, 코틀린에서는 `map`이 기본적으로 제공됩니다. ## **자바 코드** ```java import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; public class Main { public static void main(String[] args) { List names = Arrays.asList("Alice", "Bob", "Charlie"); List greetings = names.stream() .map(name -> "Hello, " + name) .collect(Collectors.toList()); greetings.forEach(System.out::println); } } ``` ## **코틀린 코드** ```kotlin fun main() { val names = listOf("Alice", "Bob", "Charlie") val greetings = names.map { "Hello, $it" } greetings.forEach(::println) } ``` # 21강 : 엘비스 연산자 (`?:`) - [25 02 14, p 14039, 21강, 엘비스 연산자 (`?:`)](https://youtu.be/WvKn66cyTf8) **설명:** 코틀린에서는 `?:` (엘비스 연산자)를 사용하여 `null`인 경우 기본값을 제공할 수 있습니다. 자바에서는 `if-else` 또는 `Optional`을 사용해야 합니다. ## **자바 코드** ```java public class Main { public static void main(String[] args) { String name = null; String displayName = (name != null) ? name : "Guest"; System.out.println("Hello, " + displayName); } } ``` ## **코틀린 코드** ```kotlin fun main() { val name: String? = null val displayName = name ?: "Guest" // 엘비스 연산자로 기본값 제공 println("Hello, $displayName") } ``` # 22강 : 타입 체크와 캐스팅 (`is` vs `instanceof`) - [25 02 14, p 14039, 22강, 타입 체크와 캐스팅 (`is` vs `instanceof`)](https://youtu.be/RSk1aWk6b0Q) **설명:** 자바에서는 `instanceof`를 사용하여 타입을 체크한 후 명시적으로 캐스팅해야 합니다. 코틀린에서는 `is`를 사용하며, 스마트 캐스트 기능을 제공하여 자동 캐스팅됩니다. ## **자바 코드** ```java public class Main { public static void main(String[] args) { Object obj = "Hello"; if (obj instanceof String) { String str = (String) obj; // 명시적 캐스팅 필요 System.out.println(str.length()); } } } ``` ## **코틀린 코드** ```kotlin fun main() { val obj: Any = "Hello" if (obj is String) { // 스마트 캐스트 적용 println(obj.length) // 자동으로 String으로 캐스팅됨 } } ``` # 23강 : apply, let, also, run, with (스코프 함수) - [25 02 14, p 14039, 23강, apply, let, also, run, with (스코프 함수)](https://youtu.be/XN1QcKZjcg4) **설명:** 코틀린은 `apply`, `let`, `also`, `run`, `with` 같은 **스코프 함수** 를 제공하여 객체 조작을 간결하게 만듭니다. 자바에서는 메서드 체이닝을 직접 구현해야 합니다. ## **자바 코드** ```java class Person { String name; int age; public Person setName(String name) { this.name = name; return this; } public Person setAge(int age) { this.age = age; return this; } public void printInfo() { System.out.println(name + " is " + age + " years old."); } public static void main(String[] args) { Person person = new Person() .setName("Alice") .setAge(30); person.printInfo(); } } ``` ## **코틀린 코드** ```kotlin class Person { var name: String = "" var age: Int = 0 fun printInfo() { println("$name is $age years old.") } } fun main() { val person = Person().apply { name = "Alice" age = 30 } person.printInfo() } ``` # 24강 : `apply` - 객체 설정 후 반환 - [25 02 14, p 14039, 24강, `apply` - 객체 설정 후 반환](https://youtu.be/QTe8k-1bIRg) **설명:** `apply`는 **객체를 생성한 후 내부 속성을 설정**할 때 사용합니다. 마지막에 **해당 객체를 반환**하므로, 객체 초기화에 유용합니다. ## **자바 코드** ```java class Person { String name; int age; public Person setName(String name) { this.name = name; return this; } public Person setAge(int age) { this.age = age; return this; } public void printInfo() { System.out.println(name + " is " + age + " years old."); } public static void main(String[] args) { Person person = new Person() .setName("Alice") .setAge(30); person.printInfo(); } } ``` ## **코틀린 코드** ```kotlin class Person { var name: String = "" var age: Int = 0 fun printInfo() { println("$name is $age years old.") } } fun main() { val person = Person().apply { name = "Alice" age = 30 } person.printInfo() } ``` # 25강 : `let` - 안전 호출과 변환 - [25 02 14, p 14039, 25강, `let` - 안전 호출과 변환](https://youtu.be/b-epR5hntfw) **설명:** `let`은 **null이 아닌 경우 특정 로직을 실행**할 때 유용합니다. 또한, **리턴값을 변환하여 새로운 값으로 사용할 수도 있습니다.** 주로 **안전 호출 (`?.`)과 함께 사용**됩니다. ## **자바 코드** ```java public class Main { public static void main(String[] args) { String name = null; if (name != null) { int length = name.length(); System.out.println("Length: " + length); } } } ``` ## **코틀린 코드** ```kotlin fun main() { val name: String? = null name?.let { println("Length: ${it.length}") } } ``` # 26강 : `also` - 부가적인 로직 실행 - [25 02 14, p 14039, 26강, `also` - 부가적인 로직 실행](https://youtu.be/Ozb_KZ3S6GE) **설명:** `also`는 **객체를 유지하면서 추가적인 작업을 수행**할 때 사용합니다. 로그 출력이나 디버깅에 자주 활용됩니다. ## **자바 코드** ```java public class Main { public static void main(String[] args) { String message = "Hello"; System.out.println("Before: " + message); message = message.toUpperCase(); System.out.println("After: " + message); } } ``` ## **코틀린 코드** ```kotlin fun main() { val message = "Hello".also { println("Before: $it") }.uppercase().also { println("After: $it") } } ``` # 27강 : `run` - 블록 실행 후 반환 - [25 02 14, p 14039, 27강, `run` - 블록 실행 후 반환](https://youtu.be/L81Zff02vmw) **설명:** `run`은 **일회성 작업을 수행한 후 결과를 반환**할 때 유용합니다. 객체 생성 없이 특정 블록을 실행할 수도 있습니다. ## **자바 코드** ```java public class Main { public static void main(String[] args) { int result = compute(5); System.out.println("Result: " + result); } public static int compute(int x) { return x * 2 + 10; } } ``` ## **코틀린 코드** ```kotlin fun main() { val result = run { val x = 5 x * 2 + 10 } println("Result: $result") } ``` # 28강 : `with` - 객체 설정과 결과 반환 - [25 02 14, p 14039, 28강, `with` - 객체 설정과 결과 반환](https://youtu.be/ZoqCuN0PtC4) **설명:** `with`는 **객체를 컨텍스트로 가져와 여러 작업을 수행**한 후 **결과를 반환**합니다. 코틀린에서는 `with(객체) { }` 형식으로 사용되며, **객체를 수정하는 것이 아니라 작업만 수행**하는 점이 `apply`와 다릅니다. ## **자바 코드** ```java class Person { String name; int age; double weight; double salary; public Person(String name, int age, double weight, double salary) { this.name = name; this.age = age; this.weight = weight; this.salary = salary; } public void increaseAge(int years) { this.age += years; } public void increaseWeight(double kg) { this.weight += kg; } public void increaseSalary(double amount) { this.salary += amount; } public String getInfo() { return name + " is " + age + " years old, weighs " + weight + "kg, and earns $" + salary; } public static void main(String[] args) { Person person = new Person("Alice", 30, 55.0, 50000.0); // with와 비슷한 방식으로 메서드 체이닝 사용 person.increaseAge(5); person.increaseWeight(3.5); person.increaseSalary(10000); String info = person.getInfo(); System.out.println(info); } } ``` ## **코틀린 코드** ```kotlin class Person(val name: String, var age: Int, var weight: Double, var salary: Double) { fun increaseAge(years: Int) { age += years } fun increaseWeight(kg: Double) { weight += kg } fun increaseSalary(amount: Double) { salary += amount } fun getInfo() = "$name is $age years old, weighs $weight kg, and earns $$salary" } fun main() { val person = Person("Alice", 30, 55.0, 50000.0) val info = with(person) { increaseAge(5) increaseWeight(3.5) increaseSalary(10000.0) getInfo() // 마지막 실행된 값이 반환됨 } println(info) } ``` # 29강 : `apply`, `let`, `also`, `run`, `with` 정리 표 - [25 02 14, p 14039, 29강, `apply`, `let`, `also`, `run`, `with` 정리 표](https://youtu.be/IOfJZfeqSKw) | 함수 | 리턴값 | 컨텍스트(`this` or `it`) | 사용 목적 | |-------|--------|----------------------|----------| | `apply` | 객체 자체 | `this` | **객체 설정** (초기화, 프로퍼티 변경) | | `let` | 람다 결과값 | `it` | **안전 호출과 변환** (Nullable 처리, 새로운 값 반환) | | `also` | 객체 자체 | `it` | **객체 유지 + 추가 로직 수행** (디버깅, 로깅) | | `run` | 람다 결과값 | `this` | **객체 설정 + 결과 반환** (객체 없이 블록 실행도 가능) | | `with` | 람다 결과값 | `this` | **객체를 컨텍스트로 작업 수행 후 결과 반환** | ### ✅ **정리 요약** - `apply`, `also` → **객체 자체를 반환** - `let`, `run`, `with` → **람다 결과를 반환** - `apply`, `run`, `with` → **`this` 사용** - `let`, `also` → **`it` 사용** ### 🔥 **사용 예제 비교** ```kotlin class Person { var name: String = "" var age: Int = 0 } fun main() { val person = Person() person.apply { // 객체 자체 반환 name = "Alice" age = 30 }.also { // 객체 그대로 유지하면서 로깅 가능 println("Created person: ${it.name}, ${it.age}") }.let { // 변환 가능 (여기서는 이름 길이 반환) it.name.length }.run { // 특정 연산 후 결과 반환 this * 2 }.also { println("Final result: $it") } val personInfo = with(person) { // 객체 컨텍스트로 실행 후 결과 반환 "Name: $name, Age: $age" } println(personInfo) } ``` # 30강 : `lateinit` - 나중에 초기화하는 변수 - [25 02 14, p 14039, 30강, `lateinit` - 나중에 초기화하는 변수](https://youtu.be/W6Cphf9RAdQ) **설명:** - `lateinit`은 **var(변경 가능 변수)** 에서 사용 가능 - 기본적으로 **null 허용 불가 (`String?` 불가능)** - **초기화 없이 선언 가능**, 나중에 `setter`를 통해 값 할당 - **초기화 전에 접근하면 예외 발생 (`UninitializedPropertyAccessException`)** ## **자바 코드** ```java class Example { private String value; public void setValue(String value) { this.value = value; } public String getValue() { if (value == null) { throw new IllegalStateException("Value is not initialized"); } return value; } public static void main(String[] args) { Example example = new Example(); example.setValue("Hello, Kotlin!"); System.out.println(example.getValue()); } } ``` ## **코틀린 코드** ```kotlin class Example { lateinit var value: String // 초기화 없이 선언 가능 fun printValue() { println(value) // 초기화 전 접근하면 예외 발생 } } fun main() { val example = Example() example.value = "Hello, Kotlin!" // 나중에 값 설정 example.printValue() } ``` # 31강 : `lazy` - 최초 접근 시 초기화 (Lazy Initialization) - [25 02 14, p 14039, 31강, `lazy` - 최초 접근 시 초기화 (Lazy Initialization)](https://youtu.be/RAnfR8_b_XQ) **설명:** - `lazy`는 **val(불변 변수)** 에서 사용 가능 - **한 번만 초기화됨** (캐싱됨, 이후 동일한 값 유지) - **객체를 처음 사용할 때 초기화됨** (지연 로딩) - 동기적으로 작동 (`lazy(LazyThreadSafetyMode.SYNCHRONIZED)` 기본 적용) ## **자바 코드** ```java class Example { private String value; public String getValue() { if (value == null) { value = "Hello, Lazy!"; } return value; } public static void main(String[] args) { Example example = new Example(); System.out.println(example.getValue()); // 최초 접근 시 초기화 System.out.println(example.getValue()); // 이후 캐싱된 값 사용 } } ``` ## **코틀린 코드** ```kotlin val lazyValue: String by lazy { println("Initializing...") // 최초 접근 시 실행 "Hello, Lazy!" } fun main() { println("Before accessing lazyValue") println(lazyValue) // 첫 호출 시 초기화됨 println(lazyValue) // 이후에는 캐싱된 값 사용 } ``` # 32강 : `lateinit` vs `lazy` 비교 - [25 02 14, p 14039, 32강, `lateinit` vs `lazy` 비교](https://youtu.be/k-ubKasjqno) | 비교 항목 | `lateinit` | `lazy` | |-----------|-----------|--------| | 사용 대상 | `var` (변경 가능 변수) | `val` (불변 변수) | | 초기화 시점 | **명시적으로** 코드에서 설정 (`변수 = 값`) | **최초 접근 시 자동 초기화** | | null 허용 여부 | ❌ (`String?` 불가능) | ✅ 가능 (`lazy { null }` 가능) | | 재할당 여부 | 가능 (나중에 값 변경 가능) | 불가능 (최초 값 유지) | | 예외 발생 가능성 | 초기화 전에 접근하면 `UninitializedPropertyAccessException` | 예외 없음 (사용 시 자동 초기화) | | 멀티스레드 안전성 | 보장되지 않음 (직접 관리) | 기본적으로 **동기화됨** (`lazy(LazyThreadSafetyMode.SYNCHRONIZED)`) | ## 🔥 **사용 예제 비교** ```kotlin class Example { lateinit var name: String val lazyMessage: String by lazy { println("Lazy value initialized!") "Hello, Lazy!" } } fun main() { val example = Example() // lateinit 사용: 명시적으로 값 할당 후 사용 example.name = "Alice" println("Name: ${example.name}") // lazy 사용: 최초 접근 시 초기화 println("Before accessing lazyMessage") println(example.lazyMessage) println(example.lazyMessage) // 두 번째 호출은 초기화 없이 사용 } ``` # 33강 : 동반 객체 (`companion object`) - [25 02 14, p 14039, 33강, 동반 객체 (`companion object`)](https://youtu.be/qvSrgaIwWWI) **설명:** 코틀린에서는 **클래스 내부에서 정적 멤버를 선언할 때 `companion object`를 사용**합니다. 자바의 `static` 멤버와 유사하지만, **객체처럼 사용**할 수 있습니다. ## **자바 코드** ```java class MathUtils { public static final double PI = 3.14159; public static int square(int x) { return x * x; } } public class Main { public static void main(String[] args) { System.out.println("PI: " + MathUtils.PI); System.out.println("Square of 4: " + MathUtils.square(4)); } } ``` ## **코틀린 코드** ```kotlin class MathUtils { companion object { const val PI = 3.14159 fun square(x: Int) = x * x } } fun main() { println("PI: ${MathUtils.PI}") println("Square of 4: ${MathUtils.square(4)}") } ``` # 34강 : `object` vs `companion object` 비교 - [25 02 14, p 14039, 34강, `object` vs `companion object` 비교](https://youtu.be/d2FnIg0z6wg) **설명:** 코틀린에서는 `object`와 `companion object`를 사용하여 싱글톤 및 정적 멤버를 관리할 수 있음. - `object` → **싱글톤 객체** - `companion object` → **클래스 내부에서 정적 멤버처럼 사용** ## **1️⃣ `object` - 싱글톤 객체** **특징:** ✅ **클래스가 아니라 곧바로 하나의 객체** ✅ 프로그램 실행 시 **자동 생성**되며, **전역적으로 사용 가능** ✅ 생성자가 없음 (`object`는 인스턴스를 만들 수 없음) ### **자바 코드 (싱글톤 패턴)** ```java class Singleton { private static final Singleton INSTANCE = new Singleton(); private Singleton() {} public static Singleton getInstance() { return INSTANCE; } public void showMessage() { System.out.println("Hello from Singleton!"); } public static void main(String[] args) { Singleton.getInstance().showMessage(); } } ``` ### **코틀린 코드 (`object` 사용)** ```kotlin object Singleton { fun showMessage() { println("Hello from Singleton!") } } fun main() { Singleton.showMessage() // 인스턴스 생성 없이 바로 사용 가능 } ``` ✅ **자바에서는 `static` 멤버를 이용해 싱글톤을 구현해야 하지만, 코틀린에서는 `object` 키워드로 쉽게 가능** ✅ **클래스가 아니라 곧바로 객체(`Singleton`) 자체를 생성하기 때문에, `new` 키워드 없이 사용 가능** ## **2️⃣ `companion object` - 클래스 내부 정적 멤버** **특징:** ✅ **클래스 내부에 하나만 존재할 수 있음** ✅ **`static`처럼 정적 멤버를 선언하는 용도** ✅ 클래스의 인스턴스를 생성하지 않아도 접근 가능 (`클래스명.함수명()`) ✅ 하지만 `object`와 다르게, **클래스와 연결된 멤버처럼 동작** ### **자바 코드 (정적 메서드)** ```java class MathUtils { public static final double PI = 3.14159; public static int square(int x) { return x * x; } } public class Main { public static void main(String[] args) { System.out.println("PI: " + MathUtils.PI); System.out.println("Square of 4: " + MathUtils.square(4)); } } ``` ### **코틀린 코드 (`companion object` 사용)** ```kotlin class MathUtils { companion object { const val PI = 3.14159 fun square(x: Int) = x * x } } fun main() { println("PI: ${MathUtils.PI}") println("Square of 4: ${MathUtils.square(4)}") // 인스턴스 없이 접근 가능 } ``` ✅ **자바에서 `static` 키워드를 사용했던 방식 대신, 코틀린에서는 `companion object`를 활용하여 정적 멤버 선언 가능** ✅ **클래스 내부에서 정적 메서드처럼 사용할 때 `companion object`가 적합** ## **3️⃣ `object` vs `companion object` 비교 표** | 비교 항목 | `object` | `companion object` | |-----------|-------------|------------------| | 용도 | 싱글톤 객체 | 클래스 내부 정적 멤버 | | 인스턴스 생성 | **불가능** (이미 하나의 객체) | **가능** (클래스 인스턴스 생성 가능) | | 접근 방식 | `객체명.메서드()` | `클래스명.메서드()` | | 클래스 내부 사용 | ❌ 클래스 외부에서 바로 사용 | ✅ 클래스 내부에서 정적 멤버처럼 사용 | | 생성자 사용 | ❌ 생성자 없음 | ❌ 생성자 없음 | | 멀티톤 패턴 | ❌ (싱글톤만 가능) | ✅ 클래스마다 다르게 생성 가능 | ## **4️⃣ 사용 예제 비교** ### **1) `object` 사용 (싱글톤 객체)** ```kotlin object Logger { fun log(message: String) { println("Log: $message") } } fun main() { Logger.log("Application started") // 싱글톤 객체 사용 } ``` ✅ **싱글톤 객체이므로 `Logger()`로 인스턴스를 만들 필요 없음** ### **2) `companion object` 사용 (클래스 내부 정적 멤버)** ```kotlin class User(val name: String) { companion object { fun createGuestUser() = User("Guest") } } fun main() { val guest = User.createGuestUser() // 인스턴스 없이 호출 가능 println("Guest User: ${guest.name}") } ``` ✅ **클래스 내부 정적 메서드를 만들 때 `companion object`가 적합** ✅ `User.createGuestUser()`처럼 **클래스명으로 직접 호출 가능** ## **🔥 최종 정리** ✔ **싱글톤 패턴이 필요할 때 → `object` 사용** ✔ **클래스 내부에서 `static`과 같은 정적 멤버가 필요할 때 → `companion object` 사용** ✔ **`companion object`는 `object`와 다르게 클래스 인스턴스 생성이 가능** 🚀 # 35강 : `open` 키워드 (클래스 & 메서드 상속 허용) - [25 02 14, p 14039, 35강, `open` 키워드 (클래스 & 메서드 상속 허용)](https://youtu.be/b9UMSLmTkv0) **설명:** 코틀린에서 기본적으로 **클래스와 메서드는 `final`(상속 불가)** 상태임. 즉, 명시적으로 `open` 키워드를 붙여야 **상속 가능**하게 만들 수 있음. 자바와 달리, 기본적으로 **클래스를 상속하려면 `open`을 사용해야 함.** ## **1️⃣ `open`을 사용하지 않은 경우 (기본 `final`)** ```kotlin class Animal { // 기본적으로 final fun makeSound() { println("Some generic animal sound") } } class Dog : Animal() // ❌ 컴파일 에러! (Animal은 상속 불가) ``` 🔴 **오류 발생:** `Animal`이 기본적으로 `final`이므로 상속할 수 없음. ✔️ **해결 방법:** `open` 키워드를 추가해야 함. ## **2️⃣ `open` 키워드를 사용한 상속 허용** ```kotlin open class Animal { // 이제 상속 가능 open fun makeSound() { println("Some generic animal sound") } } class Dog : Animal() { override fun makeSound() { // 메서드 오버라이딩 가능 println("Bark! Bark!") } } fun main() { val dog = Dog() dog.makeSound() // 출력: Bark! Bark! } ``` ✅ **`open class Animal` → `Animal`이 상속 가능해짐** ✅ **`open fun makeSound()` → 서브클래스에서 `override` 가능해짐** ## **3️⃣ `final`, `open`, `override` 키워드 정리** | 키워드 | 역할 | 기본값 | |--------|------|--------| | `final` | 상속/오버라이딩 불가능 | ✅ (기본값) | | `open` | 상속/오버라이딩 가능 | ❌ (기본값 아님) | | `override` | 부모 클래스의 메서드를 재정의 | - | ✔ **코틀린에서 `open`을 붙이지 않으면 `final`이 기본값!** ✔ **자바와 달리, 명시적으로 `open`을 사용해야 상속 가능** ## **4️⃣ `open` 키워드가 없는 자바 코드와 비교** ### **자바 코드 (`open`이 필요 없음)** ```java class Animal { void makeSound() { System.out.println("Some generic animal sound"); } } class Dog extends Animal { @Override void makeSound() { System.out.println("Bark! Bark!"); } } ``` ✔ 자바에서는 기본적으로 클래스와 메서드가 **`open` 상태** ### **코틀린 코드 (명시적으로 `open` 필요)** ```kotlin open class Animal { // 기본적으로 final이므로 open 필요 open fun makeSound() { println("Some generic animal sound") } } class Dog : Animal() { override fun makeSound() { println("Bark! Bark!") } } ``` ✔ **코틀린에서는 `open`을 명시해야 상속 가능!** ✔ **메서드도 `open`을 붙여야 오버라이딩 가능!** ## **🔥 최종 정리** ✔ **코틀린에서 기본적으로 모든 클래스와 메서드는 `final` 상태** ✔ **클래스를 상속하려면 `open class`로 선언해야 함** ✔ **메서드를 오버라이드하려면 `open fun`으로 선언해야 함** ✔ **`fun`은 오버라이딩이 불가능** 🚀 # 36강 : 자바의 상속 & 인터페이스 vs 코틀린의 상속 & 인터페이스 비교 - [25 02 14, p 14039, 36강, 자바의 상속 & 인터페이스 vs 코틀린의 상속 & 인터페이스 비교](https://youtu.be/FIBGMo1onZ4) **설명:** 자바와 코틀린 모두 **클래스 상속과 인터페이스 구현을 지원**하지만, 코틀린에서는 더 간결하고 명확한 문법을 제공함. ## **1️⃣ 자바의 상속 (`extends`) & 코틀린의 상속 (`:`)** ### **✅ 자바 코드** ```java // 부모 클래스 class Animal { void makeSound() { System.out.println("Some generic animal sound"); } } // 자식 클래스 (상속) class Dog extends Animal { @Override void makeSound() { System.out.println("Bark! Bark!"); } } ``` ### **✅ 코틀린 코드** ```kotlin // 부모 클래스 (코틀린에서는 기본적으로 상속 불가 → open 필요) open class Animal { open fun makeSound() { println("Some generic animal sound") } } // 자식 클래스 (상속) class Dog : Animal() { override fun makeSound() { println("Bark! Bark!") } } ``` ✅ **자바에서는 `extends` 키워드 사용 → 코틀린에서는 `:`로 대체** ✅ **코틀린에서는 기본적으로 클래스가 `final`이므로 `open`을 붙여야 상속 가능** ## **2️⃣ 자바의 인터페이스 (`implements`) & 코틀린의 인터페이스 (`:`)** ### **✅ 자바 코드** ```java // 인터페이스 정의 interface Animal { void makeSound(); } // 클래스에서 인터페이스 구현 class Dog implements Animal { @Override public void makeSound() { System.out.println("Bark! Bark!"); } } ``` ### **✅ 코틀린 코드** ```kotlin // 인터페이스 정의 interface Animal { fun makeSound() } // 클래스에서 인터페이스 구현 class Dog : Animal { override fun makeSound() { println("Bark! Bark!") } } ``` ✅ **자바에서는 `implements` 사용 → 코틀린에서는 `:`로 대체** ✅ **코틀린에서는 인터페이스 메서드에 `abstract`를 붙일 필요 없음** ## **3️⃣ 다중 상속 차이점 (자바 vs 코틀린)** 자바는 **클래스 다중 상속 불가**, **인터페이스 다중 구현 가능** 코틀린도 **클래스 다중 상속 불가**, **인터페이스 다중 구현 가능** ### **✅ 자바 코드** ```java interface Animal { void makeSound(); } interface Pet { void play(); } class Dog implements Animal, Pet { @Override public void makeSound() { System.out.println("Bark! Bark!"); } @Override public void play() { System.out.println("Playing fetch!"); } } ``` ### **✅ 코틀린 코드** ```kotlin interface Animal { fun makeSound() } interface Pet { fun play() } class Dog : Animal, Pet { override fun makeSound() { println("Bark! Bark!") } override fun play() { println("Playing fetch!") } } ``` ✅ **자바와 코틀린 모두 다중 인터페이스 구현 가능** ✅ **코틀린에서는 `,`(쉼표)로 인터페이스 여러 개를 구현 가능** ## **4️⃣ 기본 메서드 (`default` vs `interface` 메서드 구현)** 자바에서는 `default` 메서드를 지원하며, 코틀린에서도 **인터페이스에 메서드 구현이 가능**함. ### **✅ 자바 코드** ```java interface Animal { default void eat() { System.out.println("Eating..."); } } class Dog implements Animal {} public class Main { public static void main(String[] args) { Dog dog = new Dog(); dog.eat(); // "Eating..." } } ``` ### **✅ 코틀린 코드** ```kotlin interface Animal { fun eat() { println("Eating...") } } class Dog : Animal fun main() { val dog = Dog() dog.eat() // "Eating..." } ``` ✅ **자바의 `default` 메서드와 코틀린의 인터페이스 메서드 구현 방식이 동일** ✅ **인터페이스에서 메서드를 구현하면, 모든 구현 클래스가 사용할 수 있음** ## **5️⃣ 같은 이름의 메서드 충돌 시 해결 방법 (자바 vs 코틀린)** 자바와 코틀린 모두 **인터페이스에 같은 이름의 메서드가 있을 경우** 구현 클래스에서 반드시 해결해야 함. ### **✅ 자바 코드** ```java interface Animal { default void makeSound() { System.out.println("Animal sound"); } } interface Pet { default void makeSound() { System.out.println("Pet sound"); } } class Dog implements Animal, Pet { @Override public void makeSound() { Animal.super.makeSound(); // 특정 인터페이스의 메서드 호출 } } ``` ### **✅ 코틀린 코드** ```kotlin interface Animal { fun makeSound() { println("Animal sound") } } interface Pet { fun makeSound() { println("Pet sound") } } class Dog : Animal, Pet { override fun makeSound() { super.makeSound() // 특정 인터페이스의 메서드 호출 } } ``` ✅ **코틀린에서는 `super<인터페이스명>.메서드()`를 사용하여 충돌 해결** ✅ **자바에서는 `인터페이스명.super.메서드()`를 사용하여 해결** ## **6️⃣ 생성자에서 부모 생성자 호출 (`super()` vs `: 부모클래스()`)** ### **✅ 자바 코드** ```java class Animal { String name; Animal(String name) { this.name = name; } } class Dog extends Animal { Dog(String name) { super(name); // 부모 생성자 호출 } } ``` ### **✅ 코틀린 코드** ```kotlin open class Animal(val name: String) class Dog(name: String) : Animal(name) // 부모 생성자 호출 ``` ✅ **자바에서는 `super()`를 사용 → 코틀린에서는 `: 부모클래스()` 사용** ✅ **코틀린은 `val name: String`을 주 생성자로 바로 선언 가능** ## **7️⃣ `abstract` 키워드 비교** 코틀린에서는 **인터페이스 자체가 추상적이므로 `abstract` 불필요** 추상 클래스에서만 **`abstract` 사용 가능** ### **✅ 자바 코드** ```java abstract class Animal { abstract void makeSound(); // 반드시 오버라이딩해야 함 } class Dog extends Animal { @Override void makeSound() { System.out.println("Bark! Bark!"); } } ``` ### **✅ 코틀린 코드** ```kotlin abstract class Animal { abstract fun makeSound() // 반드시 오버라이딩해야 함 } class Dog : Animal() { override fun makeSound() { println("Bark! Bark!") } } ``` ✅ **자바와 코틀린 모두 `abstract` 메서드는 반드시 오버라이딩 필요** ✅ **인터페이스에서는 `abstract`를 사용할 필요 없음 (기본값이 abstract)** ## **🔥 최종 정리** | 비교 항목 | 자바 | 코틀린 | |-----------|------|-------| | 클래스 상속 | `extends` | `:` 사용 (`open` 필요) | | 인터페이스 구현 | `implements` | `:` 사용 | | 다중 인터페이스 | ✅ 지원 | ✅ 지원 | | 기본 메서드 | `default` | 인터페이스 내 메서드 구현 가능 | | 같은 이름 메서드 충돌 해결 | `Interface.super.method()` | `super.method()` | | 부모 생성자 호출 | `super()` | `: 부모클래스()` | | `abstract` 메서드 | `abstract` 필요 | `abstract` 필요 | ✔ **자바의 `extends`, `implements` → 코틀린에서는 `:` 하나로 통합** ✔ **코틀린은 기본적으로 `final`, 상속하려면 `open` 필요** ✔ **인터페이스에서 `default` 없이 바로 메서드 구현 가능** 🚀 # 37강 : object와 companion object가 클래스 상속을 받을 수 있음 - [25 02 14, p 14039, 37강, object와 companion object가 클래스 상속을 받을 수 있음](https://youtu.be/Wz2eVASiTVY) **설명:** 코틀린에서는 `object`와 `companion object`가 **일반 클래스나 인터페이스를 상속받을 수 있음**. 즉, **object는 독립적인 객체이므로 특정 부모 클래스를 확장할 수 있음**. ## **1️⃣ object가 클래스를 상속하는 예제** ### ✅ **부모 클래스를 상속받는 companion object** ```kotlin open class SuperClass { fun greet() = println("Hello from SuperClass") } class Child { companion object : SuperClass() } fun main() { Child.greet() // ✅ 출력: "Hello from SuperClass" } ``` ✅ `companion object`가 `SuperClass`를 상속받아 `greet()` 메서드를 사용 가능 ✅ `Child.greet()`를 호출하면, `SuperClass`의 메서드가 동작 ## **2️⃣ companion object가 인터페이스를 구현하는 예제** ### ✅ **companion object가 인터페이스를 구현** ```kotlin interface Greetable { fun greet() } class Child { companion object : Greetable { override fun greet() { println("Hello from Companion Object") } } } fun main() { Child.greet() // ✅ 출력: "Hello from Companion Object" } ``` ✅ `companion object`가 `Greetable` 인터페이스를 구현하여 `greet()` 메서드 오버라이드 ✅ `Child.greet()`를 호출하면 companion object의 `greet()`가 실행됨 ## **3️⃣ companion object가 부모 클래스와 인터페이스를 동시에 사용할 수 있음** ```kotlin open class SuperClass { fun hello() = println("Hello from SuperClass") } interface Greetable { fun greet() } class Child { companion object : SuperClass(), Greetable { override fun greet() { println("Hello from Companion Object with Interface") } } } fun main() { Child.hello() // ✅ 출력: "Hello from SuperClass" Child.greet() // ✅ 출력: "Hello from Companion Object with Interface" } ``` ✅ `companion object`가 `SuperClass`를 상속하고 `Greetable` 인터페이스를 동시에 구현 가능 ✅ `Child.hello()` → 부모 클래스의 메서드 사용 ✅ `Child.greet()` → companion object에서 오버라이드한 메서드 사용 ## **4️⃣ companion object가 부모 타입으로 사용될 수 있음** ### ✅ **부모 타입 변수에 companion object를 할당 가능** ```kotlin open class SuperClass { open fun message() = "Hello from SuperClass" } class Child { companion object : SuperClass() { override fun message() = "Hello from Companion Object" } } fun main() { val parent: SuperClass = Child // 부모 타입으로 할당 가능 println(parent.message()) // ✅ 출력: "Hello from Companion Object" } ``` ✅ `companion object`가 `SuperClass`를 상속했으므로, 부모 타입 변수로 받을 수 있음 ✅ `val parent: SuperClass = Child`와 같이 사용 가능 ## **🔥 최종 정리** ✔ **`companion object`는 일반 클래스나 인터페이스를 상속받을 수 있음** ✔ **부모 클래스의 메서드를 companion object에서 직접 사용할 수 있음** ✔ **인터페이스를 구현할 수도 있으며, 여러 개를 동시에 확장 가능** ✔ **부모 클래스 타입으로 companion object를 할당할 수도 있음** 🚀 # 38강 : 자바의 Getter, Setter가 없는 `private` vs 코틀린의 `private val` - [25 02 14, p 14039, 38강, 자바의 Getter, Setter가 없는 `private` vs 코틀린의 `private val`](https://youtu.be/LsQzedSsTB4) ## **자바 코드** ```java class Person { private String name = "Unknown"; // private 변수 (외부 접근 불가) } ``` ## **코틀린 코드** ```kotlin class Person { private val name: String = "Unknown" // private val (외부 접근 불가) } ``` **설명:** 자바와 코틀린 모두 `private`을 사용하면 외부에서 읽거나 변경할 수 없음. # 39강 : Getter만 있는 경우 - [25 02 14, p 14039, 39강, Getter만 있는 경우](https://youtu.be/QYkd5bRAEuY) ## **자바 코드** ```java class Person { private String name = "Unknown"; // private 변수 public String getName() { // Getter 제공 (읽기 가능, 변경 불가) return name; } } ``` ## **코틀린 코드** ```kotlin class Person { val name: String = "Unknown" // val 사용 (자동으로 Getter 생성) } ``` **설명:** - 자바에서는 `private` 변수에 대해 **Getter만 제공**하여 읽기만 가능하게 만듦. - 코틀린에서는 `val`을 사용하면 자동으로 **읽기 전용 Getter**가 생성됨. - **Setter가 없으므로 값 변경 불가능**. # 40강 : Setter만 있는 경우 (Getter 호출 시 예외 발생) - [25 02 14, p 14039, 40강, Setter만 있는 경우 (Getter 호출 시 예외 발생)](https://youtu.be/aPKGSE95scY) ## **자바 코드** ```java class Person { private String name = "Unknown"; // private 변수 public void setName(String name) { // Setter 제공 (쓰기 가능, 읽기 불가) this.name = name; } } ``` ## **코틀린 코드** ```kotlin class Person { private var _name: String = "Unknown" // 내부 변수 var name: String get() = throw IllegalAccessException("읽을 수 없습니다.") // Getter 호출 시 예외 발생 set(value) { _name = value } // Setter 제공 (쓰기 가능) } ``` **설명:** - 자바에서는 **Setter만 제공**하면 변수 값을 설정할 수 있지만, 직접 읽을 수 없음. - 코틀린에서는 `get()`에서 **예외를 던지도록 설정**하여 읽기를 방지할 수 있음. - **Setter만 사용 가능하며, `get()` 호출 시 `IllegalAccessException` 발생**. # 41강 : Getter와 Setter가 모두 있는 경우 - [25 02 14, p 14039, 41강, Getter와 Setter가 모두 있는 경우](https://youtu.be/YTrCdEQ7rFs) ## **자바 코드** ```java class Person { private String name; // private 변수 public Person(String name) { // 생성자 this.name = name; } public String getName() { // Getter return name; } public void setName(String name) { // Setter this.name = name; } } ``` ## **코틀린 코드** ```kotlin class Person( var name: String // var 사용 (자동으로 Getter와 Setter 생성) ) { } ``` **설명:** - 자바에서는 `private` 변수에 대해 **Getter와 Setter를 명시적으로 정의**해야 함. - 코틀린에서는 `var`을 사용하면 **자동으로 Getter와 Setter가 생성됨**. - **외부에서 읽고 쓸 수 있음**. # 42강 : Getter와 Setter에 로직 추가 (가상 필드 활용) - [25 02 14, p 14039, 42강, Getter와 Setter에 로직 추가 (가상 필드 활용)](https://youtu.be/yo6A9ST4a5s) ## **자바 코드** ```java class Person { private String name = ""; // 실제 저장되는 필드 public Person(String name) { this.name = name; } public String getName() { // Getter (""일 경우 예외 발생) if (name.isEmpty()) { throw new IllegalStateException("이름이 설정되지 않았습니다."); } return name; } public void setName(String name) { // Setter ("" 방지) if (name.isEmpty()) { throw new IllegalArgumentException("이름은 비어 있을 수 없습니다."); } this.name = name; } } ``` ## **코틀린 코드** ```kotlin class Person( private var _name: String ) { var name: String get() { if (_name.isEmpty()) { throw IllegalStateException("이름이 설정되지 않았습니다.") } return _name } set(value) { require(value.isNotEmpty()) { "이름은 비어 있을 수 없습니다." } _name = value } } ``` **설명:** - 자바와 코틀린 모두 **`_name`을 실제 데이터 저장용 필드**로 사용하고, `name`을 **가상 필드처럼 만들어 Getter/Setter에 로직 추가**. - Getter에서 `_name`이 비어 있으면 **예외 발생**. - Setter에서 빈 문자열이 들어오지 못하도록 **검사 후 예외 발생**. - 코틀린에서는 `require(value.isNotEmpty())`를 활용하여 **더 간결한 코드 작성 가능**. # 43강 : **주 생성자 (Primary Constructor)** - [25 02 14, p 14039, 43강, 주 생성자 (Primary Constructor)](https://youtu.be/vtKgIEz_c94) **설명:** 코틀린에서는 **클래스 선언과 동시에 생성자 정의가 가능**하며, 이를 **주 생성자**라고 부름. `class 클래스명(매개변수: 타입) { }` 형식으로 선언함. ## **자바 코드** ```java class Person { private String name; private int age; // 생성자 public Person(String name, int age) { this.name = name; this.age = age; } public void introduce() { System.out.println("Hi, I'm " + name + " and I'm " + age + " years old."); } } ``` ## **코틀린 코드** ```kotlin class Person(val name: String, val age: Int) { fun introduce() { println("Hi, I'm $name and I'm $age years old.") } } fun main() { val person = Person("Alice", 25) person.introduce() } ``` ✅ **자바에서는 필드를 선언하고 생성자에서 초기화해야 하지만, 코틀린에서는 `val` 또는 `var`을 사용하여 바로 선언 가능** ✅ **`class Person(val name: String, val age: Int)`처럼 간결하게 표현 가능** ✅ **주 생성자는 `init` 블록 없이도 사용 가능** # 44강 : **주 생성자와 init 블록** - [25 02 14, p 14039, 44강, 주 생성자와 init 블록](https://youtu.be/SSNpKfFd1qc) **설명:** `init` 블록을 사용하면 **주 생성자가 호출될 때 실행할 코드** 를 정의할 수 있음. ## **자바 코드** ```java class Person { private String name; private int age; public Person(String name, int age) { this.name = name; this.age = age; System.out.println("Person 객체가 생성되었습니다: " + name + ", " + age); } } ``` ## **코틀린 코드** ```kotlin class Person(val name: String, val age: Int) { init { println("Person 객체가 생성되었습니다: $name, $age") } } fun main() { val person = Person("Alice", 25) } ``` ✅ **`init` 블록은 주 생성자 실행 직후 호출됨** ✅ **객체 초기화 로직을 `init` 블록에 작성 가능** ✅ **자바의 생성자 내부 `System.out.println()`과 같은 역할** # 45강 : **부 생성자 (Secondary Constructor)** - [25 02 14, p 14039, 45강, 부 생성자 (Secondary Constructor)](https://youtu.be/bBIVRzI4j-Q) **설명:** - 코틀린에서는 **부 생성자(Secondary Constructor)** 를 `constructor` 키워드로 선언 가능. - 주 생성자가 있는 경우, **반드시 `this`를 통해 주 생성자를 호출해야 함**. ## **자바 코드** ```java class Person { private String name; private int age; // 주 생성자 public Person(String name, int age) { this.name = name; this.age = age; } // 부 생성자 public Person(String name) { this(name, 0); // 다른 생성자 호출 } } ``` ## **코틀린 코드** ```kotlin class Person(val name: String, val age: Int) { constructor(name: String) : this(name, 0) // 주 생성자 호출 } fun main() { val person1 = Person("Alice", 25) val person2 = Person("Bob") // age는 기본값 0 } ``` ✅ **부 생성자는 `constructor` 키워드로 선언** ✅ **주 생성자가 존재하면 `this(…)`를 사용해 반드시 호출해야 함** ✅ **부 생성자를 이용해 다양한 방식으로 객체 초기화 가능** # 46강 : **주 생성자 + 부 생성자 조합** - [25 02 14, p 14039, 46강, 주 생성자 + 부 생성자 조합](https://youtu.be/lwonQceSUDY) **설명:** 주 생성자와 부 생성자를 함께 사용하여 **객체를 더 유연하게 생성할 수 있음**. ## **자바 코드** ```java class Person { private String name; private int age; private String country; public Person(String name, int age, String country) { this.name = name; this.age = age; this.country = country; } public Person(String name, int age) { this(name, age, "Unknown"); // 다른 생성자 호출 } public Person(String name) { this(name, 0); // 기본값 제공 } } ``` ## **코틀린 코드** ```kotlin class Person(val name: String, val age: Int, val country: String) { constructor(name: String, age: Int) : this(name, age, "Unknown") constructor(name: String) : this(name, 0) } fun main() { val p1 = Person("Alice", 25, "USA") val p2 = Person("Bob", 30) // country는 "Unknown" val p3 = Person("Charlie") // age와 country 기본값 사용 } ``` ✅ **부 생성자를 사용해 다양한 객체 초기화 방식 제공** ✅ **`this(...)`를 활용해 중복 코드 최소화** ✅ **각 부 생성자는 주 생성자로 연결됨** # 47강 : **생성자 정리 및 총정리** - [25 02 14, p 14039, 47강, 생성자 정리 및 총정리](https://youtu.be/7SYjugqSJ5w) | 생성자 유형 | 설명 | 사용 예제 | |------------|-----|---------| | 주 생성자 (Primary Constructor) | 클래스 선언과 동시에 정의되는 생성자 | `class Person(val name: String, val age: Int)` | | `init` 블록 | 주 생성자 실행 직후 초기화 코드 실행 | `init { println("객체 생성됨") }` | | 부 생성자 (Secondary Constructor) | `constructor` 키워드를 사용하여 추가 생성자 정의 | `constructor(name: String) : this(name, 0)` | | 주+부 생성자 조합 | 여러 생성자를 조합하여 유연한 객체 생성 | `constructor(name: String, age: Int) : this(name, age, "Unknown")` | --- # 48강 : **생성자에서 `require()`와 `check()` 활용** - [25 02 14, p 14039, 48강, 생성자에서 `require()`와 `check()` 활용](https://youtu.be/Pb9YIE8g-wU) **설명:** `require()`와 `check()`를 사용하면 **입력값 검증을 간결하게 처리 가능**. ## **코틀린 코드** ```kotlin class Person(val name: String, val age: Int) { init { require(age >= 0) { "나이는 0 이상이어야 합니다." } check(name.isNotEmpty()) { "이름은 비어 있을 수 없습니다." } } } fun main() { val person1 = Person("Alice", 25) // 정상 val person2 = Person("", 30) // 예외 발생: 이름이 비어 있음 val person3 = Person("Bob", -5) // 예외 발생: 나이가 0 미만 } ``` ✅ **`require()` → 입력값이 조건을 충족하지 않으면 `IllegalArgumentException` 발생** ✅ **`check()` → 내부 상태가 올바르지 않으면 `IllegalStateException` 발생** # 49강 : 게터/세터의 커스텀 - [25 02 19, p 14039, 49강, 게터/세터의 커스텀](https://youtu.be/8K1TxzbjCik) ```kt class PersonV1(var name: String, var age: Int) class PersonV2(var name: String, val age: Int) class PersonV3(var name: String, private val _age: Int) { val age: Int get() = _age + 1 } class PersonV4(var name: String, private var _age: Int) { var age: Int get() = _age + 1 set(value) { _age = value - 1 } } class PersonV5(var name: String, private var _age: Int) { init { _age -= 1 } var age: Int get() = _age + 1 set(value) { _age = value - 1 } } class PersonV6 private constructor(var name: String, private var _age: Int) { companion object { fun create(name: String, age: Int): PersonV6 { return PersonV6(name, age - 1) } } var age: Int get() = _age + 1 set(value) { _age = value - 1 } } class PersonV7 private constructor(var name: String, private val _age: Int) { companion object { fun create(name: String, age: Int): PersonV7 { return PersonV7(name, age - 1) } } val age: Int get() = _age + 1 } fun main() { // V1 : 나이에 대해서 getter, setter val personV1 = PersonV1("Alice", 29) println("personV1 나이 조회 : ${personV1.age}") // 29 personV1.age = 10 // personV1 나이 설정, 10살로 설정됨 // V2 : 나이에 대해서 getter, setter(x) val personV2 = PersonV2("Alice", 29) println("personV2 나이 조회 : ${personV2.age}") // 29 // personV2.age = 10 // Error // V3, V4, V5, V6, V7 은 만나이로 출력 // V3 : 나이에 대해서 getter(custom), setter(x) val personV3 = PersonV3("Alice", 29) println("personV3 나이 조회 : ${personV3.age}") // 30 // personV3.age = 10 // Error // V4, V5, V6, V7 한국나이로 만나이로 입/출력 // V4 : 나이에 대해서 getter(custom), setter(custom) val personV4 = PersonV4("Alice", 29) // 여기서는 만나이로 입력해야 함 println("personV3 나이 조회 : ${personV3.age}") // 30(만나이) personV4.age = 10 // personV4 나이 설정, 9살(만나이)로 설정됨 // V5 : 나이에 대해서 getter(custom), setter(custom) val personV5 = PersonV5("Alice", 30) // 여기서는 한국나이로 입력해도 됨 println("personV5 나이 조회 : ${personV5.age}") // 30(만나이) personV5.age = 10 // personV5 나이 설정, 9살(만나이)로 설정됨 // V6 : 나이에 대해서 getter(custom), setter(custom) val personV6 = PersonV6.create("Alice", 30) // 여기서는 한국나이로 입력해도 됨 println("personV6 나이 조회 : ${personV6.age}") // 30(만나이) personV6.age = 10 // personV6 나이 설정, 9살(만나이)로 설정됨 // V7 : 나이에 대해서 getter(custom), setter(x) val personV7 = PersonV7.create("Alice", 30) // 여기서는 한국나이로 입력해도 됨 println("personV7 나이 조회 : ${personV7.age}") // 30(만나이) // personV7.age = 10 // Error } ```