100년 뒤 개발자 한승규입니다.

https://kotlinlang.org/docs/basic-types.html

• Basic types

코틀린에서도 모든 것은 객체이다.

호출하는 함수와 그 어떤 속성도 모두 객체이다.

코틀린에서는 4가지의 숫자 타입을 제공한다.

만약 처음에 타입을 지정해주지 않는다면, 컴파일러는 자동으로 Int로 지정해주게 된다.

만약 Int의 범위 밖이라면, 타입은 Long으로 지정되게 된다.

처음에 Long 타입으로 지정해주고 싶다면, 숫자 뒤에 L을 붙여야 한다.

val a = 1 // Int
val b = 3030303030303030303030 //Long
val c = 123L // Long

코틀린은 실수에 대해, Float와 Double을 제공한다.
Float은 Single precision, Double은 Double precision

실수를 선언하면 자동으로 Double로 지정이되며, Float로 지정하고 싶다면 뒤에 f를 붙여주어야 한다.

val e = 2.7182818284 // Double
val eFloat = 2.7182818284f // Float, actual value is 2.7182817

수는 다음과 같이 표현할 수 있다.

- Decimals: 123

- Longs: 123L

- Hexadecimals: 0x0F

- Binaries: 0b00010101

- Doubles by default: 123.5, 123.5e10

Numbers representation on the JVM

자바에서는 수를 Int, double로 저장하게 된다.

하지만 이런 타입에는 null이 지정되지 못한다.

그러면 코틀린에서의 Int?는 어떻게 되는 것일까?

그런 경우에는 자바에서의 boxed type인 Integer, Double을 사용했었다.

nullable 타입은 같은 수라도 다른 object를 참조한다.

fun main() {
    val a: Int = 100
    val boxedA: Int? = a
    val anotherBoxedA: Int? = a

    val b: Int = 10000
    val boxedB: Int? = b
    val anotherBoxedB: Int? = b

    println(boxedA === anotherBoxedA) // true
    println(boxedB === anotherBoxedB) // false
}

이런 일이 생기는 이유는 ~128~127의 범위는 JVM이 메모리 최적화를 위해 같은 곳을 참조하도록 하기 때문이다.

하지만 b의 경우에는 그런 일이 생기지 않는다.

// Hypothetical code, does not actually compile:
val a: Int? = 1 // A boxed Int (java.lang.Integer)
val b: Long? = a // Implicit conversion yields a boxed Long (java.lang.Long)
print(b == a) // Surprise! This prints "false" as Long's equals() checks whether the other is Long as well

val b: Byte = 1 // OK, literals are checked statically
// val i: Int = b // ERROR
val i1: Int = b.toInt()

코틀린은 +, -, *, /, %와 같은 기본 연산자를 지원한다.

Division of integers

Int 끼리의 나누기는 항상 Int를 반환한다.

소숫점 부분은 무시된다.

val x = 5 / 2
//println(x == 2.5) // ERROR: Operator '==' cannot be applied to 'Int' and 'Double'
println(x == 2)

소숫점까지 구하기 위해서는 하나를 명시적으로 float 타입으로 변환해주어야 한다.

val x = 5 / 2.toDouble()
println(x == 2.5)

• Unsigned integer types

Integer type에 더해, 코틀린은 unsigned 값들을 제공한다.

Unsigned arrays and ranges

다른 원시 타입들과 같이, 해당 데이터 타입들도 배열을 제공한다.

UByteArray: and array of unsigned bytes

UShortArray: an array of unsigned shorts

UIntArray: an array of unsigned ints

ULongArray: an array of unsigned longs

Unsigned integers literals

unsigned 타입을 더 명확하게 사용하기 위해, 코틀린은 해당 suffix를 제공한다.(Float, Long과 같이)

뒤에 u, U를 붙이면 해당 unsigned 타입으로 컴파일러가 인지하게 된다.

val b: UByte = 1u  // UByte, expected type provided
val s: UShort = 1u // UShort, expected type provided
val l: ULong = 1u  // ULong, expected type provided

