안드로이드 앱 프로그래밍 - 3(코틀린 프로그래밍 기본)

- 변수와 상수

val data1 = 10 //상수
var date2 = 10 //변수

fun main(){
    date1 = 20 //오류
    date2 = 20 //성공
    }

 

<변수의 타입지정>

var date1 : Int = 10

 

<초기값 할당>

최상위 변수나 클래스의 맴버 변수는 선언과 동시에 초깃값을 할당해야합니다. 하지만 함수 내부에 선언한 변수는 선언과 동시에 초깃값을 할당하지 않아도 됩니다.

 

<lateinit, lazy>

변수를 선언할때 값을 이후에 할당하려면 컴파일러에게 알려줘야합니다. 이에 lateinit 이나 lazy 키워드를 사용합니다.

lateinit var date : String

lateinit 키워드를 사용할"때는 다음 2가지 규칙을 따라야합니다.

• lateinit은 var 키워드로 선언한 변수에만 사용할 수 있습니다.
• Int, Long, Short, Double, Float, Boolean, Byte 타입에는 사용할 수 없습니다.

val data4 : Int by Lazy {	
    println("in lazy...")
    10
}

lazy 키워드의 경우에는 소스에서 val 변수에만 사용할 수 있고, val 변수가 최초로 이용되는 순간 중괄호로 묶은 부분이 자동으로 실행되어 그 결괏값이 변수의 초깃값으로 할당됩니다. 위 코드의 data4의 값은 10이 됩니다.

 

<데이터 타입>

val a1: Byte = 0b00001011
val a2: Int = 123
val a3: Short = 123
val a4: Long = 10L
val a5: Double = 10.0
val a6: Float = 10.0f
val a7: Boolean = true

val a: Char = 'a'
val str1 = "hello world"
val str2 = """
    hello	
    world
"""

val data1: Any = 10 //Any는 모든 데이터 타입을 포함합니다.
val data2: Any = "hello"

fun some(): Unit {} //함수에서 반환문이 ㅇ벗음을 명시적으로 나타냅니다. 생략도 가능합니다.

val data1: Nothing? = NULL //NULL만 대입할 수 있는 데이터타입니다.
fun some1(): Nothing?{ return null } //함수반환값에도 사용할 수 있습니다.

var data1: Int? = 10 //?기호는 null을 허용할 수 있다는 뜻으로 ?가 업으면 null은 허용되지않습니다.

 

<함수선언>

fun 함수명(매개변수명: 타입): 반환 타입{}
ex)
fun some(data1: Int): Int{}

함수의 매개변수에는 var이나 val 키워드를 사용할 수 없습니다. 함수의 매개변수에는 기본값을 설정할 수 있습니다.

fun some(data1: Int, data2: Int = 10 ) Int {}

호출할때 매개변수명을 지정하여 호출하면 순서는 상관없게 됩니다.

soem(data2 = 20, data1 = 32)

 

<컬렉션 타입>

컬렉션 타입이란 여러개의 데이터를 표현하는 방법이며 Array, List, Set, Map이 있습니다. 순서대로 보겠습니다.

//array 사용법
val data1: Array<Int> = Array(3, { 0 })
data1[0] = 10
data1.set(2, 30)
var data5 = data1.get(2)

//array 종류
val data1: IntArray = IntArray(3, { 0 })
val data2: BooleanArray = BooleanArray(3, { false })
val data3: CharArray = CharArray(3, { 'a' })
val data4: DoubleArray = DoublArray(3, { 10.0 })
val data5: FloatArray = FloatArray(3, { 10.0f })
val data6: LongArray = LongArray(3, { 10L })
val data7 ShortArray = ShortArray(3, { 3 })

//arrayof함수
val data1 = intArrayOf(10, 20, 30)
val data2 = booleanArrayOf(true, false, ture)
val data3 = charArrayOf('3', '4', '5')
val data4 = doubleArrayOf(10.1, 10.2, 10.3)
val data5 = floatArratOf(10.1f, 10.2f, 10.3f)
val data6 = longArrayOf(10L, 12L, 14L)
val data7 = shortArrayOf(10, 12, 14)

아래 3개의 컬렉션 타입은 가변과 불변 클래스로 나뉩니다. 

List : 순서가 있는 데이터 집합으로 데이터의 중복을 허용합니다.

