반응형

코틀린(Kotlin)도 다른 언어와 동일하게 함수를 사용할 수 있습니다.

코틀린에 가장 큰 함수 특징은 일급 객체로 사용이 가능합니다.

일급 객체는 일반적인 함수 형식과  엔티티로 적용하여 변수로 바로 사용이 가능하다.

함수 기본 형식은 (함수명) -> 반환 형식으로 되어 있습니다.

fun MakeString(mes : String): String{
    return mes + "  Create Message"
}

MakeString 함수는 mes String 매개변수를 받아서 String으로 반환합니다.

println(MakeString("함수 사용"))

println 함수를 사용해서 출력합니다.

출력 결과 입력된 "함수 사용" 뒤에 메시지가 추가되었습니다.

일반적인 함수는 함수를 만들어서 호출할 수 있습니다.

코틀린(Kotlin) 함수는 이런 함수를 변수 처럼 정의할 수 있습니다.

var MString:(String) -> String = fun(mes:String) = mes + " Create Message 2"

변수 MString에 함수를 직접 선언할 수 있습니다.

    println(MakeString("함수 사용"))

    println(MString("변수 함수 사용"))

MakeString 함수와 MString 변수를 출력 했습니다.

출력 결과 동일하게 입력 String에 추가 내용이 포함되어 있습니다.

함수에 사용되는 매개변수를 다양하게 사용이 가능합니다.

    var MString:(String) -> String = fun(mes:String) = mes + " Create Message 2"

    var a:(Int) -> Int = fun(i:Int) = i * 10

    println(a(7).toString())

    println(MakeString("함수 사용"))

    println(MString("변수 함수 사용"))

Int를 사용해서 추가 함수 a를 선언했습니다.

기존과 동일하게 println 함수를 사용해서 출력했습니다.

a 함수는 입력 변수에 10을 곱하는 형태로 7을 입력 시 70을 반환했습니다.

코틀린 함수는 매개변수 형식과 반환 형식을 자유롭게 사용할 수 있어 문법이 매우 편리합니다.

또한 외부 함수 정의가 아닌 내부에 함수를 정의를 사용할 수 있어 객체에 대한 처리를 완벽하게 수용할 수 있습니다.

내부 함수 정의 후 모호하다면 invoke() 메서드를 사용해서 모호함을 해결할 수 있다.

감사합니다.

반응형
반응형

코틀린이나 자바로 클래스를 정의할 경우 클래스 내부에 클래스를 다시 정의해야 하는 경우가 있습니다.

코틀린은 자바와 동일하게 최상위 클래스 내부에 클래스를 다시 배치할 수 있는 중첩 클래스(neted class)를 지원합니다.

중첩 클래스(neted class)

class nested{
    private val value:Int = 0

    class In{
        fun foo() = 7
    }
}

클래스 내부에 함수를 다른 클래스에 정의해서 접근할 수 있습니다.

nested class 내부에 In class를 정의하고 foo 메서드를 사용해서 멤버에 접근이 가능합니다.

nested.In().foo() 메서드를 사용해서 멤버 정보를 출력할 수 있습니다.

출력 결과 멤버에 저장된 7을 출력하게 됩니다.

중첩 클래스(neted class)에서 최상위 클래스에 정의된 인스턴스 변수나 메서드에 직접 접근이 불가능합니다.

중첩된 내부 클래스를 사용해서 객체 참조가 가능합니다.

class nested{
    private val value:Int = 0

    class In{
        fun foo() = 7
    }

    inner class innerIn{
        fun foo2() = 20
    }
}

코틀린(Kotlin) 중첩 클래스(neted class)에서 내부 클래스를 직접 접근하기 위해서는 inner 한정자를 사용해서 클래스를 정의하면 됩니다.

innerIn class는 inner로 정의 되었기 때문에 직접 foo2 메서드에 접근이 가능합니다.

nested를 선언하고 innerIn class에 직접 접근할 수 있습니다.

출력 결과 foo2 메서드에서 설정한 20을 확인할 수 있습니다.

