• Kotlin
• 프로그램 문법
• 기초
• 상수/변수
• 클래스
• 함수
• 조건문/반복문
• 오류 처리
• 주요 객체

Kotlin

Google은 2017년 Google I/O에서 Kotlin을 Android의 공식 언어로 지정 하였다.

Kotlin은 Java와 100% 호환되는 함수형 언어 이다.

• 홈페이지 : https://kotlinlang.org/

• 매뉴얼 : https://kotlinlang.org/docs/reference/

• 샘플 : https://developer.android.com/samples/index.html?language=kotlin&hl=ko

프로그램 문법

기초

// 한줄 주석

/*
여러줄 주석
*/

상수/변수

//--- 변수 타입
//---     문자형 : String
//---     정수형 : Int, Long
//---     실수형 : Double
//---     논리형 :
//---     null

val  상수명:타입  =  값
val  상수명  =  값
val  상수명  =  lazy {                   //--- 초기값을 천천히 계산하여 반환 한다.
    return ~
}

var  변수명:타입  =  값
var  변수명:타입?  =  값                  //--- null 허용
var  변수명  =  값
lateinit  var  ~:~

return 변수명?.함수()                     //--- null이면 null 반환, 아니면 함수 결과 반환
return 변수명?.함수() ?: ~                //--- null이면 ~ 반환
변수명?.let { ~ }                        //--- null이 아니면 { ~ } 실행

A as? B                                 //--- A를 B로 타입 변환. 실패시 null 반환
A as? B ?: return ~                     //--- A를 B로 타입 변환. 실패시 ~ 반환

변수명!!.~()                             //--- null인 경우, NPE(Null Point Exception)

//--- 변수 타입 확인
if (변수 is Int) { ~ }

//--- 문자열 확장
"~ ${변수명} ~"

//--- 날자, 시간
val  startTime  =  System.currentTimeMillis()
val  timeText  =  SimpleDateFormat("HH:mm:ss", Locale.KOREA).format(startTime)

val  timeFr  =  System.nanoTime()
val  timeTo  =  System.nanoTime()
println("소요 시간 : ${timeTo - timeFr}")

클래스

//--- Any : 최상위 클래스
//---     equals(~): Boolean, hashCode(): Int, , toString(): String
//--- Unit : void 역할
//--- Noting : 실행될 수 없는 표현식

//--- 클래스
//---     가시성 : public (디폴트), protected, private, internal
class 클래스명(val ~:~) {
    init {                              //--- 생성자
    }
    
    inner class ~ {	                    //--- 내부 클래스 선언
    }
}

val ~ = 클래스명()                       //--- 클래스에 해당하는 object 생성

//--- Singleton 클래스
object ~ {
}

class ~ {
    companion object {
        fun ~ {                         //--- 클래스명.함수명()으로 호출하여 사용
        }
    }
}

//--- 상속
//---     상속은 하나만 가능 하다.
//---     인터페이스의 경우, 여러개를 추가하여 상속이 가능 하다.
interface ~ {                           //--- 인터페이스
    //--- 생성자 없음. 값 초기화 불가
    fun ~(): String
}

interface ~ {                        //--- Generics
    fun ~(~: T)
}
~                               //--- 선언
typealias ~ = ~
typealias Machine = (T) -> Unit

abstract class ParentClass {            //--- 추상 클래스
    //--- Object를 생성할 수 없음
    abstract fun ~(): String            //--- 선언만 있는 함수
}

open class ParentClass {                //--- 상속을 허용하는 클래스
	//--- 하나만 상속 가능
    
    open fun ~():~ {
    }
    
    override fun ~():~ {
    }
}

class childClass: ParentClass, 추상클래스_또는_인터페이스 {
}

//--- 데이터 클래스 : 데이터를 저장
//---     equals(~): Boolean, hashCode(): Int, , toString(): String
//---     copy(~)
//---     val (~, _, ~) = 데이터_인스턴스  //--- _는 사용하지 않는 인수
data class ~ (~)

