[안드로이드 코틀린] 3. 기본 문법(2) - 함수/메소드, 전역변수, 지역변수/클래스, 인스턴스/추가적인 문법

기본 문법

 

함수

fun 함수 이름([변수 이름: 자료형, 변수 이름: 자료형..]): [반환 값 자료형]{	// fun: 함수 예약어
    표현식...
    [return 반환값]
}

// ex
fun sum(a: Int, b: Int): Int{
    var sum = a + b
    return sum
}

 

1. 코틀린은 다중 패러다임 언어

- 함수형 프로그래밍(FP: Funtional Programming)

- 객체 지향 프로그래밍(OOP: Object-Oriented Programming)

 

2. 함수형 프로그래밍

- 코드 간략, 테스트나 재사용성 증가

- 순수 함수, 람다식, 고차 함수를 사용해 구성

→ ex) main(), sum(), max() 함수

 

3. 일반적 선언

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

 

4. 간략한 선언

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

 

예제

fun sum(a: Int, b: Int): Int{
    var sum = a + b
    return sum
}

fun main() {
    val result1: Int
    val result2: Int

    result1 = sum(3, 2) // IntelliJ IDEA에서 매개변수(a: 3, b: 2)를 보여줌
    result2 = sum(6, 7) // IntelliJ IDEA에서 매개변수(a: 6, b: 7)를 보여줌

    println(result1)
    println(result2)
}

 

fun main() {    // 최초의 스택 프레임
    val num1 = 10   // 임시 변수 혹은 지역 변수
    val num2 = 3    // 임시 변수 혹은 지역 변수
    val result: Int

    result = max(num1, num2) // 두 번째 스택 프레임
    println(result)
}

fun max(a: Int, b: Int) = if (a > b) a else b // a와 b는 max의 임시 변수

 

// 두개의 숫자를 입력 받아서 덧셈, 뺄셈, 곱셈을 함수를 이용해 출력하시오

fun sum(a: Int, b: Int) = a + b
fun sub(a: Int, b: Int): Int = a - b
fun mul(a: Int, b: Int): Int{
    return a * b
}

fun main() {
    var num1: Int
    var num2: Int

    print("number1 = ")
    num1 = readLine()!!.toInt()     // !! : 반드시 입력받아라 -> 코틀린의 경우 .만쓰면 오류나므로 !!써줘야함
    print("number2 = ")
    num2 = readLine()!!.toInt()

    println("number1+number2 = ${sum(num1, num2)}")
    println("number1-number2 = ${sub(num1, num2)}")
    println("number1*number2 = ${mul(num1, num2)}")
}

※ 만약 다른 파일에서 sum()을 써서 오버라이딩이 되었다면, 함수의 이름을 바꿔라

 

 

순수 함수(pure function) (→ 일반적으로 알고 있는 함수)

- 부작용(side-effect)이 없는 함수

    - 동일한 입력 인자에 대해서는 항상 같은 결과를 출력 혹은 반환함

    - 값이 예측이 가능해 결정적임

fun sum(a: Int, b: Int): Int{
    return a + b	// 동일한 인자인 a, b를 입력 받아 항상 a + b를 출력(부작용이 없음)
}

- 순수 함수의 조건

    - 같은 인자에 대하여 항상 같은 값을 반환

    - 함수 외부의 어떤 상태도 바꾸지 않음

 

 

람다식(Lambda Expression)

- 익명 함수의 하나의 형태로 이름이 없이 사용 및 실행이 가능

- 람다 대수(Lambda calculus)로 부터 유래

(x, y -> x + y)

 

- 람다식의 이용

    - 람다식은 고차 함수에서 인자로 넘기거나 결과값으로 반환 등을 할 수 있음

    - 변수에 람다식 적용

fun main(){
    var result: Int
    val multi = {x: Int, y: Int -> x * y}	// 일반 변수에 람다식 할당
    
    result = multi(10, 20)	// 람다식이 할당된 변수는 함수처럼 사용 가능
    println(result)
}

 

- 람다식