중첩 클래스(neted class)는 내부 클래스를 직접 참조하거나, 간접적으로 참조할 수 있는 구조로 정의가 가능합니다.

Outer 클래스의 인스턴스를 먼저 만들어서 Inner 클래스를 접근하게 되면 모든 Outer 클래스를 멤버를 참조할 수 있어 하나의 인스턴스처럼 사용이 가능합니다.

감사합니다.

 

 

반응형
반응형

코틀린에서는 선언된 모든 하위 클래스를 확인할 수 있는 봉인 클래스(Sealed Class)가 있습니다.

봉인 클래스를 사용하면 상속 계층을 보호하면서 클래스를 정의할 수 있습니다.

봉인 클래스(Sealed Class)는 코틀린 1.1 이전 버전에서는 봉인 클래스를 내부에 정의했지만 1.1 버전부터는

봉인 클래스가 있는 파일 안에서 하위 클래스를 정의할 수 있게 되었습니다.

봉인 클래스가 하위에 정의되기 때문에 모든 하위 클래스를 한눈에 확인할 수 있습니다.

 

봉인 클래스(Sealed Class)

sealed class Mammal(val name:String)
class Cat(val catName: String) : Mammal(catName)
class Dog(val dogName:String) : Mammal(dogName)
class Human(val humanName:String, val job: String) : Mammal(humanName)

봉인 클래스(Sealed Class)를 선언하기 위해서는 sealed 한정자를 사용해서 선언하면 됩니다.

하위 클래스는 Mammal을 상속받아 접근이 가능합니다.

즉, 하위 클래스만 확장이 가능하고 개방이 안될 경우 다른 파일에서 사용이 불가능합니다.

개방은 조금 아래에서 확인해보겠습니다.

    fun greetMammal( mammal: Mammal) : String{
        when(mammal){
            is Cat -> return "안녕 고양이 ${mammal.name}"
            is Dog -> return "안녕 강아지 ${mammal.name}"
            is Human -> return "안녕 ${mammal.name} == 직업은 ${mammal.job}"
        }
    }
    
    Log.d(TAG,"-------- Sealed Classes ---------")

    Log.d(TAG, greetMammal(Cat("야옹이")))
        
    Log.d(TAG,"-------- Sealed END ---------")

greetMammal 함수를 사용해서 선언한 클래스를 when 제어문을 사용해서 확인할 수 있습니다.

Logcat View에서 봉인 클래스(Sealed Class) 출력 정보를 확인할 수 있습니다.

sealed class Mammal(val name:String)
class Cat(val catName: String) : Mammal(catName)
class Dog(val dogName:String) : Mammal(dogName)
class Human(val humanName:String, val job: String) : Mammal(humanName)

class Dog2: Cat("ddd")

봉인 클래스(Sealed Class)를 상속받은 클래스를 일반 클래스에서 상속받게 되면 봉인되어 있어 상속이 불가능합니다.

class Dog2에서 Cat class를 상속받으면 에러가 발생하는 것을 확인할 수 있습니다.

sealed class Mammal(val name:String)
open class Cat(val catName: String) : Mammal(catName)
class Dog(val dogName:String) : Mammal(dogName)
class Human(val humanName:String, val job: String) : Mammal(humanName)

class Dog2: Cat("ddd")

코틀린(Kotlin) 봉인 클래스(Sealed Class)를 다른 파일에서 사용하기 위해서는 open 한정자를 사용해서 개방을 해야 합니다.

Cat class를 개방하면 오류 없이 정상적으로 컴파일됩니다.

 

봉인 클래스(Sealed Class) 적용 사례

코틀린(Kotlin) 봉인 클래스(Sealed Class)는 상속 계층을 보호하는 기능이 가장 큰 특징이지만

링크 리스트나 이진트리 같은 데이터 형식 정의에 적용하면 데이터 상속에 따른 오류를 최소화할 수 있습니다.

또한 특정 클래스를 확장하지 못하게 하면서 특정 모듈에 API를 보호하면서 개발할 수 있습니다.

감사합니다.

play.kotlinlang.org/byExample/03_special_classes/03_Sealed%20Classes

 