val a1 = 42u // UInt: no expected type provided, constant fits in UInt
val a2 = 0xFFFF_FFFF_FFFFu // ULong: no expected type provided, constant doesn't fit in UInt

• Booleans

Boolean 타입은 true, false 이렇게 두가지만 가지는 boolean object이다.

다른 언어와 마찬가지로

|| : disjunction(Logical OR)

&&:: conjunction (Logical AND)

!: negation(Logical NOT)

val myTrue: Boolean = true
val myFalse: Boolean = false
val boolNull: Boolean? = null

println(myTrue || myFalse)
// true
println(myTrue && myFalse)
// false
println(!myTrue)
// false
println(boolNull)
// null

||, &&는 Lazy하게 동작하기도 한다.

무슨말이냐면, first operand가 true라면 OR는 second operand를 확인하지 않는다.

마찬가지로, first operand가 false라면 and는 second operand를 확인하지 않는다.

• Charaters

Character는 작은따옴표 안에 있는 문자 하나를 말한다. ex) '1'

backslash로 시작하는 Special Character가 존재한다.

아래와 같은 역할을 한다.

\t: tab

\b: backspace

\n: new line

\r: carriage return

\': single quotation mark

\": double quotation mark

\\: backslash

\$: dollar sign

• Strings

String은 문자열이며, JVM에서 UTF-16을 사용하기 때문에 문자 하나당 2bytes를 사용한다.

String은 큰따옴표 안에 존재한다.

String은 immutable로 후에 바꿀 수 없기 때문에 새로운 문자열 객체를 만들어서 대입해야 한다.

String은 +를 사용하여 문자열들을 이을 수 있다.

val s = "abc" + 1
println(s + "def")
// abc1def

• Strings

Array는 같은 타입이거나 그것들의 sub 타입 객체들을 고정된 숫자로 가지고 있는 자료구조이다.

// Creates an array with values [1, 2, 3]
val simpleArray = arrayOf(1, 2, 3)
println(simpleArray.joinToString())
// 1, 2, 3

// Creates an array with values [null, null, null]
val nullArray: Array<Int?> = arrayOfNulls(3)
println(nullArray.joinToString())
// null, null, null

emptyArray는 빈 배열을 생성한다.

Array도 객체이기 때문에 다른 Array 안에 들어 갈 수 있다.

// Creates a two-dimensional array
val twoDArray = Array(2) { Array<Int>(2) { 0 } }
println(twoDArray.contentDeepToString())
// [[0, 0], [0, 0]]

simpleArray[0] = 10
twoDArray[0][0] = 2

fun main() {
    val lettersArray = arrayOf("c", "d")
    printAllStrings("a", "b", *lettersArray)
    // abcd
}

fun printAllStrings(vararg strings: String) {
    for (string in strings) {
        print(string)
    }
}

val simpleArray = arrayOf(1, 2, 3)
val anotherArray = arrayOf(1, 2, 3)

// Compares contents of arrays
println(simpleArray.contentEquals(anotherArray))
// true

// Using infix notation, compares contents of arrays after an element 
// is changed
simpleArray[0] = 10
println(simpleArray contentEquals anotherArray)
// false

val sumArray = arrayOf(1, 2, 3)

// Sums array elements
println(sumArray.sum())
// 6

val simpleArray = arrayOf(1, 2, 3)

// Shuffles elements [3, 2, 1]
simpleArray.shuffle()
println(simpleArray.joinToString())

// Shuffles elements again [2, 3, 1]
simpleArray.shuffle()
println(simpleArray.joinToString())

• Convert arrays to collections

Array를 List와 Set으로 변환 할 수 있다.

.toList()와 .toSet()을 사용하면 된다.

val simpleArray = arrayOf("a", "b", "c", "c")

// Converts to a Set
println(simpleArray.toSet())
// [a, b, c]

// Converts to a List
println(simpleArray.toList())
// [a, b, c, c]

• Type checks and casts

인스턴스가 해당 타입의 객체인지  확인하기 위해서는 is, !is operator를 사용한다.

if (obj is String) {
    print(obj.length)
}