// 피라미터 2개를 받아서 함계를 출력하는 일반적인 메소드 형식
fun addNumber(n1: Int, n2: Int): Int{
    return n1 + n2
}
// 람다식으로 표현
val addNumbe = {n1: Int, n2: Int -> n1 + n2}

 

- 특징

1. 람다식은 { }로 감싸며 fun 예약어를 사용하지 않음

2. { } 안 ->의 왼쪽은 파라미터, 오른쪽은 함수의 내용

3. -> 오른쪽 문장이 여러 개라면 세미콜론(;)으로 구분

4. 내용 중 마지막 문장을 반환 값(return)임

// ex) 버튼을 클릭했을 때 실행되는 람다식
버튼변수.SetOnClickListener{
    // 버튼을 클릭하면 실행될 내용
}

 

 

고차 함수(high-order function)

- 일반 함수를 인자나 반환값으로 사용

fun main(){
    println(highFunc({x, y -> x + y}, 10, 20))	// 람다식 함수를 인자로 넘김
}

fun highFunc(sum: (Int, Int) -> Int, a: Int, b: Int): Int = sum(a, b)	// sum 매개변수 함수

 

---

메소드와 전역변수, 지역변수

메소드

- 기본 메소드인 main( ) 함수 외에 사용자가 메소드를 추가로 생성할 수 있음

- 메소드를 호출할 때 파라미터를 넘길 수 있음

- 메소드에서 사용된 결과를 return 문으로 돌려줄 수도 있음

 

변수

- 전역변수(global variable)

    - 전역변수는 모든 메소드에서 사용됨

 

- 지역변수(local variable)

    - 메소드 내부에서만 사용됨

var myVar: Int = 100    // 전역변수
fun main() {
    var myVar: Int = 0     // 지역변수
    println(myVar)

    var sum: Int = addFunction(10, 20)
    println(sum)
}

fun addFunction(num1: Int, num2: Int): Int{
    var hap: Int
    hap = num1 + num2 + myVar
    return  hap
}

// 결과
// 0
// 130

 

---

클래스와 인스턴스

클래스(class)

- 변수(필드)와 메소드로 구성

- 객체지향 관점에서의 클래스 : 실세계의 객체들이 가질 수 있는 상태(변수)와 행동(메소드)

 

class Car{
    var color: String = ""
    var speed: Int = 0

    fun upSpeed(value: Int){
        if(speed+value >= 200)
            speed = 200
        else
            speed = speed + value
    }
    fun downSpeed(value: Int){
        if(speed-value <= 0)
            speed = 0
        else
            speed = speed - value
    }
}

fun main() {
    var myCar1: Car = Car()
    myCar1.color = "빨강"
    myCar1.speed = 0

    var myCar2: Car = Car()
    myCar2.color = "파랑"
    myCar2.speed = 0

    var myCar3: Car = Car()
    myCar3.color = "초록"
    myCar3.speed = 0

    myCar1.upSpeed(50)
    println("자동차1의 색상은 " + myCar1.color + "이며, 속도는 " + myCar1.speed + "km입니다.")

    myCar2.upSpeed(20)
    println("자동차2의 색상은 " + myCar2.color + "이며, 속도는 " + myCar2.speed + "km입니다.")

    myCar3.upSpeed(250)
    println("자동차3의 색상은 " + myCar3.color + "이며, 속도는 " + myCar3.speed + "km입니다.")
}

 

- 생성자 코드 추가 → 위의 코드를 개선(아래 코드)

class Car{
    var color: String = ""
    var speed: Int = 0
    
    constructor(color: String, speed: Int){		// 생성자 코드 추가
        this.color = color
        this.speed = speed
    }

    fun upSpeed(value: Int){
        if(speed+value >= 200)
            speed = 200
        else
            speed = speed + value
    }
    fun downSpeed(value: Int){
        if(speed-value <= 0)
            speed = 0
        else
            speed = speed - value
    }
}

