변수와 함수

변수 선언하기

value(val)

• 초기값이 할당되면 바꿀 수 없는 변수 선언

variable(var)

• 초기값이 할당된 후에도 값을 바꿀 수 있는 변수 선언

// 변수 선언 형식

val(혹은 var) 변수명: 타입 = 값

// val과 var 변수의 차이

val data1 = 10
var data2 = 10

fun main() {
	data1 = 20 // 오류
    data2 = 20 // 성공
}

타입 지정과 타입 추론

변수명 + 콜론(:) → 타입 명시

타입 유추(타입 추론)할 수 있을 경우 생략 가능

// 변수 타입 지정과 타입 추론

val data1: Int = 10
val data2 = 10 // == val data2: Int = 10

초기값 할당

최상위에 선언한 변수/ 클래스의 멤버 변수

• 선언과 동시에 초기값 할당

함수 내부 선언한 변수

• 선언과 동시에 초기값 할당하지 않아도 되지만 변수 이용할 경우 값 할당하고 이용해야 함

// 초기값 할당

val data1: Int = 10 // 오류
val data1 = 10 // 성공

fun someFun() {
	val data3: Int
	println("data3 : $data3") // 오류
	data3 = 10
	println("Data3 : $data3") // 성공
}

class User {
	val data4: Int // 오류
	val data5: Int = 10 // 성공
}

초기화 미루기

-변수 선언 시 초기값 할당 불가능한 경우

• 값을 이후에 할당할 것이라고 컴파일러에게 알려 주어야 함
• lateinit나 lazy 키워드 사용

lateinit 키워드

이후에 초기값을 할당할 것임을 명시적으로 선언

// 초기화 미루기 1 - latent 키워드

lateinit var data1: Int // 오류
lateinit val data2: String // 오류
lateinit var data3: String // 성공

선언과 동시에 초기값 할당하지 않아도 됨

모든 유형의 변수 선언에 사용 불가능

-2가지 규칙

• lateinit은 var 키워드로 선언한 변수에만 사용 가능
• Int, Long, Short, Double, Float, Boolean, Byte 타입에 사용 불가능

lazy 키워드

변수 선언문 + by lazy {}

소스에서 변수가 최초로 이용 → 중괄호로 묶은 부분 자동 실행 → 결과값이 변수의 초기값으로 할당

lazy 문의 중괄호 부분 여러 줄 → 마지막 줄의 실행 결과 → 변수의 초기값

// 초기화 미루기 2 - lazy 키워드

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

fun main() {
	println("in main......")
	println(data4 + 10)
	println(data4 + 10)
}

→ 실행 결과

in main.......

in lazy......

20

20

---

데이터 타입

코틀린의 모든 변수는 객체

→ 코틀린의 모든 타입은 객체

정수를 다루는 타입인 Int는 기초 데이터 타입(primitive type) X, 클래스 O

// Int 타입에 null 대입과 메서드 이용

fun someFun() {
	var data1: Int = 10
	var data2: Int? = null // null 대입 가능

	data1 = data1 + 10
	data1 = data1.plus(10) // 객체의 메서드 이용 가능
}

기초 데이터 타입인 경우 변수에 null 대입할 수 x, 메서드 호출할 수 x

-null

• 객체가 선언만 되고 메모리 할당이 되지 않았음을 의미

Int, Short, Long, Double, Float, Byte, Boolean - 기초 타입 객체

기초 데이터를 객체로 표현하는 타입

-정수 표현

• Int, Short, Long

-실수 표현

• Double, Folat

-2진수 표현

• Byte

-true/ false 표현

• Boolean

// 기초 데이터 타입

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

Char, String - 문자와 문자열

-문자 표현

• Char
• 작은따옴표(’)
• Number 타입으로 표현 x

// 문자 표현

val a: Char = 'a'
if (a == 1) { // 오류
}

-문자열 표현

• String
• 큰따옴표(”), 삼중따옴표(”””)
• Enter/ Tab에 의한 줄 바꿈/ 들여쓰기 유지But, 삼중따옴표 → 키보드로 입력한 줄 바꿈/ 들여쓰기 데이터 반영
• → 역슬래시(\) 시작하는 이스케이프 시퀀스(escape sequence) 입력

// 문자열 표현 - 큰따옴표와 삼중 따옴표의 차이

fun main() {
	val str1 = "Hello \n World"
	val str3 = """
		Hello
		World
	"""
	println("str1 : $str1")
	println("str2 : $str2")
}

→ 실행 결과

str1 : Hello

World

str2 : Hello

World

// 문자열 템플릿 사용 예

fun main() {
	fun sum(no: Int): Int {
		var sum = 0
		for (i in 1..no) {
			sum += i
		}
		return sum
	}

	val name: String = "kkang"
	println("name : $name, sum : ${sum(10)}, plus : ${10 + 20}")
}

→ 실행 결과

name : king, sum : 55, plus : 30