Kotlin Playground: Edit, Run, Share Kotlin Code Online

 

play.kotlinlang.org

 

반응형
반응형

코틀린에서 개발 시 상수를 열거해야 하는 경우가 있습니다.

코틀린이나 JAVA에서는 상수를 열거하기 위해서

열거형 클래스(Enum Class)를 사용할 수 있습니다.

열거형 클래스(Enum Class) 사용하면 상수를 집합으로 관리할 수 있어 코드에 가독성이 높아집니다.

코틀린 열거형 클래스(Enum Class) 사용하기 위해서는 "enum class"로 선언됩니다.

순차적으로 적용되기 때문에 원하는 상수를 입력하면 됩니다.

enum class State{
    IDLE,
    RUNNING,
    FINISHED
}

fun enumprint(){
      val selecteditem = State.valueOf("IDLE")
      Log.d(TAG, (selecteditem == State.RUNNING).toString())
}

코틀린 열거형 클래스(Enum Class)는 자바와 동일하게 vlaueOf 메소드를 사용해서 열거형을 확인할 수 있습니다.

코드 실행 결과 "selecteditem"에 저장된 "IDLE" 열거형과 "State.RUNNING" 열거형이 다른 것을 확인할 수 있습니다.

상수 집합을 간단하게 사용할 수 있어 열거형 클래스(Enum Class)는 다양한 데이터 집합에 꼭 필요한 요소입니다.

    fun enumprint2()
    {
        for( state in State.values()){
            Log.d(TAG, "${state.name} == ${state.ordinal}")
        }
    }

열거형 클래스(Enum Class) 일반적으로 "values" 메소드를 사용해서 전체 열거형을 확인할 수 있습니다.

"name", "ordinal"을 사용해서 이름과 선언 값을 확인할 수 있습니다.

출력 결과 순차적으로 출력된 내용을 확인할 수 있습니다.

  fun enumprint3()
    {
        for( state in enumValues<State>())
        {
            Log.d(TAG, "enumValues : ${state.name} == ${state.ordinal}")
        }
    }

코틀린 열거형 클래스(Enum Class)는 도우미 메소드 enumValueOf를 이용해서도 열거형 클래스를 확인할 수 있습니다.

"enumValues"를 사용 후 열거형 클래스를 선언하면 전체 열거형 클래스를 for문으로 확인 가능합니다.

출력 결과 values 메소드를 사용한 결과와 동일한 내용을 확인할 수 있습니다.

코틀린(kotlin) 열거형 클래스(Enum Class)는 상수를 맞춤형 데이터로 연결할 수 있습니다.

일반적으로 선언할 경우 0번에서 부터 순차적으로 선언되지만, 별도 상수를 선언이 가능합니다.

코틀린 열거형 클래스(Enum Class) 선언 후 fun 별도 함수를 하나 추가했습니다.

enum class Color(val rgb: Int){
    RED(0xFF0000),
    GREEN(0x00FF00),
    BLUE(0x0000FF),
    YELLOW( 0xFFFF00);

    fun containsRed() = (this.rgb and 0xFF000 != 0)
}

fun enumprint4()
{
    val red = Color.RED
    Log.d(TAG, red.toString())
    Log.d(TAG, red.containsRed().toString())
    Log.d(TAG, Color.BLUE.containsRed().toString())
}

fun 함수는 열거형에 선언된 HEX 값을 확인하여 참, 거짓으로 리턴합니다.

red.containRed() 메서드를 실행하면 RED 값과 조건식이 맞기 때문에 참으로 출력됩니다.

반면 Color.BLUE.contatinsRed() 메서드를 선언하면 RED가 아니기 때문에 거짓을 리턴합니다.

코틀린(kotlin) 열거형 클래스(Enum Class) 집합된 상수를 사용할 수 있어 가독성이 떨어지는 Int형보다 편리하게 사용할 수 있는 클래스입니다.

다양한 열거형을 클래스 내부에서 사용하게 되면 가독성을 더욱더 높일 수 있습니다.

감사합니다.

