Null v Null Check kt val data 1

Null 안전성 v Null. Check. kt val data 1: String = "cyberadam" val data 2: String? = null class Address { val city: String? ="seoul" } class User { val address: Address? = Address() } 3

Null 안전성 v Null. Check. kt fun main(args: Array<String>) { //null 허용 프로퍼티에 null 불허 프로퍼티 대입 가능 val data 3: String? = data 1 //null 불허 프로퍼티에 null 허용 프로퍼티를 대입하는 것은 에러 //val data 4: String=data 2//error //if문을 이용한 null 체크 val length 1: Int? = if(data 2 != null){ data 2. length } else { null } //? 연산자를 이용한 연산 var length 2: Int? = data 2? . length println(length 2) //null check chain ~~~~~~~~~~ val user: User? = User() println(user? . address? . city) 4

Null 안전성 v Null. Check. kt val array= array. Of("adam", null, "itggangpae") array. for. Each { if(it != null){ println("$it. . ${it. length}") } } array. for. Each { it? . let { println("$it. . ${it. length}") } } } 5

Null 안전성 v Null. Operation. kt fun main(args: Array<String>) { var data: String? ="adam" var length: Int = if(data != null){ data. length }else { -1 } //elvis operator를 이용한 작업 data=null length=data? . length ? : -1 println(length) data ? : println("data is null") data = "itggangpae" data!!. length data=null // data!!. length 7

Null 안전성 v Null. Operation. kt val str. Data : String = "adam" //val int. Data: Int = str. Data as Int //예외 발생 //안전한 캐스팅 val int. Data: Int? = str. Data as? Int println(int. Data) } 8

Exception Handling 9

Exception Handling v Exception. Handling. kt fun main(args: Array<String>) { try { println("try top. . . ") val data: String = "adam" val int. Data: Int? = data. to. Int() println("try bottom. . . ") }catch (e: Exception){ println("catch. . . ") }finally { println("finally. . ") } println("계속 수행") } 14

Exception Handling v Multi. Catch. kt fun main(args: Array<String>) { val array= array. Of("0", 1, "6") try { println("try top. . . ") val int. Data: Int= array[0] as Int val data: String = array[2] as String val data 2: Int = data. to. Int() }catch (e: Class. Cast. Exception){ println("catch. . . Class. Cast. Exception") }catch (e: Array. Index. Out. Of. Bounds. Exception){ println("catch. . . Array. Index. Out. Of. Bounds. Exception") }catch (e: Exception){ println("catch. . . Exception. . . ${e. to. String()}") } } 15

Exception Handling v User. Define. Exception. kt fun some(arg: Int): Int{ if(arg<1) throw Exception("매개변수는 0보다 크거나 같아야 합니다. ") else { var sum=0 for(i in 1. . arg){ sum += i } return sum } } class My. Exception(msg: String): Exception(msg){ val error. Data: String = "some error data" fun error. Fun(){ println("error. Fun call. . ") } } fun some 1(){ throw My. Exception("My Error. . . ") } 17

Exception Handling v User. Define. Exception. kt fun some 2() { val name: String? = null val s: String = name ? : throw Illegal. Argument. Exception("Name required") println("some 1 bottom") } fun some 3(arg: Int): Nothing { if(arg> 0) throw Exception("some 2 exception. . arg>0 true") else throw Exception("some 2 exception. . arg>0 false") } 18

Exception Handling v User. Define. Exception. kt fun main(args: Array<String>) { try { println("${some(5)}") println("${some(-1)}") println("main bottom. . ") }catch (e: Exception){ println("Exception. . ${e. to. String()}") } try { some 1() }catch (e: My. Exception){ println("error message : ${e. to. String()}") println("error data : ${e. error. Data}") e. error. Fun() } 19

Exception Handling v User. Define. Exception. kt try { some 2() }catch (e: Exception){ println(e. to. String()) } try { some 3(10) }catch (e: Exception){ println(e. to. String()) } } 20

Class Extension 21

클래스 확장 v Class. Extension. kt //상속을 통한 기능 확장 /* open class Super { val super. Data: Int = 10 fun super. Fun() { println("super. Fun. . ") } } class Sub: Super() { val sub. Data: Int = 20 fun sub. Fun() { println("sub. Fun. . ") } } fun main(args: Array<String>) { val obj: Sub = Sub() println("super. Data : ${obj. super. Data}, sub. Data : ${obj. sub. Data}") obj. super. Fun() obj. sub. Fun() } */ 23

클래스 확장 v Class. Extension. kt class Super. Ext { val super. Data: Int = 10 fun super. Fun() { println("super. Fun. . ") } } //Super. Ext 클래스에 메소드와 프로퍼티 추가 val Super. Ext. sub. Data: Int get() = 20 fun Super. Ext. sub. Fun() { println("sub. Fun. . . ") } fun main(args: Array<String>) { val obj: Super. Ext = Super. Ext() println("super. Data : ${obj. super. Data}, sub. Data : ${obj. sub. Data}") obj. super. Fun() obj. sub. Fun() } 24

클래스 확장 v Super. Error. kt open class Super 1{ val super. Data: Int = 10 fun super. Fun() { println("super. Fun. . ") } } class Sub 1: Super 1() { fun disp(){ println("출력") } } fun Sub 1. sub. Fun() { println("sub. Fun. . . ") disp() //super. Fun() //error } 25

클래스 확장 v Polymorphism. kt open class Super 2 class Sub 2 : Super 2() fun Super 2. say. Hello(){ println("Super. . say. Hello()") } fun Sub 2. say. Hello(){ println("Sub. . say. Hello()") } fun some(obj: Super 2){ obj. say. Hello() } fun main(args: Array<String>) { some(Sub 2()) } 26

클래스 확장 v Extension. Property. kt class Test { fun say. Hello(){ println("Test. . say. Hello()") } companion object { val data 1: Int = 10 fun my. Fun 1(){ println("companion object my. Fun 1(). . ") } } } //프로퍼티 확장 val Test. extension. Data: Int get() = 10 //동일한 메소드 사용 fun Test. say. Hello(){ println("Test extension. . say. Hello()") } fun Test. Companion. my. Fun 2() { println("extension my. Fun 2(). . ") } 28

클래스 확장 v Extension. Property. kt fun main(args: Array<String>) { val test=Test() println("extension. Data : ${test. extension. Data}") test. say. Hello() println("data 1 : ${Test. data 1}") Test. my. Fun 1() } 29

클래스 확장 v Extern. Extension. kt package chap 06 class Extern. Test { val data 1: Int = 10 } val Extern. Test. data 2 get() = 20 fun main(args: Array<String>) { val obj: Extern. Test = Extern. Test() println("data 2 : ${obj. data 2}") } 31

클래스 확장 v extern. Extension. Use. kt package extern import chap 06. Extern. Test import chap 06. data 2 fun main(args: Array<String>) { val obj: Extern. Test = Extern. Test() println("data 2 : ${obj. data 2}") } 32

클래스 확장 v Inner. Extension. Use. kt class Extension. Class { fun some 1() { println("Extension. Class some 1()") } fun my. Fun() { println("Extension. Class my. Fun()") } } class Dispatch. Class { fun my. Fun() { println("Dispatch. Class my. Fun()") } fun Extension. Class. some 2() { some 1() my. Fun() this@Dispatch. Class. my. Fun() } } 33

클래스 확장 v Inner. Extension. Use. kt fun main(args: Array<String>) { val obj: Extension. Class = Extension. Class() obj. some 1() //obj. some 2()//error } 34

Reflection 35

Reflection v Class. Reference. kt import kotlin. reflect. KClass val my. Val 1: KClass<*> = String: : class val my. Val 2: KClass<String> = String: : class //val my. Val 3: KClass<String> = Double: : class//error val my. Val 4: Class<*> = String: : class. java 37

Reflection v 클래스 정보 분석 ü val is. Abstract: Boolean : 클래스 Reference 가 abstract 로 선언되었는지 판단 ü val is. Companion: Boolean : 클래스 Reference 가 companion 로 선언되었는지 판단 ü val is. Data: Boolean : 클래스 Reference 가 data 로 선언되었는지 판단 ü val is. Final: Boolean : 클래스 Reference 가 final 로 선언되었는지 판단 ü val is. Inner: Boolean : 클래스 Reference 가 inner 로 선언되었는지 판단 ü val is. Open: Boolean : 클래스 Reference 가 open 로 선언되었는지 판단 ü val is. Sealed: Boolean : 클래스 Reference 가 sealed 로 선언되었는지 판단 v 생성자 정보 분석 ü val constructors: Collection<KFunction<T>> : 모든 생성자 정보 ü val <T : Any> KClass<T>. primary. Constructor: KFunction<T>? : 주생성자 정보 38

Reflection v Class. Information. kt import kotlin. reflect. KClass import kotlin. reflect. full. primary. Constructor open class My. Define. Class(no: Int) { constructor(no: Int, name: String): this(10){} constructor(no: Int, name: String, email: String): this(10){ } } fun class. Fun(arg: KClass<*>){ println("class info. . . ") println("is. Abstract : ${arg. is. Abstract}") println("is. Companion : ${arg. is. Companion}") println("is. Data : ${arg. is. Data}") println("is. Final : ${arg. is. Final}") println("is. Inner : ${arg. is. Inner}") println("is. Open : ${arg. is. Open}") println("is. Sealed : ${arg. is. Sealed}") } 39

Reflection v Class. Information. kt fun constructor. Fun(arg: KClass<*>){ print("primary constructor. . . ") val primary. Constructor=arg. primary. Constructor if(primary. Constructor != null){ val parameters = primary. Constructor. parameters for(parameter in parameters){ print("${parameter. name}: ${parameter. type}. . ") } } } fun main(args: Array<String>) { class. Fun(My. Define. Class : : class) constructor. Fun(My. Define. Class : : class) } 40

Reflection v 클래스 프로퍼티 분석 ü val <T : Any> KClass<T>. declared. Member. Properties: Collection<KProperty 1<T, *>> : 확 장 프로퍼티를 제 외한 클래스에 선언된 모든 프로퍼티 리턴 ü val <T : Any> KClass<T>. member. Properties: Collection<KProperty 1<T, *>> : 확장 프로 퍼티를 제외한 클래 스와 상위 클래스에 선언된 모든 프로퍼티 리턴 ü val <T : Any> KClass<T>. declared. Member. Extension. Properties: Collection<KProperty 2<T, *, *>> : 클래스에 선언된 확장 프로퍼티 리턴 ü val <T : Any> KClass<T>. member. Extension. Properties: Collection<KProperty 2<T, *, *>> : 상위 클래스 및 현 클래스의 확장 프로퍼티 리턴 v 클래스 함수 분석 ü val KClass<*>. declared. Member. Functions: Collection<KFunction<*>> : 확장 함수를 제외 한 클래스에 선언된 모든 함수 리턴 ü val KClass<*>. member. Functions: Collection<KFunction<*>> : 확장 함수를 제외한 클래 스와 상위 클래스에 선언된 모든 함수 리턴 ü val KClass<*>. declared. Member. Extension. Functions: Collection<KFunction<*>> : 클래스 에 선언된 확장 함수 리턴 ü val KClass<*>. member. Extension. Functions: Collection<KFunction<*>> : 상위 클래스 및 현 클래스의 확장 함수 리턴 41

Reflection v Class. Funtion. Information. kt import kotlin. reflect. KClass import kotlin. reflect. full. declared. Member. Extension. Functions import kotlin. reflect. full. declared. Member. Functions import kotlin. reflect. full. member. Functions open class Super. Class { fun super. Fun(){ } } class Sub. Class: Super. Class() { fun my. Fun() { } fun String. some. Fun() { } } 42

Reflection v Class. Funtion. Information. kt function. Fun(arg: KClass<*>){ println("declared. Member. Functions. . ") val functions = arg. declared. Member. Functions for(function in functions){ println("${function. name}: ${function. return. Type} ") } println("member. Functions. . . ") val functions 2 = arg. member. Functions for(function in functions 2){ println("${function. name}: ${function. return. Type} ") } println("declared. Member. Extension. Functions. . . ") val functions 3 = arg. declared. Member. Extension. Functions for(function in functions 3){ println("${function. name}: ${function. return. Type} ") } } fun main(args: Array<String>) { function. Fun(Sub. Class: : class) } 43

Reflection v Funtion. Information. kt import kotlin. reflect. KFunction fun my. Define. Fun(no: Int, name: String): Boolean { return true } fun reflection. Fun(arg. Fun: KFunction<*>) { print("${arg. Fun. name}") val parameters = arg. Fun. parameters print("(") for (parameter in parameters) { print("${parameter. name}: ${parameter. type} ") if (parameter. index < parameters. size - 1) print(", ") } print("): ") print("${arg. Fun. return. Type}") } fun main(args: Array<String>) { reflection. Fun(: : my. Define. Fun) } 45

Reflection v Property. Information. kt import kotlin. reflect. KMutable. Property import kotlin. reflect. KProperty val my. Val: Int = 3 var my. Var: Int = 5 class Property. Class { val obj. Val: Int = 10 var obj. Var: Int = 20 } fun reflection. Property(obj: Any? , arg: KProperty<*>){ println("property name: ${arg. name}, property type: ${arg. return. Type}") if(obj != null){ println(arg. getter. call(obj)) }else { println(arg. getter. call()) } } 47

Reflection v Property. Information. kt fun reflection. Mutable. Property(obj: Any? , arg: KMutable. Property<*>){ println("property name: ${arg. name}, property type: ${arg. return. Type}") if(obj != null){ arg. setter. call( obj, 40) println(arg. getter. call(obj)) }else { arg. setter. call( 40) println(arg. getter. call()) } } fun main(args: Array<String>) { reflection. Property(null, : : my. Val) reflection. Mutable. Property(null, : : my. Var) val obj: Property. Class = Property. Class() reflection. Property(obj, Property. Class: : obj. Val) reflection. Mutable. Property(obj, Property. Class: : obj. Var) } 48

Annotation 49

Annotation v Annotation. Create. kt //어노테이션 생성 annotation class Test. Annotation class Test. Class{ //어노테이션 설정 @Test. Annotation fun my. Fun 1() { } fun my. Fun 2() { } } fun main(args: Array<String>) { val methods = Test. Class: : class. java!!. methods for(method in methods){ val method. Name = method. name //어노테이션이 있는 메소드만 출력 if(method. is. Annotation. Present(Test. Annotation: : class. java)){ println("$method. Name function has Test. Annotation annotation. . . ") } } } 51

Annotation ü Annotation. Property. kt annotation class Property. Annotation(val count: Int) class Property. Annotation. Class { @Property. Annotation(count=3) fun some(){ println("some. . . ") } } fun main(args: Array<String>) { val obj: Property. Annotation. Class = Property. Annotation. Class() val methods = Test: : class. java!!. methods for(method in methods){ if(method. is. Annotation. Present(Property. Annotation: : class. java)){ val annotation=method. get. Annotation(Property. Annotation: : class. java) val count = annotation. count for(i in 1. . count){ obj. some() } } 53

Annotation v Annotation ü 추가 대상 설정 l file : 클래스 파일 명 변경 l property (annotations with this target are not visible to Java): 자바에서는 추가되지 않음 l field: 변수에 어노테이션 추가 l get (property getter): getter에 어노테이션 추가 l set (property setter): setter에 어노테이션 추가 l receiver (receiver parameter of an extension function or property): 확장 함수나 프 로퍼티에 추가 l param (constructor parameter): 생성자의 매개변수에 추가 l setparam (property setter parameter): setter 함수의 매개변수에 추가 54

Annotation ü Annotation. Option. kt @file: Jvm. Name("My. Test") annotation class Test. Annotation 1 annotation class Test. Annotation 2 class Test. Option constructor(@param: Test. Annotation 1 var email: String){ @get: [Test. Annotation 1 Test. Annotation 2] var no: Int=10 @property: Test. Annotation 1 var name: String = "adam" @field: Test. Annotation 1 var age: Int = 30 @setparam: Test. Annotation 1 var phone: String= "01037901997" } fun @receiver: Test. Annotation 1 Test. Option. my. Fun(){ } 55

Annotation ü Java 클래스 annotation class Test. Annotation 1 annotation class Test. Annotation 2 class Test. Option constructor(@param: Test. Annotation 1 var email: String){ @get: [Test. Annotation 1 Test. Annotation 2] var no: Int=10 @property: Test. Annotation 1 var name: String = "adam" @field: Test. Annotation 1 var age: Int = 30 @setparam: Test. Annotation 1 var phone: String= "01037901997" } fun @receiver: Test. Annotation 1 Test. Option. my. Fun(){ } 56

Thread 57

Thread ü Thread. Use. kt //Thread 클래스를 상속받아 구현하기 class Thread. Ex: Thread() { override fun run() { for(i in 0. . 9){ Thread. sleep(1000) println("Thread 클래스를 이용한 구현") } } } // Runnable 인터페이스로부터 run() 구현하기 class Runnable. Impl: Runnable { override fun run() { for(i in 0. . 9){ Thread. sleep(1000) println("Runnable 인터페이스를 이용한 구현") } } } 59

Thread ü Thread. Use. kt fun main() { val thread. Ex = Thread. Ex() thread. Ex. start() val runnable. Impl = Runnable. Impl() val th = Thread(runnable. Impl) th. start() //익명 객체를 이용한 스레드의 실행 object : Thread() { override fun run() { for(i in 0. . 9){ Thread. sleep(1000) println("Annonymous Class를 이용한 구현") } } }. start() 60

Thread ü Thread. Use. kt // 람다식을 이용한 스레드의 생성 Thread({ for(i in 0. . 9){ Thread. sleep(1000) println("람다를 이용한 구현") } }). start() } 61

Delegation v Legacy. Delegate. kt class My. Delegatee { fun print(str: String){ println("i am delegatee : $str") } } class My. Delegator { val delegatee: My. Delegatee = My. Delegatee() fun print(str: String){ delegatee. print(str) } } fun main(args: Array<String>) { val obj: My. Delegator = My. Delegator() obj. print("Hello Delegate") } 65

Delegation v Kotlin. Delegate. kt interface Print { fun print(arg: String) } class Kotlin. Delegatee: Print { override fun print(arg: String) { println("i am delegatee : $arg") } } class Kotlin. Delegator(obj: Kotlin. Delegatee): Print by obj fun main(args: Array<String>) { val obj: Kotlin. Delegatee = Kotlin. Delegatee() Kotlin. Delegator(obj). print("Hello Delegate") } 67

SAM v SAMTest. java interface Java. Interface 1 { void callback(); } public class SAMTest { public Java. Interface 1 callback; public void set. Interface(Java. Interface 1 callback){ this. callback=callback; } } 69

SAM v SAMTest. kt fun main(args: Array<String>) { val obj=SAMTest() obj. set. Interface(object : Java. Interface 1{ override fun callback() { println("hello kotlin") } }) obj. callback() obj. set. Interface { println("hello sam") } obj. callback() } 70

Type. Alias v Type. Alias. kt typealias My. Int = Int MList<T> = Mutable. List<T> MC = My. Class MI = My. Interface interface My. Interface class My. Class: MI typealias My. Type = (Int) -> Boolean val my. Fun: My. Type = { it > 10 } class Super { inner class Sub fun get. Sub. Insance(): My. Sub { return Sub() } } typealias My. Sub = Super. Sub 72

Type. Alias v Type. Alias. kt fun main(args: Array<String>) { val no: My. Int = 10 val list: MList<String> = mutable. List. Of("Hello", "Adam") val obj: MC = MC() } 73