fun main() {   
    var myCar1:Car = Car("빨강", 0)
    var myCar2:Car = Car("파랑", 0)
    var myCar3:Car = Car("초록", 0)

    myCar1.upSpeed(50)
    println("자동차1의 색상은 " + myCar1.color + "이며, 속도는 " + myCar1.speed + "km입니다.")

    myCar2.upSpeed(20)
    println("자동차2의 색상은 " + myCar2.color + "이며, 속도는 " + myCar2.speed + "km입니다.")

    myCar3.upSpeed(250)
    println("자동차3의 색상은 " + myCar3.color + "이며, 속도는 " + myCar3.speed + "km입니다.")
}

 

- 메소드 오버로딩

    - 한 클래스 내에서 메소드의 이름이 같아도 파라미터의 개수나 데이터 형식만 다르면 여러 개를 선언할 수 있음

 

class Car{
    var color: String = ""
    var speed: Int = 0

    constructor(color: String, speed: Int){     // 생성자 코드 추가
        this.color = color
        this.speed = speed
    }

    constructor(color: String){     // 메소드 오버로딩
        this.color = color
    }

    constructor(speed: Int){     // 메소드 오버로딩
        this.speed = speed
    }

    constructor(){     // 메소드 오버로딩
        
    }

    fun upSpeed(value: Int){
        if(speed+value >= 200)
            speed = 200
        else
            speed = speed + value
    }
    fun downSpeed(value: Int){
        if(speed-value <= 0)
            speed = 0
        else
            speed = speed - value
    }
}

fun main() {
//    생략
}

 

정적 필드, 정적 메소드, 상수 필드

- 정적 필드(static field)

    - 인스턴스를 생성하지 않고 클래스 자체에서 사용되는 변수

    - companion object { } 안에 작성하여 정적 필드를 만듦

 

- 정적 메소드(static method)

    - 메소드 또한 companion object { } 안에 작성하면 됨

    - 인스턴스를 생성하지 않고도 ‘클래스명.메소드명( )’으로 호출하여 사용 가능

 

- 상수 필드

    - 정적 필드에 초깃값을 입력하고 const val로 선언

    - 선언한 후에는 값을 변경할 수 없음

    - 상수 필드는 대문자로 구성하는 것이 일반적임

    - 클래스 안에 상수를 정의할 때 사용

 

class Car{
    var color: String = ""
    var speed: Int = 0

    companion object{
        var carCount: Int = 0           // 정적 필드
        const val MAXSPEED: Int = 200   // 상수 필드
        const val MINSPEED: Int = 0     // 상수 필드
        fun currentCarCount(): Int{     // 정적 메소드
            return carCount
        }
    }

    constructor(color: String, speed: Int){     // 생성자 코드 추가
        this.color = color
        this.speed = speed
    }

    constructor(color: String){     // 메소드 오버로딩
        this.color = color
    }

    constructor(speed: Int){     // 메소드 오버로딩
        this.speed = speed
    }

    constructor(){     // 메소드 오버로딩

    }

    fun upSpeed(value: Int){
        if(speed+value >= 200)
            speed = 200
        else
            speed = speed + value
    }
    fun downSpeed(value: Int){
        if(speed-value <= 0)
            speed = 0
        else
            speed = speed - value
    }
}

fun main() { 
    var myCar1:Car = Car("빨강", 0)
    var myCar2:Car = Car("파랑", 0)
    var myCar3:Car = Car("초록", 0)

    println("생산된 차의 대수(정적 필드) ==> " + Car.carCount)
    println("생산된 차의 대수(정적 메소드) ==> " + Car.currentCarCount())
    println("차의 최고 제한 속도 ==> " + Car.MAXSPEED)

    println("PI의 값 ==> " + Math.PI)
    println("3의 5제곱 ==> " + Math.pow(3.0, 5.0))
}

// 결과
// 생산된 차의 대수(정적 필드) ==> 0
// 생산된 차의 대수(정적 메소드) ==> 0
// 차의 최고 제한 속도 ==> 200
// PI의 값 ==> 3.141592653589793
// 3의 5제곱 ==> 243.0

 