play.kotlinlang.org/byExample/03_special_classes/02_Enum

 

Kotlin Playground: Edit, Run, Share Kotlin Code Online

 

play.kotlinlang.org

 

반응형
반응형

코틀린은 다양한 Class를 사용해서 가독성 높게 개발할 수 있습니다.

오늘은 데이터(Data)를 쉽게 사용할 수 있는 데이터 클래스(Data Class)를 알아보겠습니다.

서버에서 사용하는 데이터를 가져와서 저장하기 위해서 많이 사용되는 클래스입니다.

데이터 클래스(Data Class)는 애플리케이션 데이터 모델의 주요 구성요소입니다.

코틀린(Kotlin)에서는 클래스에 사용되는 속성에 게터, 세터가 지정됩니다.

var을 선언할 경우 읽기 쓰기 속성이기 때문에, 게터, 세터 모두 정의됩니다.

val을 선언할 경우는 읽기 속성만 있는 게터만 적용됩니다.

코틀린 데이터 클래스(Data Class)

데이터 클래스(Data Class)는 데이터의 무결성을 유지하기 위해서 val을 많이 사용합니다.

구조는 "data class"로 되어 있습니다.

class name을 지정하고 기본 인자를 선언하면 됩니다.

data class Book(val title:String, val price:Int, val type:Int)

Book 데이터 클래스는 val로 모두 선언되어 있어 직접 변경이 불가능합니다.

Book 데이터 클래스를 사용하기 위해서 다양한 함수를 적용했습니다.

fun books(){

        val book = Book("Kotlin", 20000, 1)

        Log.d(TAG, book.toString())

        val secondBook = Book("C#", 15000, 3)
        val thirdBook = Book("JAVA", 25000, 4)

        Log.d(TAG, book.hashCode().toString())
        Log.d(TAG, secondBook.hashCode().toString())
        Log.d(TAG, thirdBook.hashCode().toString())

        Log.d(TAG, book.copy().toString())
        Log.d(TAG,book.copy("Kotlin copy second").toString())
        Log.d(TAG,book.copy(price = 40000).toString())

        Log.d(TAG, secondBook.component1())
        Log.d(TAG, secondBook.component2().toString())
        Log.d(TAG, secondBook.component3().toString())

    }

클래스 선언은 JAVA와 다르게 new 없이 바로 선언하면 됩니다.

BOOK 클래스 타입을 확인하기 위해서. toString() 함수를 사용하면 모든 인수를 확인할 수 있습니다.

데이터 클래스는 두 인스턴스의 구조적 동등성을 비교하기 위해서 hashCode() 함수를 사용합니다.

hashCode() 함수를 사용할 경우 클래스 형식을 확인할 수 있습니다.

코틀린(Kotlin) 데이터 클래스(Data Class)는 직접 인수를 변경할 수 없기 때문에 copy() 함수를 사용해서 각 인수를 변경할 수 있습니다.

함수를 사용하기 위해서 MainActivity에 books() 함수를 호출했습니다.

데이터 클래스(Data Class) 인수를 확인하기 위해서는 component+번호() 함수를 사용할 수 있습니다.

데이터 클래스(Data Class) 인수에 따라서 함수가 순차적으로 변경됩니다.

함수 뒤에 자료형도 확인이 가능합니다.

모든 자료형은 .toString() 함수를 출력이 가능합니다.

Log View에서 출력된 데이터 클래스(Data Class) 정보를 확인할 수 있습니다.

.toString() 함수를 사용해서 인스턴스를 바로 확인할 수 있습니다.

HashCode() 함수를 사용하면 데이터 클래스의 Hash 값을 확인할 수 있습니다.

copy() 함수를 사용하면 인수를 변경할 수 있습니다.

코틀린(Kotlin) 데이터 클래스(Data Class)는 데이터 자료형을 프로그램에서 편리하게 사용할 수 있게 도와주는 매우 좋은 클래스입니다.

코틀린 파일을 따로 생성해서 데이터 클래스를 정의하면 더욱더 편리하게 사용할 수 있습니다.

감사합니다.