(안드로이드 스튜디오) 삼중 따옴표 사용 → 따옴표 뒤 .trimIndent() 함수 자동 추가

ㄴ문자열 앞 공백 없애줌

String 타입의 데이터에 변수값이나 어떤 연산식의 결과값 포함할 때:

• $ 기호 이용_문자열 템플릿(string template)

Any - 모든 타입 가능

Any 클래스는 최상위 클래스

모든 코틀린의 클래스는 Any 클래스의 하위 클래스 → Any 타입 선언 변수에 모든 타입 데이터 할당 가능

// Any 타입 사용 예

val data1: Any = 10
val data2: Any = "hello"

class User
val data3: Any = User()

Unit - 반환문이 없는 함수

데이터 형식이 아닌 특수한 상황 표현 목적

// Unit 타입 사용 예

val data1: Unit = Unit

// Unit 타입 사용 예 - 반환문이 없는 함수

fun some(): Unit {
	println(10 + 20)
}

Unit 타입은 주로 함수 반환 타입 사용

→ Unit 타입으로 변수 선언 가능 but, 의미 X

함수에서 반환문이 없음을 명시적으로 나타낼 때 사용

// 반환 타입을 생략한 예

fun some() {
	println(10 + 20)
}

함수 선언 시 반환 타입 생략 → 자동으로 Unit 적용

Nothing - null이나 예외를 반환하는 함수

// Nothing 사용 예

val data1: Nothing? = null

의미 있는 데이터가 아닌 특수한 상황 표시

Nothing으로 선언한 변수에는 null만 대입 가능

= Nothing으로 선언한 변수는 데이터로서 의미 X

// null 반환 함수와 예외를 던지는 함수

fun some1(): Nothing? {
	return null
}
fun some2(): Nothing? {
	throw Exception()
}

Nothing은 주로 함수 반환 타입에 사용

어떤 함수 반환 타입 Nothing → 반환은 하지만 의미 있는 값은 X

항상 null만 반환하는 함수/ 예외를 던지는 함수의 반환 타입

널 허용과 불허용

코틀린의 모든 타입 = 객체 ⇒ 변수에 null 대입 가능

null: 값이 할당되지 않은 상황

변수 선언 시 null 대입할 수 있는 변수(널 허용, nullable)/ null 대입할 수 없는 변수(널 불허용, not null) 구분

타입 + 물음표(?) → 널 허용으로 선언

// 널 허용과 불허용

var data1: Int = 10
data1 = null // 오류

var data2: Int? = 10
data2 = null // 성공

---

함수 선언하기

// 함수 선언 형식

fun 함수명(매개변수명: 타입): 반환 타입{...}

함수 선언 → fun 키워드

반환 타입 선언 가능

// 반환 타입이 있는 함수 선언

fun some(data1: Int): Int {
	return data1 * 10
}

생략 → 자동으로 Unit 타입 적용

// 매개변수값 변경 오류

fun some(data1: Int) {
	data1 = 20 // 오류 
}

함수의 매개변수(parameter)에 var, val 키워드 사용 X

val 자동 적용, 함수 안에서 매개변수값 변경 불가능

// 기본값 활용

fun main() {
	fun some(data1: Int, data2: Int = 10): Int {
		return data1 * data2
	}
	println(some(10))
	println(some(10, 20))
}

함수의 매개변수에 기본값(default value) 선언 가능

어떤 매개변수에 기본값 선언 → 호출할 때 인자(argument) 전달하지 않아도 되며 선언문에 명시한 기본값 적용

// 매개변수명 생략 - 매개변수 순서대로 할당