if (obj !is String) { // Same as !(obj is String)
    print("Not a String")
} else {
    print(obj.length)
}

컴파일러는 is, !is로 확인 한 경우에는 안전하게 해당 타입으로 캐스팅을 해준다.

그렇기 때문에 개발자가 직접 타입을 as를 사용하여 변환 할 필요가 없다.

fun demo(x: Any) {
    if (x is String) {
        print(x.length) // x is automatically cast to String
    }
}

if (x !is String) return

print(x.length) // x is automatically cast to String

"Unsafe" cast operator

명시적으로 타입을 캐스팅하고 싶다면 as를 사용한다.

val x: String = y as String

만약 캐스팅이 불가능하다면, Exception이 발생한다.

"Safe" (nullable) cast operator

이런 exception을 피하기 위해서는 as? 연산자를 사용한다.

만약 해당 캐스팅이 실패하면 null이 return 되게 된다.

val x: String? = y as? String

https://kotlinlang.org/docs/basic-syntax.html

Package definition and imports

패키지는 소스파일 가장 위에 명시한다.

package seungkyu

class PackageDefinitionAndImports {

}

코틀린에서는 디렉토리와 패키지를 똑같이 맞출 필요는 없다고 한다.

코틀린 애플리케이션이 시작하는 부분은 main 함수 부분이다.

package seungkyu

fun main(args: Array<String>) {
   println("Hello, world!")

    println(args[0])
}

만약 애플리케이션 실행에서 매개변수를 받고 싶으면, 메인 함수에 저렇게 문자열 배열로 받을 수 있다.

Print to the standard output

print 함수는 매개변수를 standard output에 출력한다.

package seungkyu

fun main(){
    print("seungkyu")
    
    println("seungkyu")
}

println은 print에서 한 line을 차지하여 출력하는 함수이다.

다음 출력은 해당 출력의 다음줄부터 시작된다.

Read from the standard input

readln은 standard input으로부터 읽어오는 함수이다.

이 함수는 한 줄 전체를 읽어온다.

package seungkyu

fun main(){
    print("Enter your name: ")

    val name = readln()

    print("Your name: ")
    println(name)

    println("is contain new line? : ${name.contains("\n")}")
}

엔터키는 제외하고 읽어오는 것을 볼 수 있다.

Functions

아래는 2개의 Int를 매개변수로 받고 Int를 반환하는 함수이다.

fun sum1(a: Int, b: Int): Int {
    return a + b
}

아래와 같이 명시적이라면 return과 괄호를 생략 할 수 있다.

fun sum2(a: Int, b: Int) = a + b

만약 return이 아무것도 반환하지 않는다면 Unit으로 return type을 준다.

fun printSum(a: Int, b: Int): Unit {
    println("sum of $a and $b is ${a + b}")
}

이 때 Unit은 생략이 가능하다.

fun printSum(a: Int, b: Int) {
    println("sum of $a and $b is ${a + b}")
}

Variables

코틀린은 val, var 키워드로 변수 선언이 가능하며, 그 뒤에 변수의 이름을 적어준다.

val은 할당이 한 번만 일어나는 변수를 선언 할 때 사용하며, 후에 값이 변하지 않는다.

선언 이후에는 read-only이다.

val x: Int = 5

그에 비해 var은 선언 이후에도 값을 변경 할 수 있다.

fun main(){
    var x: Int = 5
    x += 1
}

위에서는 변수의 type을 :로 같이 명시해 준 것을 볼 수 있는데, 사실 코틀린은 변수의 타입을 추정이 가능하기 때문에 변수 타입은 생략을 해주어도 된다.

var x = 5

아래와 같이 변수의 타입까지만 선언해두고 값은 나중에 할당하는 것도 가능하다.

fun main(){
    val x = 5
    
    val c: Int
    c = 3
}

자바와는 다르게, 변수를 클래스 밖인 top level에 선언도 가능하다.

val value = 0

fun main(){

    println(value)
}

Creating classes and instances

늘 그렇듯, 클래스를 정의하기 위해서는 class 키워드를 사용한다.

