# 1강 - [코틀린 개발환경 세팅](https://www.youtube.com/watch?v=E7svPkcxXxY) # 2강 - [25 03 19, p14329, 2강, 변수 선언과 기본 출력](https://www.youtube.com/watch?v=Y2RVfzv1dWc) ## 자바 코드 ```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 var message = "Hello, Java!" println("Number: ${number}") println("Message: ${message}") } ``` # 3강 - [25 03 19, p 14329, 3강, 조건문 if else](https://www.youtube.com/watch?v=Ltth14H8Qs0) ## 자바 코드 ```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 = 10 val str = if(number % 2 == 0) "Even" else "Odd" println(str) when{ number % 2 == 0 -> println("Even") number % 2 != 0 -> println("Odd") } } ``` # 4강 - [반복문 for](https://www.youtube.com/watch?v=985yclFt4Sw) ## 자바 코드 ```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(args: Array) { for(i in 0 until 5) { println("Count: ${i}") } for(i in 0 .. 4) { println("Count: ${i}") } } ``` # 5강 - [25 03 19, p14329, 5강, 함수 선언과 호출](https://www.youtube.com/watch?v=co2m_xEQQgc) ## 자바 코드 ```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 } ``` # 6강 - [25 03 19, p14329, 6강, 클래스와 객체](https://www.youtube.com/watch?v=l8oHGPPQVq4) ## 자바 코드 ```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() } ``` # 7강 - [25 03 19, p14329, 7강, 리스트List 사용](https://www.youtube.com/watch?v=m1danznChvQ) ## 자바 코드 ```java 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") val names = mutableListOf("Alice", "Bob", "Charlie") names.add("Daniel") for (name in names) { println(name) } } ``` # 8강 - [25 03 19, p14329, 8강, 맵Map 사용](https://www.youtube.com/watch?v=h7VL1kDBDXs) ## 자바 코드 ```java 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 = mutableMapOf("Peter" to 24, "Clark" to 31, "Bruce" to 32) ages.put("Barry", 25) for ((key, value) in ages) { println("$key is $value years old.") } } ``` # 9강 - [25 03 19, p14329, 9강, 널null 처리](https://www.youtube.com/watch?v=DpRlxjR6pjM) ## 자바 코드 ```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 println(name?.length ?: "Name is null") // val person = Person() // if ( person?.leftArm?.hand?.grab()) } ``` # 10강 - [25 03 19, p14329, 10강, 람다 표현식](https://www.youtube.com/watch?v=8ZoTKznm7wI) ## 자바 코드 ```java 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 {name -> println(name)} // 매개변수 표현 names.forEach {println(it)} // 매개변수 it으로 대체 } ``` # 11강 - [25 03 19, p14329, 11강, 데이터 클래스 Data Class](https://www.youtube.com/watch?v=cO1PROc5Kpo) ## 자바 코드 ```java 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 // 자바의 record와 유사 data class Person( val name: String, val age: Int ) {} fun main() { val p1 = Person("Alice", 29) val p2 = Person("Alice", 29) println(p1) // 자동 생성된 toString() 메서드 사용 println(p1 == p2) // 자동 생성된 equals() 메서드 사용. ==로 사용해도 된다. } ``` # 12강 - [25 03 19, p14329, 12강, 확장 함수](https://www.youtube.com/watch?v=VjstkOvYdGk) ## 자바 코드 ```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 // String 클래스에 greet 확장 함수 추가 fun String.greet() { println("hello, $this ~!") } // Int List 클래스에 square 확장 함수 추가 fun List.square(): List { val rst = this.map { it * it } return rst } fun main() { val name: String = "Alice" name.greet() // hello, Alice ~! val intList = listOf(1, 2, 3, 4, 5) val rst = intList.average() println(rst) val squaredIntList = intList.square() println("===========================") squaredIntList.forEach(::println) } ``` # 13강 - [25 03 19, p14329, 13강, 기본 매개변수](https://www.youtube.com/watch?v=juwIt0tV8KY) ## 자바 코드 ```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") } ``` # 14강 : 객체 싱글톤 (Singleton) - [25 03 20, p14329, 14강, 객체 싱글톤 (Singleton)](https://www.youtube.com/watch?v=GM8r1RW4UPA) ## 자바 코드 ```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 class Test { } object Singleton { fun showMessage() { println("Hello, World!") } } fun main() { val a = Singleton val b = Singleton println(a == b) // Singleton 이므로 항상 같은 인스턴스가 반환됨. val t1 = Test() val t2 = Test() println(t1 == t2) // 객체 생성마다 새로운 인스턴스가 생성되므로 서로 다른 인스턴스임. } ``` # 15강 : 문자열 템플릿 - [25 03 20, p14329, 15강, 문자열 템플릿](https://www.youtube.com/watch?v=AAobdimJY5Y) ## 자바 코드 ```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("안녕하세요 저는 ${name.length}입니다. 나이는 ${age}살입니다.") } ``` # 16강 : 예외 처리 - [25 03 20, p14329, 16강, 예외 처리](https://www.youtube.com/watch?v=WotKod2whyE) ## 자바 코드 ```java 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 fun main() { Files.copy(File("a.txt").toPath(), File("a_copy.txt").toPath(), StandardCopyOption.REPLACE_EXISTING) } ``` # 17강 : 컬렉션 필터링 - [25 03 20, p14329, 17강, 컬렉션 필터링](https://www.youtube.com/watch?v=VhW9131FKrY) ## 자바 코드 ```java 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 rst = numbers.filter { it % 2 == 0 } for (n in rst) { println(n) } } ``` # 18강: forEach와 map - [25 03 20, p14329, 18강, forEach와 map ](https://www.youtube.com/watch?v=y8w1KcC6iEw) ## 자바 코드 ```java 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") names.map { "Hello, $it" } .forEach(::println) } ``` # 19강 : 엘비스 연산자(?:) - [25 03 20, p14329, 19강, 엘비스 연산자(?:)](https://www.youtube.com/watch?v=qj3cTwlMdY8) ## 자바 코드 ```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: String = name ?: "Guest" println(displayName) } ``` # 20강 : 타입 체크와 캐스팅 (is vs instanceof) - [25 03 20, p14329, 20강, 타입 체크와 캐스팅 (is vs instanceof)](https://www.youtube.com/watch?v=OB57Z9RcngQ) ## 자바 코드 ```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) } } ``` # 21강 : 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(); } } ``` ## 코틀린 코드 # 22강 : apply - [25 03 20, p14329, 22강, apply](https://www.youtube.com/watch?v=beRVbE-6VAI) ## 자바 코드 ```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 fun main() { val person1 = Person() person1.name = "Alice" person1.age = 25 person1.printInfo() val person2 = Person().apply { name = "Alice" age = 25 } person2.printInfo() } ``` # 23강 : let - [25 03 20, p14329, 23강, let](https://www.youtube.com/watch?v=IaLatSY47YY) ## 자바 코드 ```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? = "hello" val len = name?.length ?: 0 println(len) val rst = name?.let { println(it.length) 10 } println(rst) } ``` # 24강 : also - [25 03 20, p14329, 24강, also](https://www.youtube.com/watch?v=l3Nk8nyWy8s) ## 자바 코드 ```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 length = "Hello".also { println("Before: $it") }.uppercase().also { println("After: $it") }.length println("Length: $length") // apply => this를 받고 객체를 반환 // let => it을 받고 람다의 결과값 반환 // also => it을 받고 객체를 반환 } ``` # 25강 : run - [25 03 20, p14329, 25강, run](https://www.youtube.com/watch?v=tcwV3c4DPNc) ## 자바 코드 ```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 num = 5 // apply => this를 받고 객체를 반환 // let => it을 받고 람다의 결과값 반환 // also => it을 받고 객체를 반환 // run => this를 받고 람다 값을 반환 val rst = num.run { this * 2 + 10 } println(rst) } ``` # 26강 : with ## 자바 코드 ```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( var name: String, var age: Int, var weight: Double, var salary: Int ) { fun increaseAge(years: Int) { age += years } fun increaseWeight(kg: Double) { weight += kg } fun increaseSalary(amount: Int) { salary += amount } fun getInfo() { println("이름: $name, 나이: $age, 몸무게: $weight, 연봉: $salary") } } fun main() { val p1 = Person("Alice", 25, 55.5, 3000) with(p1) { increaseAge(5) increaseWeight(3.5) increaseSalary(10000) } p1.getInfo() } ``` # 27강 : 스코프 함수 사용 예제 - [25 03 20, p14329, 27강, 스코프 함수 사용 예제](https://www.youtube.com/watch?v=x5SagWkpTwY) ## 스코프 함수 비교 표 | 함수 | 리턴값 | 컨텍스트(this or it) | 사용 목적 | |--------|--------|-------------------|-----------| | apply | 객체 자체 | this | 객체 설정 (초기화, 프로퍼티 변경) | | let | 람다 결과값 | it | 안전 호출과 변환 (Nullable 처리, 새로운 값 반환) | | also | 객체 자체 | it | 객체 유지 + 추가 로직 수행 (디버깅, 로깅) | | run | 람다 결과값 | this | 객체 설정 + 결과 반환 (객체 없이 블록 실행도 가능) | | with | 람다 결과값 | this | 객체를 컨텍스트로 작업 수행 후 결과 반환 | ## 코틀린 코드 ```kotlin class Person { var name: String = "" var age: Int = 0 } fun main() { val p1 = Person() p1.apply { name = "Alice" age = 25 }.also { println("이름: ${it.name}, 나이: ${it.age} 으로 생성됨") }.let { it.name.length }.run { this * 2 }.also { println("이름 길이의 2배: $it") } val rst = with(p1) { "${age}살 ${name}님 환영합니다." } println(rst) } ``` # 28강 : lateinit - 나중에 초기화하는 변수 - [25 03 20, p14329, 28강, lateinit - 나중에 초기화하는 변수](https://www.youtube.com/watch?v=9V3xdq0W6cQ) ## 자바 코드 ```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 // 나중에 초기화 할 수 있기 때문에 not null 유지 } fun main() { val example = Example() example.value = "hi" println(example.value.length) // 만약 초기화 되지 않았다면, UninitializedPropertyAccessException 발생 } ``` # 29강 : lazy - 최초 접근 시 초기화 (Lazy Initialization) ## 자바 코드 ```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" } fun main() { println(lazyValue) println(lazyValue) } ``` # 30강 : 동반 객체 (companion object) - 정적 멤버 - [25 03 20, p14329, 30강, 동반 객체 (companion object) - 정적 멤버](https://www.youtube.com/watch?v=17r_Y1DFrp4) ## 자바 코드 ```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 MathUtil { companion object { val PI = 3.141569 fun square(n: Int): Int { return n * n } } } fun main() { MathUtil.square(5).also { println(it) } MathUtil.PI.also { println(it) } } ``` # 31강 : open 키워드 (클래스 & 메서드 상속 허용) - [25 03 20, p14329, 31강, open 키워드 (클래스 & 메서드 상속 허용)](https://www.youtube.com/watch?v=CeYStxDNR9k) ## 자바 코드 ```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 class Animal { // 재정의 가능 open fun makeSound() { println("Animal makes a sound") } // 재정의 불가 fun move() { println("Animal move") } } class Dog : Animal() { override fun makeSound() { println("Dog barks") } } fun main() { val animal: Animal = Dog() animal.makeSound() } ``` # 32강 : 인터페이스 - [25 03 20, p14329, 32강, 인터페이스](https://www.youtube.com/watch?v=31TKVuRuUhw) ```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 eat() } interface Pet { fun play() } class Dog : Animal, Pet { override fun eat() { TODO("Not yet implemented") } override fun play() { TODO("Not yet implemented") } } fun main() { } ``` # 33강 : private val - [25 03 20, p14329, 33강, private val](https://www.youtube.com/watch?v=ap_sMX82ySk) ## 자바 코드 ```java class Person { private String name = "Unknown"; // private 변수 public String getName() { // Getter 제공 (읽기 가능, 변경 불가) return name; } } ``` ## 코틀린 코드 ```kotlin // 필드의 수정은 막되 접근은 가능하게 하고 싶을 때 => 굳이 private 사용 X class Person( val name: String = "" ) { } fun main() { val p = Person("Alice") println(p.name) } ``` # 34강 : Setter만 있는 경우 (Getter 호출 시 예외 발생) - [25 03 20, p14329, 34강, Setter만 있는 경우 (Getter 호출 시 예외 발생)](https://www.youtube.com/watch?v=06krsitAGBU) ## 자바 코드 ```java class Person { private String name = "Unknown"; // private 변수 public void setName(String name) { // Setter 제공 (쓰기 가능, 읽기 불가) this.name = name; } } ``` ## 코틀린 코드 ```kotlin class Person { private var _name: String = "" var name: String get() = throw IllegalAccessException("Can't access") set(value) { _name = value } } fun main() { val p = Person() p.name = "Bob" println(p.name) } ``` # 35강 : 커스텀 게터/세터 - [25 03 20, p14329, 35강, 커스텀 게터/세터](https://www.youtube.com/watch?v=Gv_N2kRsGKs) ## 자바 코드 ```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 ``` # 36강 : 주 생성자와 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) } ```