클래스 상속(inheritance)

- 기존의 클래스가 가지고 있는 것을 그대로 물려받으면서 필요한 필 드나 메소드를 추가로 정의하는 것을 의미함

 

open class Car{
    var color: String = ""
    var speed: Int = 0

    companion object{
        var carCount: Int = 0           // 정적 필드
        const val MAXSPEED: Int = 200   // 상수 필드
        const val MINSPEED: Int = 0     // 상수 필드
        fun currentCarCount(): Int{     // 정적 메소드
            return carCount
        }
    }

    constructor(color: String, speed: Int){     // 생성자 코드 추가
        this.color = color
        this.speed = speed
    }

    constructor(color: String){     // 메소드 오버로딩
        this.color = color
    }

    constructor(speed: Int){     // 메소드 오버로딩
        this.speed = speed
    }

    constructor(){     // 메소드 오버로딩

    }

    open fun upSpeed(value: Int){
        if(speed+value >= 200)
            speed = 200
        else
            speed = speed + value
    }
    fun downSpeed(value: Int){
        if(speed-value <= 0)
            speed = 0
        else
            speed = speed - value
    }
}

class Automobile: Car{
    var seatNum: Int = 0

    constructor(){

    }
    fun conutSeatNum(): Int{
        return seatNum
    }

    override fun upSpeed(value: Int){
        if (speed + value >= 300)
            speed = 300
        else
            speed = speed + value
    }
}

fun main() {
    var auto: Automobile = Automobile()
    auto.upSpeed(250)
    println("승용차의 속도는 " + auto.speed + "km입니다.")
}

// 결과
// 승용차의 속도는 250km입니다.

 

클래스 상속 - 추상클래스와 메소드

- 추상(abstract) 클래스

    - 추상 클래스는 인스턴스 생성 불가

    - 추상 클래스는 클래스 앞에 abstract 키워드를 붙여서 지정함

    - 인스턴스화란

var myCar1: Car = Car("빨강", 0)
var myCar2: Car = Car("초록", 0)
var myCar3: Car = Car("파랑", 0)

var auto: Automobile = Automobile()

 

- 추상 메소드

    - 본체가 없는 메소드

    - 메소드 앞에 abstract 키워드를 붙여서 지정

        - 추상 메소드를 포함하는 클래스는 추상 클래스로 지정해야 함

 

- 추상 클래스와 추상 메소드를 사용하는 목적

    - 공통적으로 사용되는 기능을 추상 메소드로 선언 해놓고, 추상 클래스를 상속받은 후에 추상 메소드를 오버라이딩해서 사용하기 위함

    - ‘구현한다(implement)’ : 추상 메소드를 오버라이딩하는 것을 의미함

    - 동물 클래스를 추상 클래스로 만들고 추상 메소드인 ‘이동한다( )’를 포함함

abstract class Animal {
    var name: String = ""
    abstract fun move()
}

class Tiger: Animal(){
    var age: Int = 0
    override fun move(){
        println("네 발로 이동한다.")
    }
}

class Eagle: Animal(){
    var home: String = ""
    override fun move(){
        println("날개로 날아간다.")
    }
}

fun main() {
    var tiger1 = Tiger()    // var tiger1 = Animal()은 불가, 추상 클래스이므로 
    var eagle1 = Eagle()

    tiger1.move()
    eagle1.move()
}

 

클래스 상속 - 클래스 변수의 다형성

- 다형성(polymorphism)

    - 서브클래스에서 생성한 인스턴스를 자신의 클래스 변수에 대입할 수 있는 것을 의미함

    - 하나의 변수에 여러 종류의 인스턴스를 대입할 수 있음

// 위 코드의 Animal, Tiger, Eagle 클래스와 동일

fun main() {
    var animal: Animal  // animal: 클래스 변수

    animal = Tiger()
    animal.move()

    animal = Eagle()
    animal.move()
}

 

클래스 상속 - 인터페이스와 다중 상속