play.kotlinlang.org/byExample/03_special_classes/01_Data%20classes

 

Kotlin Playground: Edit, Run, Share Kotlin Code Online

 

play.kotlinlang.org

 

반응형
반응형

오늘은 Android에서 디버깅 로그 사용법을 알아보겠습니다.

디버깅 로그는 Print() 함수와 동일하게 cmd에 출력하는 구조입니다.

Android를 개발할 경우 코드를 확인하기 위해서 Toast를 많이 사용합니다.

하지만 Toast 메시지 함수는 많은 이벤트에서 사용하기 매우 불편한합니다.

Android에서 코트린을 사용해서 디버깅을 출력하기 위해서는 먼저 Logcat View를 활성화해야 합니다.

android Studio 하단에서 Logcat 탭을 클릭하면 컴파일 시 모든 내용을 확인할 수 있습니다.

로그를 출력할 경우 Logcat View 내용이 출력됩니다.

Android Kotlin Log CODE

기본적으로 로그를 사용하기 위해서는 "import android.util.Log"를 포함해야 합니다.

Log 함수는 TAG 값을 기준으로 메시지를 추가할 수 있습니다.

class MainActivity : AppCompatActivity() {


    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        val TAG:String = "MainActivity : "

        Log.d(TAG, "Log ----- START")
        Log.d(TAG, "Log ----- INSERT")
        Log.d(TAG, "Log ----- END")

}

TAG를 String 변수로 초기화 해주세요.

이후 Log를 추가하고 싶은 라인에 Log.d(TAG, 메시지)를 추가하면 됩니다.

Log는 Debug, Info, Error, VERBOSE 등 다양한 타입으로 출력이 가능합니다.

컴파일을 진행하면 Log를 Logcat View에서 확인할 수 있습니다.

Log 정보를 타입에 따라서 잘 사용하면 오류가 발생할 경우 쉽게 원인을 파악할 수 있습니다.

감사합니다.

developer.android.com/reference/kotlin/android/util/Log

 

Log  |  Android 개발자  |  Android Developers

 

developer.android.com

 

반응형
반응형

오늘은 코틀린을 사용해서 안드로이드 인트로 화면을 만들어 보겠습니다.

코틀린 안드로이드 인트로

기본적인 인트로 화면으로 이미지를 추가해서 전환하는 방식으로 코드를 진행하겠습니다.

코틀린 안드로이드 인트로

먼저 안드로이드 스튜디오 및 IntelliJ을 사용해서 안드로이드 컴파일할 수 있는 환경을 구성해주세요.

전 유료 버전인 IntelliJ를 사용해보겠습니다.

안드로이드 스튜디오 개발 회사에서 만든 툴이기 때문에 비슷한 부분이 많이 있습니다.

먼저 "Empty Activity" 프로젝트를 생성해줍니다.

코틀린 안드로이드 인트로

안드로이드 인트로화면은 Activity를 호출해주는 방식이기 때문에 먼저 IntroActivity를 생성해줍니다.

이번에는 안드로이드 인트로에 사용할 이미지를 등록해주세요.

drawable 폴더에서 우클릭을 사용해서 Explorer을 오픈해서 이미지를 복사하면 자동으로 drawable 하위에 이미지가 등록됩니다.

코틀린 안드로이드 인트로

등록된 이미지를 클릭하면 확인할 수 있습니다.

코틀린 안드로이드 인트로

처음에 신규로 생성한 introlActivity.kt 파일을 클릭해서 코드를 입력해주세요.

class introlActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_introl)

        var handler = Handler()
        handler.postDelayed( {
            var intent = Intent( this, MainActivity::class.java)
            startActivity(intent)
        }, 3000)
    }

    override fun onPause() {
        super.onPause()
        finish()
    }
}

Intent를 사용해서 MainActivity를 3초 후에 이동하는 코드입니다.

onPause가 호출되면서 대기상태일 때 introActivity는 종료시키는 코드도 추가해주세요.

 

 

 

코틀린 안드로이드 인트로

