이전
다음

Kotlin




프로그램 문법


기초

// 한줄 주석

/*
여러줄 주석
*/

상수/변수

//--- 변수 타입
//---     문자형 : 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 assertEquals(객체1, 객체2) assertEquals(객체1.hashCode(), 객체2.hashCode()) } } //--- Android Test 클래스 : 안드로이드에서 테스크 코드가 실행됨 import androidx.test.platform.app.InstrumentationRegistry import androidx.test.ext.junit.runners.AndroidJUnit4 import org.junit.Test import org.junit.runner.RunWith import org.junit.Assert.* @RunWith(AndroidJUnit4::class) class ~Test { @Test fun useAppContext() { val appContext = InstrumentationRegistry.getInstrumentation().targetContext } }

class의 annotation 사용

  • kotlinreflect.jar 필요
@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(~)


Last modified, 2020.01.26 ~ 2020.01.27, version 0.02

이전
다음
공유하기