- 인터페이스(interface)

    - 추상 클래스와 성격이 비슷함

    - interface 키워드를 사용하여 정의하고 내부에는 추상 메소드를 선언함

    - 클래스에서 인터페이스를 받아 완성할 때 상속과 마찬가지로 ‘ : 인터페이스 이름’ 형식을 사용함

    - 인터페이스는 ‘상속받는다’고 하지 않고 ‘구현한다’고 함

    - Kotlin은 다중 상속을 지원하지 않음

        - 대신 인터페이스를 사용하여 다중 상속과 비슷하게 작성할 수 있음

abstract class Animal {
    var name: String = ""
    abstract fun move()
}

interface iAnimal{
    abstract fun eat()
}

class iCat: iAnimal{
    override fun eat(){
        println("생선을 좋아한다.")
    }
}

class iTiger: Animal(), iAnimal{
    override fun move() {
        println("네 발로 이동한다.")
    }

    override fun eat() {
        println("멧돼지를 잡아먹는다.")
    }
}

class Eagle: Animal(){
    var home: String = ""
    override fun move(){
        println("날개로 날아간다.")
    }
}

fun main() {
    var cat = iCat()
    cat.eat()

    var tiger = iTiger()
    tiger.move()
    tiger.eat()
}

// 결과
// 생선을 좋아한다.
// 네 발로 이동한다.
// 멧돼지를 잡아먹는다.

 

---

추가적인 문법

프로젝트, 모듈, 패키지

프로젝트, 모듈, 패키지, 파일의 관계

모듈: 패키지들의 묶음

가장 기본적인 패키지: default, 아무것도 쓰지 않아도 기본 생성됨

 

패키지

- 클래스와 인터페이스가 많아지면 관리하기가 어렵기 때문에 패키지 단위로 묶어서 관리함

- 사용자가 생성한 클래스가 포함될 패키지는 *.kt 파일 첫 행에 아래와 같이 지정

package 패키지명

- 안드로이드에서 제공하는 패키지 목록 확인 링크: https://developer.android.com/reference/kotlin/packages

- 자바 프로젝트처럼 디렉터리와 매치 되어야 하지는 않음

package com.example.edu

class Person(val name: String, val age: Int)
...

- 패키지를 지정하지 않으면 이름이 없는 기본(default) 패키지 포함

- import의 이름이 충돌하면 as 키워드로 로컬에서 사용할 이름을 변경 후 사용

import com.example.edu.Person
import com.example.edu.Person as User 
// com.example.edu.Person을 User로 지정

- import는 클래스 뿐만 아니라 다른 것도 임포트 할 수 있음

    - 최상위레벨 함수와 프로퍼티, 오브젝트 선언의 함수와 프로퍼티, 열거형 상수

 

- 패키지 정의

패키지 이름	설명
kotlin.*	Any, Int, Double 등 코어 함수와 자료형
kotlin.text.*	문자와 관련된 API
kotlin.sequences.*	컬렉션 자료형의 하나로 반복이 허용되는 개체를 열거
kotlin.ranges.*	If문이나 for문에서 사용할 범위 관련 요소
kotlin.io.*	입출력 관련 API
kotlin.collections.*	List, Set, Map 등의 컬렉션
kotlin.annotation.*	애노테이션 관련 API

 

제네릭스(Generics)

: 데이터 형식의 안전성을 보장

- 제네릭스를 사용하여 strList에 문자열만 들어가도록 설정할 수 있음

    - 다음 코드의 마지막 행은 컴파일 오류가 발생

var strList = ArrayList<String>(4)
strList.add("첫 번째")
strList.add("두 번째")
strList.add(3)

    - 제네릭스는 <String>뿐 아니라 <Int>, <Double> 등을 사용할 수 있음

    - 사용자가 정의한 클래스 형에도 사용할 수 있음

 

try ~ catch

- 예외(exception)