Set : 순서가 없으며 데이터의 중복을 허용하지 않습니다.

Map : 키와 값으로 이루어진 데이터 집합으로 순서가 없으며 키의 중복은 허용하지 않습니다.

//불변리스트 사용예시
var list = listOf<Int>(10, 20, 30)
println("${list[10]}, ${list.get(1)}")

//가변리스트 사용예시
var list = mutableListOf<Int>(10, 20, 30)
mutableList.add(3, 40) //인덱스에 추가
mutableList.Set(0. 50) //인덱스 값을 변경

//맵 사용예시
var map = mapOf<Stirng, String>(Pair(:one", "hello"), "two" to "world")

 

<조건문과 반복문>

//if-else
if (data > 0>{
	...
}else{
	...
}

//else-if
if (data > 0>{
	...
}else if( data > -32){
	...
}
else{
	...
}

//표현식으로 사용
val result = if(data > 0) {
    true
}else{
   false
}

when(data){
    "hello" -> println("hello")
    "world" -> println("world")
    else -> {
         println("else")
     }
}

//다양한 조건들
when(data){
    is String -> pinrtln("string")
    20, 30 -> println("20 or 30")
    in 1..10 -> println("1~10")
}

//데이터 명시안하기
when{
	data <= 0 -> println("data is minus")
    
//표현식으로 사용
var result = when{
    data <= 0 -> "data is minus"
}

//여러가지 for 문
for (i in 1..10) //1부터 10까지 1씩 증가
for (i in 1 until 10) //1부터 9까지 1씩증가
for (o on 2..10 step 2) //2부터 10까지 2씩 증가
for (i in 10 downTo 1) //10부터 1까지 1씩 감소

//예제
for (i in 1..10){
   sum += i
}

//컬렉션 타입 활용 
var data = ArrayOf<Int>(10, 20, 30>
for (i in data.indices){	//indices는 인덱스 값을 의미합니다. 
    ...
}

for ((index, value) in data.withIndex()){  //withIndex로 값을 가져올 수 있습니다.
    ...
 }

while( x < 10){}

 

<클래스와 생성자>

//class 선언
class User {}

//주생성자
class User(name: String) {}

//보조 생성자
class User {
    constructor(name: String){
    }
}

//주생성자 사용시 실행되는 init 영역사용
class User(name: String){
    init{
    ...
    }
}

//생성자의 매개변수를 클래스의 멤버 변수로 선언
class User(name: String) {
    var this.name = name  //this키워드로 직접 선언
}

class User(var name: String){}  //val 키워드로 선언

//보조생성자에 주 생성자 연결
Class User(name: Stirng){
    constructor(name: String, count: Int): this(name) {...}
    constructor(name: String, count: Int, email: String): this(name, count){...}
}

 

<클래스와 상속>

//open 키워드 사용
open class Super(name: String){...}
class Sub: Super(name){...}

//보조생성자가 있는경우
calss Sub: Super{
    constructor(name: String): super(name){...}
}

//오버라이딩
open class Super{
    open var superData = 10
    open fun superFun(){...}
}
class Sub: Super()
fun main() {
   val obj = Sub()
   override obj.superData = 20
   override obj.superFun(){ add...}
}

 

<접근제한자>

• public : 모든 파일 클래스에서 접근이 가능합니다.
• internal : 같은 모듈내에서 접근이 가능합니다.
• protected : 상속 관계의 하위 클래스와 클래스 내부에서 접근가능합니다.
• private : 클래스 내부에서만 접근 가능하고 파일 내부에서만 접근 가능합니다.

<데이터 클래스>

//데이터 클래스 선언
data class DataClass(val name: String, val email: String)

//equals()함수 반환값은 true, false
data1.equals(data2)

//toStrin()함수 반환값은 객체의 데이터
data.toString()

 

<오브젝트 클래스>

오브젝트 클래스는 익명 클래스를 만들 목적으로 사용합니다. 클래스 이름이 없으므로 클래스를 선언하면서 동시에 객체를 생성해야합니다.

val obj = objhect: Super(){
    override var data = 20
}

 

<컴패니언 클래스>

객체가 아닌 클래스의 변수나 함수를 접근하고자 할때 사용합니다.

class MyClass{
    companion object{
        var data = 10
        fun some() {
            println(data)
        }
    }
}

fun main() {
    MyClass.data = 20
    MyClass.soem()