1
2
3
fun max(a: Int, b: Int): Int { // a, b를 비교해서 최댓값을 반환
	return if (a > b) a else b
}

1
fun max(a: Int, b: Int) = if (a > b) else b // 위 max 함수 예시와 같은 기능을 하는 함수

1
2
3
4
5
6
val number: Int = 12
val number = 12

// 초기화 삭이 없다면 반드시 타입을 명시해야 한다
val number: Int
number = 12

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class Person {

	private final String name;

	public Person(String name) {
		this.name = name;
	}

	public String getName() {
		return name;
	}
}

// 위 자바 코드를 코틀린으로 이용하면 다음과 같이 변환할 수 있다.
// 이렇게 변환을 하면 public 가시성 변경자(visibility modifier)가 사라진다.
// 코틀린 기본 가시성은 public이다.
class Person(val name: String)

1
2
3
4
5
6
7
8
9
class Person (
	val name: String, // read-only 프로퍼티로, 비공개 필드와 단순한 getter를 만들어낸다
	var isMarried: Boolean // write가 가능한 프로퍼티로, 비곡개 필드, getter, setter를 만들어 낸다
)

// 자바와의 상용법을 비교하면 다음과 같다 (주석이 자바)
val person = Person("Bob", true) // Person person = new Person("Bob", true);
person.name // person.getName();
person.isMarried = false; // person.setIsMarried(false);

1
2
3
4
5
class Rectangle(val height: Int, val width: Int) {
    
    val isSquare
        get() = (height == width)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
enum class Color (
    val r: Int,
    val g: Int,
    val b: Int
) {
    RED(255, 0, 0),
    ORANGE(255, 165, 0)
    ; // 코틀린에서 유일하게 ';'을 사용하는 부분이다

    fun rgb() = (r * 256 + g) * 256 + b
}

println(Color.RED.rgb())

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 위 예제의 enum Color 사용
fun getColor(color: Color) =
        when (color) {
            Color.RED -> "red"
            Color.ORANGE, Color.YELLOW -> "or" // 한 분기에서 여러 값을 매치 패턴으로 사용할 때 ',' 사용
        }

println(getColor(Color.RED)) // output: red
println(getColor(Color.ORANGE)) // output: or
println(getColor(Color.YELLOW)) // output: or

when (color) {
	Color.Red -> {
			...
			"red"
	} // "red" 반환
}

1
2
3
4
5
fun mix(c1: Color, c2: Color) = 
    when (setOf(c1, c2)) { // Set 생성
        setOf(Color.RED, Color.YELLOW) -> Color.ORANGE
        else -> throw Exception("Dirty color")
    }

1
2
3
4
5
6
fun mix(c1: Color, c2: Color) =
    when {
        (c1 == Color.RED && c2 == Color.YELLOW) 
                ||(c1 == Color.YELLOW && c2 == Color.RED) -> Color.ORANGE
        else -> throw Exception("Dirty Color")
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
interface Expr
class Num(val value: Int): Expr // Expr 인터페이스를 implements한다
class Sum(val left: Expr, val right: Expr): Expr

fun eval(e: Expr): Int {
    if (e is Num) {
				// 타입 체크를 한 뒤 명시적으로 캐스팅을 해주지 않아도 된다.
				// 그럼에도 명시적으로 캐스팅을 해주고 싶다면 val n = e as Num 같이 as키워드를 사용하면 된다.
        return e.value
    } else if (e is Sum) {
        return eval(e.right) + eval(e.left)
    }
    throw IllegalArgumentException("Unkown expression")
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
val oneToTen = 1..10 // 1 ~ 10까지 수를 가진 변수 선언

// 1 ~ 10 까지 1 씩 증가하며 순환
for (i in 1..10) {
	...
}

// 2 씩 감소시키면서 1이 될때 까지 순회, i 초기 값은 10
for (i in 10 downTo 1 step 2) {
	...
}

// 1 ~ 9 까지 1씩 증가하며 순회
for (i in 1 until 10) {
	...
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
val binaryReps = TreeMap<Char, String>()
for (c in 'A'..'F') {
    binaryReps[c] = Integer.toBinaryString(c.code) // 아스키코드를 2진표현으로 바꾼다
}
// key는 맵의 키값, value는 맵의 키에 대응하는 밸류값
for ((key, value) in binaryReps) {
    ...
}

val list = arrayListOf("10", "11", "1001")
// index는 리스트 원소의 인덱스 번호, element는 리스트의 원소
for ((index, element) in list.withIndex()) {
    ...
}

// 변수 c의 값이 a~z 범위에 존재하면 true 반환
fun isLetter(c: Char) = c in 'a'..'z'
// 변수 c의 값이 0~9 범위에 존재하지 않으면 true 반환
fun isNotDigit(c: Char) = c !in '0'..'9'

1
2
println("Kotlin" in "Java".."Scala") // String에는 Comparable 구현이 두 문자열을 알파벳 순서로 비교한다
println("Kotlin" in setOf("Java", "Scala") // 집합에 Kotlin이 들어있나