: Kotlin 프로그램 실행 중에 발생하는 오류로 실행 도중의 잠재적인 오류까지 검사할 수 없기 때문에 정상적으로 실행이 되다가 비정상적으로 프로그램이 종료되는 경우

    - 운영체제의 문제 (잘못된 시스템 호출의 문제)

    - 입력값의 문제 (존재하지 않는 파일 혹은, 숫자 입력란에 문자 입력 등)

    - 받아들일 수 없는 연산 (0으로 나누기 등)

    - 메모리의 할당 실패 및 부족

    - 컴퓨터 기계 자체의 문제 (전원 문제, 망가진 기억 장치 등)

try {
	// 예외 발생 가능성 있는 문장
} catch (e: 예외처리 클래스명) {
	// 예외를 처리하기 위한 문장
} finally {
	// 반드시 실행되어야 하는 문장
}

 

fun main() {
    var num1: Int = 1000
    var num2: Int = 0
    try {
        println(num1/num2)
    } catch (e: ArithmeticException){
        println("계산에 문제가 있습니다")
    }
}

 

fun main() {
    val a = 6
    val b = 0
    val c: Int

    try {
        c = a/b
    } catch (e: Exception){
        println("Exception is handled")
    } finally {
        println("finally 블록은 반드시 항상 실행됨")
    }
}

// 결과
// Exception is handled
// finally 블록은 반드시 항상 실행됨

// b가 0이 아닌 다른 정수일 경우 try문과 finally 문이 실행됨

 

날짜 형식

- DateFormat 클래스를 상속받은 SimpleDate Format 사용

    - ‘연월일’이나 ‘시분초’와 같은 일반적인 표현이 가능함

import java.text.DateFormat
import java.text.SimpleDateFormat
import java.util*

fun main(){
	var now = Date()
    var sFormat: SimpleDateFormat
    
    sFormat = SimpleDateFormat("yyyyMMdd")
    sFormat = SimpleDateFormat("HH:mm:ss")
    println(sFormat.format(now)) 	 // 23:15:21 형식으로 출력 
}

 

기타 함수

문자열 비교

- String 클래스의 equals( ) 메소드 사용