//--- 열거형 클래스 : 상수 값의 집합을 표현
enum class ~ {(
    AAA {
        override fun isObcon(): Boolean { ~ }
    },
    BBB { ~ },
    CCC { ~ };
    abstract fun isObcon(): Boolean
}

//--- Getter, Setter 정의
class 클래스명(val ~:~) {
    val ~:~ = ~                         //--- 상수 선언시 자동으로 get 함수 생성
    var ~:~ = ~                         //--- 변수 선언시 자동으로 get, set 함수 생성
        //--- get, set 함수 사용자 정의
    	get():String {
            return field
        }
    	set(value:String) {
            field = value
        }
    
    //--- get, set 함수 사용자 정의
    var text = ""
    operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
        return text
    }
    
    operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
        text = value
    }
}

//---     Class를 사용하여 get, set 함수 사용자 정의
class DelegateString(val ~:~) {
    var text = ""
    operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
        return text
    }
    
    operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
        text = value
    }
}

class ~ {
    var ~ by DelegateString()
}

//--- 변수의 값이 변경될 때마다 코드 실행
class 클래스명(val ~:~) {
    var ~:~ by Delegates.observable("") {
        property, oldValue, newValue -> {
            //--- 변수의 값이 변경될 때마다 호출됨
        }
    }
}

//--- Map과 object의 내부 변수 매핑
class ~(val map:MutableMap

@Tasty(false)
object MyClass {
}

val  annotations: List  =  MyClass::class.annotations
for (annotation in annotations) {
    when (annotation) {
        is Tasty -> {
            println("${annotatin.tasty}")
        }
        else -> { ~ }
    }
}

//--- 최상위 함수 : 같은 패키지의 모든 코드에서 전역적 접근이 가능한 함수
@file:JvmName("OBConUtilKt")            //--- Java에서 호출시 사용할 클래스 이름
package biz.obcon.android

fun 최상위_함수(~) {
}

//--- 일반 함수
fun 함수명(인수:타입 = 디폴트_값) {
    return ~
}

fun  ~(t: T, fn: (T) -> T): T {
    return fn(t)
}

fun ~(vararg params: Int) { ~ }         //--- 여러개의 인수를 params 변수에 모두 저장

tailrec fun 생략                         //--- 재귀함수에서 사용시 속도가 조금 빨라진다.

//--- Lambda 함수
val  sum  =  { x:Int, y:Int  ->  x + y }
sum(1, 3)

{  ()  ->  Unit  }                      //--- 전달 인수 없음. 반환 인수 없음

{  str  ->  str.substring(0..1)  }      //--- 아래 람다 선언과 동일
{  it.substring(0..1)  }                //--- it 예약어는 유일한 하나의 인수를 의미

val  capitalize  =  {  str:  String  ->  str.capitalize()  }
val  capitalize  =  object: Function1 {
    override  fun  invoke(p1: String): String {
        return  p1.capitalize()
    }
}

::함수명                                 //--- 함수의 참조를 전달하기 위해 사용
인스턴스::함수명                           //--- 인스턴스 함수의 참조를 전달

함수명(~, 람다_함수)                       //--- 마지막 인수가 람다 함수인 경우
함수명(~) { 람다_함수 }                    //--- 외부에 위치 시킬 수 있다.

//--- Collection 함수
filter { item -> item is Int }
find { item -> item is Int }
map { item -> "value: ${item}" }
groupBy { item -> item.javaClass }
flatmap { item -> item.toList() }

//--- 확장 함수
fun String.확장함수명():String {          //--- Java의 String 클래스에 함수 추가
    //--- this : String 객체를 지칭함
    return ~
}

//--- 조건문
if (~) {
} else if (~) {
} else {
}

when (~) {
    ~ -> { ~ }
    ~, ~ -> { ~ }
    in 1..4 -> { ~ }
    조건식 -> { ~ }
    else -> { ~ }
}

//--- 반복문
loop1@ for (i in 1..100) {
    continue
    break@loop1
}

loop2@ while (~) {
}

ppp

//--- List
val data: List = listof(1, 2, 3, 4)

for (item in data) { ~ }
data.forEach { item -> { ~ } }
data.map { item -> { ~ } }
data.fold(초기값) { total, item -> { ~ } }
data.reduce { total, item -> { ~ } }    //--- data의 첫번째 값을 초기값으로 사용
data.foldRight(초기값) { total, item -> { ~ } }
data.reduceRight { total, item -> { ~ } }    //--- data의 마지막 값을 초기값으로 사용

val data: MutableList = mutableListOf()

data.add(~)