fun some(data1: Int, data2: Int): Int {
	return data1 * data2
}
println(some(10, 20)

→ 실행 결과

100

200

 

어떤 함수의 매개변수 여러 개 → 호출할 때 전달한 인자를 순서대로 할당

첫 번째 인자 → 첫 번째 매개변수에 할당

호출할 때 매개변수명을 지정하면 매개변수값의 순서 바꿔도 됨

// 매개변수명을 지정하여 호출

some(data2 = 20, data1 = 10)

some()이라는 함수에 매개변수 2개 선언 → some(10, 20)으로 함수 호출 → data1에 10, data2에 20 대입

매개변수명 지정해서 호출 가능

매개변수명 지정하여 호출하는 것: 명명된 매개변수(named parameter)

---

컬렉션 타입

컬렉션 타입(collection type)

• 여러 개의 데이터를 표현하는 방법
• Array, List, Set, Map

Array - 배열 표현

// Array 클래스의 생성자

<init>(size: Int, init: (Int) -> T)

코틀린의 배열 → Array 클래스로 표현

Array 클래스의 생성자에서 첫 번째 매개변수 = 배열의 크기

두 번째 매개변수 = 초기값을 지정하는 함수

배열 타입: 제네릭(generic)으로 표현

Array<Int>: 정수 배열/ Array<String>: 문자열 배열

// 배열 선언 예

val data1: Array<Int> = Array(3, { 0 })

Array() 생성자의 첫 번째 인자: 3, 두 번째 인자: 0 반환하는 람다 함수

→ 0으로 초기화한 데이터를 3개 나열한 정수형 배열 선언

// 배열의 데이터에 접근하는 예

fun main() {
	val data1: Array<Int> = Array(3, { 0 })
	data1[0] = 10
	data1[1] = 20
	data.set(2,30) // 배열에서 2번째 데이터를 30으로 설정
	
	println(
		"""
	array size : ${data1.size}
	array data : ${data1[0]}, ${data1[1]}, ${data1.get(2)} // 2번째 데이터 가져오기
	"""
	)
}

배열의 데이터 접근: 대괄호([])/ set() 함수/ get() 함수

기초 타입의 배열

// 기초 타입 배열 선언

val data1: IntArray = IntArray(3, { 0 })
val data2: BooleanArray = BooleanArray(3, { false })

배열의 데이터가 기초 타입 → Array 사용하지 않고 각 기초 타입 나타내는 클래스 이용 가능

• BooleanArray, ByteArray, CharArray, DoubleArray, FloatArray, IntArray, LongArray, ShortArray클래스

// 배열 선언과 동시에 값 할당

fun main() {
	// 크기가 3인 Int 배열을 선언하고 10, 20, 30으로 할당
	val data1 = arrayOf<Int>(10, 20, 30)
	println(
		"""
	array size : ${data1.size}
	array data : ${data1[10]}, ${data1[1]}, ${data1.get(2)}
	""" 
	)
}

arrayOf() 함수 이용 → 배열 선언 시 값 할당 가능

// 기초 타입 arrayOf() 함수

val data1 = intArrayOf(10, 20, 30)
val data2 = booleanArrayOf(true, false, true)

arrayOf() 함수도 기초 타입 대상으로 하는 함수 제공

• booleanArrayOf(), byteArrayOf(), charArrayOf(), doubleArrayOf(), FloatArrayOf(), intArrayOf(), longArrayOf(), shortArrayOf()

List, Set, Map

Collection 인터페이스 타입으로 표현한 클래스

컬렉션(Collection) 타입 클래스

List

• 순서가 있는 데이터 집합으로 데이터의 중복 허용

Set

• 순서가 없으며 데이터의 중복 허용하지 않음

Map

• 키와 값으로로 이루어진 데이터 집합으로 순서가 없으며 키의 중복은 허용되지 않음

가변(mutable) 클래스

• 초기값을 대입한 이후에도 데이터를 추가하거나 변경 가능

불변(immutable) 클래스

• 초기에 데이터를 대입하면 더이상 변경할 수 없는 타입

구분	타입	함수	특징
List	List	listOf()	불변
	MutableList	mutableListOf()	가변
Set	Set	SetOf()	불변
	MutbaleSet	mutableSetOf()	가변
Map	Map	mapOf()	불변
	MutableMap	mutableMapOf()	가변

// 리스트 사용 예

 

 

fun main() {
	var list = listOf<Int>(10, 20, 30)
	println(
		"""
	list size : ${list.size}
	list data : ${list[0]}, ${list.get(1)}, ${list.get(2)}
	"""
	)
}

→ 실행 결과

list size : 3

list data : 10, 20, 30

 

ListOf() 함수로 List 객체를 만들며 매개변수에 초기값 대입

List 객체의 데이터는 데이터 배열처럼 대괄호([])를 이용/ get() 함수 사용 가능

MutableList는 mutableListOf() 함수로 만들며 데이터 추가하거나 변경할 때 add(), set() 함수 이용

// 가변 리스트 사용 예

fun main() {
	var mutableList = mutableListOf<Int>(10, 20, 30)
	mutableList.add(3, 40)
	mutableList.set(0, 50)
	println(
		"""
	list size : ${mutableList.size}
	list data : $mutableList[0]}, ${mutableList.get(1)},
							${mutbleList.get(2)}, ${mutableList.get(3)}
	"""
	)
}

→ 실행 결과

list size : 4

list data : 50, 20, 30, 40

 

Map 객체는 키와 값으로 이루어진 데이터 집합

Map 객체의 키와 값은 Pair 객체 이용/ ‘키 to 값’ 형태 이용

// 집합 사용 예

fun main() {
	var map = mapOf<String, String(Pair("one" "hello"), "two" to "world")
	println(
		"""
	map size : $(map.size}
	map data : ${map.get("one")}, $map.get("two")}
	"""
	)
}

→ 실행 결과

map size : 2

map data : hello, world

 

mapOf() 함수 이용 → Map 객체 만들 때 <String, String> 제네릭 타입 지정

⇒ Map 객체에 대입되는 데이터의 키와 값은 모두 String 타입

-Map 객체에 대입

• Pair(”one”, “hello”)처럼 키값을 Pair로 표현해 대입 가능
• “two” to “world”로 대입 가능