인트로 레이아웃은 ImageView를 사용해서 고정시켜줍니다.

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout
        xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        xmlns:app="http://schemas.android.com/apk/res-auto"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        tools:context=".introlActivity">

    <ImageView
            android:id="@+id/introlImg"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:scaleType="fitXY"
            android:src="@drawable/moon"
    />

</androidx.constraintlayout.widget.ConstraintLayout>

마지막으로 등록된 메인 Activity 정보를 변경해줍니다.

코틀린 안드로이드 인트로

AndroidManifest.xml에서 MainActivity와 .introlActivity를 바꿔주면 IntrolActivity가 먼저 호출되면서

3초 후 MainActivity가 호출됩니다.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
          package="com.example.p365language">

    <application
            android:allowBackup="true"
            android:icon="@mipmap/ic_launcher"
            android:label="@string/app_name"
            android:roundIcon="@mipmap/ic_launcher_round"
            android:supportsRtl="true"
            android:theme="@style/AppTheme">
        <activity android:name=".MainActivity">
        </activity>
        <activity android:name=".introlActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN"/>
                <category android:name="android.intent.category.LAUNCHER"/>
            </intent-filter>
        </activity>
    </application>

</manifest>

정상적으로 코딩되었다면 빌드해주세요.

코틀린 안드로이드 인트로

인트로로 설정된 Activity가 먼저 호출되는 것을 확인할 수 있습니다.

코틀린 안드로이드 인트로

3초 후 메인화면으로 이동합니다.

인트로 화면은 앱 실행과 동시에 사용자에게 가장 큰 기대를 줄 수 있는 중요한 내용입니다.

안드로이드 인트로 화면을 사용해서 앱을 더욱더 멋지게 개발해보세요.

감사합니다.

반응형
반응형

오늘은 코틀린에서 가변 인자를 사용하고 싶을 경우 어떻게 사용해야 하는지 알아보겠습니다.

함수를 사용할 경우 고정된 파라미터를 사용하기도 하지만 가변적인 배열을 사용하고 싶은 경우도 있습니다.

코틀린에서는 이런 경우 vararg를 사용해서 배열을 정의합니다.

    fun IntMax(vararg numbers:Int):String
    {
        val sum = numbers.max()
        return sum.toString()
    }
    
    val rString = IntMax(2,4,7,9,10,15)
    Toast.makeText(this, rString, Toast.LENGTH_SHORT).show()

vararg 를 선언하게 되면 파라미터가 배열러 인식됩니다.

아규먼트(argument) 2, 4, 7, 9, 10, 15를 입력하면 MAX 항목인 15를 리턴합니다.

출력시 15를 확인할 수 있습니다.

INT 형태 배열을 사용해서 INT 가변 인자를 확인 할 수 있습니다.

그럼 이번에는 String을 사용해보겠습니다.

    fun StringAll( vararg StringList:String):String{
        val rText = StringList.joinToString()
        return rText
    }
    
    val rString = StringAll("A","S","D", "H", "I")
    Toast.makeText(this.application, rString, Toast.LENGTH_SHORT).show()

StringAll 함수는 파라미터(parameter) StringList를 vararg로 선언했습니다.

함수 내부에서 String 배열을 확인해서 입력된 아규먼트를 확인할 수 있습니다.

StringAll 함수는 입력된 String를 연결해서 리턴하게 되어 있습니다.

출력 결과 "A,S.D.H.I"를 확인 할 수 있습니다.

vararg는 다른 파라미터와 함께 사용이 가능합니다.

 

 

 

fun AllValue( Value1:Int, Value2:String, vararg StringList:String):String{
        val rText = StringList.joinToString()
        val AllText = Value1.toString() + Value2 + rText
        return AllText
    }

val rString = AllValue(123,"더하기","D", "H", "I")
Toast.makeText(this.application, rString, Toast.LENGTH_SHORT).show()

AllValue 함수는 파라미터 INT, String, vararg String를 사용합니다.

아규먼트 123, "더하기", "D", "H", "I"를 입력합니다.

결과는 "123더하기D,H,J" 입니다.