class Shape

클래스의 속성들은 선언이나 body에 작성할 수 있다.

class Rectangle(val height: Double, val length: Double){
    val perimeter = (height + length) * 2
}

이 때, 클래스 선언부에 작성된 매개변수를 바탕으로 기본 생성자가 만들어진다.

class Rectangle(val height: Double, val length: Double){
    val perimeter = (height + length) * 2
}

fun main(){
    val rectangle = Rectangle(10.0, 20.0)
    println("The Perimeter is ${rectangle.perimeter}")
}

클래스 간의 상속은 : 을 사용하면 된다.

클래스는 기본적으로 상속이 불가능한 final 상태이지만, 앞에 open 키워드를 붙여주면 상속 가능한 클래스가 된다.

open class Shape

class Rectangle(val height: Double, val length: Double): Shape() {
    val perimeter = (height + length) * 2
}

Comments

주석은 //와 /* */를 사용해서 작성 할 수 있다.

//주석입니다.

/* 이것은
주석 블럭입니다 */

val mystring = "${1+2}, but now is $a"

조건식도 If를 사용한다.

fun max_result(a: Int, b: Int): Int{
	if (a > b){
    	return a
    }
    else{
    	return b
    }
}

코틀린에서는 3항 연산자가 없으며, 대신 if 또한 표현식으로 사용된다.

fun max_result(a: Int, b: Int) = if (a > b) a else b

fun main(){
    val items = listOf("apple", "banana", "kiwi")
    for (item in items) {
        println(item)
    }
}

fun main(){
    val items = listOf("apple", "banana", "kiwi")
    var index = 0
    while (index < items.size) {
        println("item at $index is ${items[index]}")
        index++
    }
}

fun main(args: Array<String>) {
    val obj = "hi"
    
    val result = when (obj) {
        "hi" -> "hello"
        "hello" -> "hi"
        else -> ""
    }
}

fun main(){
    val x = 10
    val y = 9

    if(x in 1..y+1){
        println("fits in range")
    }
}

반복문에서도 이렇게 사용할 수 있다.

for (x in 1..5){
	print(x)
}

downTo와 step을 사용하여 증가인지 감소인지와 간격을 지정해 줄  수 있다.

fun main(){
    for (x in 1..10 step 2) {
        print(x)
    }
    println()
    for (x in 9 downTo 0 step 3) {
        print(x)
    }
}

Collections

collection을 반복하는 방법

for (item in items){
	println(item)
}

map을 사용하여 해당 collection을 반복 할 수도 있다.

    val fruits = listOf("banana", "avocado", "apple", "kiwifruit")
    fruits
    	//a로 시작하는 단어 찾기
        .filter { it.startsWith("a") }
        //정렬
        .sortedBy { it }
        //대문자로 변환
        .map { it.uppercase() }
        //각각을 출력
        .forEach { println(it) }

fun main(){
    val a: Int? = null
    val b: Int = 1
}

fun getStringLength(obj: Any): Int? {
    if (obj is String) {
        // `obj` is automatically cast to `String` in this branch
        return obj.length
    }

    // `obj` is still of type `Any` outside of the type-checked branch
    return null
}

fun main() {
    fun printLength(obj: Any) {
        println("Getting the length of '$obj'. Result: ${getStringLength(obj) ?: "Error: The object is not a string"} ")
    }
    printLength("Incomprehensibilities")
    printLength(1000)
    printLength(listOf(Any()))
}

거의 1년간 코틀린으로 스프링부트를 사용하고 있었지만, 사실 나의 코틀린은 자바에서 단지 널 안정성만 추가된 언어였다.

물론 널 안정성 만으로도 자바에서 코틀린으로 넘어 올 가치는 있지만, 그래도 더 나은 개발자가 되기 위해서는 코루틴까지 자유롭게 사용할 수 있어야 한다는 생각이 들었다.

코틀린은 아직 한국어 자료가 많이 없기 때문에 이 참에 공식문서를 참고하여 코틀린을 깊게 공부해보려 한다.

https://kotlinlang.org/docs/home.html