var str: String = "안녕하세요"
if (str.equals("안녕하세요)) {
    // 문자열이 같으면 이곳을 수행
}

 

 

문자열 비교

- String 클래스의 equals( ) 메소드 사용

// fun <T, R> T.let(block: (T) -> R): R
val result = str?.let {		// Int
    Integer.parseInt(it)
}

 

with( ) 함수

- 인자로 객체를 받고 블록에서 수행된 결과를 반환하는 함수

// fun <T, R> with(receiver:T, block T.() -> R): R
with(str) {
    println(toUpperCase())
}

 

apply( ) 함수

- 블록에 자기 자신을 전달하고 이 객체를 반환하는 함수

// fun <T> T.apply(block: T.() -> Unit): T
val result = car?.apply {
    car.setColor(Color.RED)
    car.setPrice(1000)
}

 

run( ) 함수

- 익명함수처럼 사용하거나, 블록에 자기 자신을 전달하고 수행된 결과를 반환하는 함수

// fun <R> run(block: () -> R): R
val avg = run {
    val korean = 100
    val english = 80
    val math = 50
    
    (korean + english + math) / 3.0
}

- 객체에서 호출하는 방법은 객체를 블록의 리시버 객체로 전달하고 블록의 결과를 반환함

- 안전한 호출을 사용할 수 있어서 with ( ) 함수보다는 더 유용함

// fun <T, R> T.run(block: T.() -> R): R
str?.run {
    println(toUpperCase())
}

 

컬렉션

리스트

- 배열같은 자료형의 데이터들을 순서대로 가지고 있는 자료구조

- 중복된아이템을 가질 수 있고 추가, 삭제, 교체 등이 쉬움

// 요소를 변경할 수 없는 읽기 전용 리스트는 listOf() 메서드로 작성할 수 있음
val foods: List<String> = listOf("라면", "갈비", "밥")

// 형추론으로 자료형을 생략할 수 있음
val foods = listOf("라면", "갈비", "밥")

// 요소를 변경하는 리스트를 작성할 때는 mutableListOf ( ) 메서드를 사용함
val foods = mutableListOf("라면", "갈비", "밥")

foods.add("초밥")       // 초밥을 맨 뒤에 추가
foods.removeAt(0)      // 맨 앞의 아이템 삭제
foods[1] = "부대찌개"   // foods.set(1, "부대찌개") (1번째 아이템을 부대찌개로 변경)

println(foods)  	// [갈비, 부대찌개, 초밥]
println(foods[0])   // 갈비
println(foods[1])   // 부대찌개
println(foods[2])   // 초밥

 

맵

- 키key와 값value의 쌍으로 이루어진 키가 중복될 수 없는 자료구조

// 맵의 요소에 접근할 때는 대괄호 안에 키key를 요소명으로 작성하여 접근
// 읽기 전용 맵
val map = mapOf("a" to 1, "b" to 2, "c" to 3)

// 변경 가능한 맵
val citiesMap = mutableMapOf("한국" to "서울". "일본" to "동경", "중국" to "북경")

// 요소에 덮어쓰기
citiesMap["한국"] = "서울특별시"
// 추가
citiesMap["미국"] = "워싱턴"
        
        
// 맵 전체의 키와 값을 탐색할 때는 간단히 탐색할 수 있음
// 맵의 키와 값을 탐색
for((k, v) in map){
    println("$k -> $v")
}

 

집합

- 집합set은 중복되지 않는 요소들로 구성된 자료구조

- setOf ( ) 메서드로 읽기 전용 집합을 mutableSetOf( ) 메서드로 수정 가능한 집합 생성

// 읽기 전용 집합
val citySet = setOf("서울", "수원", "부산")

// 수정 가능한 집합
val citySet2 = mutableSetOf("서울", "수원", "부산")
citySet2.add("안양")      // [서울, 수원, 부산, 안양]
citySet2.add("안양")      // [서울, 부산, 안양]

// 집합의 크기
println(citySet2.size)  // 3
// '서울'이 집합에 포함되어있는지
println(citySet2.contains("서울"))    // true

 

연산자 정리

연산자	설명
+, -, *, /, %	사칙 연산자로 %는 나머지값을 계산한다.
+, -	부호 연산자로 변수, 수, 식, 앞에 붙일 수 있다.
=	대입 연산자로 오른쪽을 왼쪽에 대입한다.
++, --	1씩 증가 또는 감소시킨다.
==, ===, !=, !==, <, >, <=, >=	비교 연산자로 결과는 true 또는 false이며, if 문이나 반복문의 조건식에 주로 사용된다.
&&, ||, !	논리 연산자로 and, or, not을 의미한다.
and, or, xor, inv()	비트 연산자로, 비트 단위로  and, or, exclusive or, not 연산을 한다.
shr, shi	시프트 연산자로, 비트 단위로 왼쪽 또는 오른쪽으로 이동한다.
+=, -=, *=, /=	복합 대입 연산자로, 'a += b'는 'a = a+b'와 동일하다.
toByte(), toShort(), toInt(), toLong(), toFloat(), toDouble(), toChar()	데이터 형식을 강제로 변환하는 함수이다. 예를 들어 'var a: Int = (3.14).toInt()'는 Double형인 3.14 값을 int형으로 강제로 변환하여 a에 대입한다. 즉 a에 3이 대입된다.

 

형변환

// 숫자형 자료형끼리는 to자료형() 메서드를 사용하여 형변환이 가능
val a = 10L
val b = 20

val c = a.toInt()       // Long을 Int로
val d = b.toDouble()    // Int를 Double로
val e = a.toString()    // Long을 String으로

// 숫자형 문자열을 숫자로 바꿀 때는 Integer.parseInt() 메서드 사용
val intStr = "10"
val str = Integer.parseInt(intStr)

// 일반 클래스 간에 형변환을 하려면 as 키워드를 사용함.
open class Animal

class Dog: Animal()

val dog = Dog()

val animal = dog as Animal  // dog를 Animal형으로 변환

//
val str = "hello"

if (str is String) {    // str이 String형이라면
    println(str.toUpperCase())
}