vararg는 다양한 가변 인자를 사용해서 함수를 유연하게 생성할 수 있습니다.

함수에 한개의 vararg만 사용이 가능합니다.

오늘은 코틀린(Kotlin) vararg에 대해서 알아보았습니다.

감사합니다.

반응형
반응형

오늘은 코틀린(Kotlin) 안드로이드 배우기 #1 - ClickEvent, when에 대해서 알아보겠습니다.

코틀린(Korlin)을 사용하기 위해서는 기본적으로 안드로이드 스튜디오를 설치하면 바로 사용이 가능합니다.

안드로이드 설치는 다음 시간에 다루고 이번 시간에는 코틀린을 사용해서 버튼 이벤트 연결에 대해서 알아보겠습니다.

안드로이드 스튜디오 설치 상태에서 "NewProject"를 선택 후 EmptyActivity를 선택해 줍니다.

Project 설정에서 원하는 폴더에 Name, Package 명을 입력해 주세요.

가장 중요한 "Language"는 Kotlin을 선택해 줍니다.

 

 

 

이번 강좌에서는 MainActivity, activity_main.xml 두 개 파일만 사용하겠습니다.

먼저 정렬을 하기 위해서 activity_main.xml 파일에서 레이아웃을 변경해 주십시오.

레이아웃 변경 후 컨트롤을 등록하기 위해서 아래 코드를 입력해 주세요.

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context=".MainActivity">

    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_gravity="center"
        android:layout_margin="7dp"
        android:onClick="onClick"
        android:id="@+id/btnStart"
        android:text="Start"
        tools:ignore="MissingConstraints"
        />

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello World!"
        android:layout_gravity="center"
        android:layout_margin="25dp"
        android:id="@+id/MainText"/>

</LinearLayout>

세로 정렬을 사용하기 위해서 LinearLayout 속성 android:orientation="vertical"을 추가하고

이벤트를 사용하기 위해서 버튼, 텍스트 뷰를 추가해 줍니다.

"Shift" + F10을 클릭하면 컴파일 되면서 안드로이드가 실행됩니다.

버튼 이벤트 속성 중 android:onClick="onClick"은 Listener를 사용해서 이벤트를 연결하기 위해서 설정이 반드시 필요합니다.

이제 MainActivity로 이동합니다.

코틀린 확장자는. kt로 생성됩니다.

코틀린은 자바와 다르게 NULL 대한 처리를 명확하게 처리하여 오류를 최소화해 줍니다.

버튼 이벤트를 연결하기 위해서 View.OnClickListerner을 상속받습니다.

코틀린은 NULL을 구분하기 위해서'?'를 사용합니다.

즉 변수 뒤에'?' 가 있을 경우 NULL을 허용한다는 뜻입니다

'?'가 없을 경우는 NULL을 허용할 수 없어 컴파일이 안됩니다.

when문은 자바에서 사용하는 switch 문과 동일합니다.

버튼에 설정한 onClick를 연결하기 위해서 상속된 Listener 가상 함수 onClick을 override 합니다.

onClick 함수에서는 코틀린 when을 사용해서 버튼 ID를 구분해서 텍스트 뷰를 변경하는 로직을 추가합니다.

override fun onClick(v: View?) {
       when(v?.id)
       {
           R.id.btnStart->{
               var tView = findViewById<TextView>(R.id.MainText)
               if( bCheck) {
                   tView.setText("Click Button")
                   bCheck = false
               }
               else
               {
                   tView.setText(R.string.sRString1)
                   bCheck = true
               }
           }
       }
    }

코틀린은 형 변환을 자유롭게 하기 위해서 생성 시 만 설정해 줍니다.

findViewById<형변환Class>

코드를 추가하고 컴파일 하면 버튼을 클릭하면 텍스트 뷰가 변경되는 것을 확인할 수 있습니다.

이상으로 코틀린(Kotlin) 안드로이드 배우기 #1 강좌를 마치겠습니다.

감사합니다.

#코틀린, #안드로이드, #Kotlin, #안드로이드강좌, #onClick, #when

반응형

+ Recent posts