4강. 코틀린에서 연산자를 다루는 방법

1. 단항 연산자 / 산술 연산자
2. 비교 연산자와 동등성, 동일성
3. 논리 연산자 / 코틀린에 있는 특이한 연산자
4. 연산자 오버로딩

 

단항 연산자 / 산술 연산자

  Java와 Kotlin 완전 동일합니다.

• 단항 연산자: ++, --
• 산술 연산자: +, -, *, /, %
• 산술대입 연산자: +=, -=, *=, /=, %=

 

비교 연산자와 동등성, 동일성

  Java와 Kotlin 완전 동일합니다.

• 비교 연산자: >, <, >=, <= 

  단, Kotlin은 Java와 다르게 객체를 비교할 때 비교 연산자를 사용하면 자동으로 compareTo를 호출해 줍니다.

 

  다음은 compareTo를 구현한 JavaMoney 클래스입니다.

package com.lannstark.lec04;

import java.util.Objects;
import org.jetbrains.annotations.NotNull;

public class JavaMoney implements Comparable<JavaMoney> {

  private final long amount;

  public JavaMoney(long amount) {
    this.amount = amount;
  }

  public JavaMoney plus(JavaMoney other) {
    return new JavaMoney(this.amount + other.amount);
  }

  @Override
  public int compareTo(@NotNull JavaMoney o) {
    return Long.compare(this.amount, o.amount);
  }

  @Override
  public boolean equals(Object o) {
    if (this == o) {
      return true;
    }
    if (o == null || getClass() != o.getClass()) {
      return false;
    }
    JavaMoney javaMoney = (JavaMoney) o;
    return amount == javaMoney.amount;
  }

  @Override
  public int hashCode() {
    return Objects.hash(amount);
  }

  @Override
  public String toString() {
    return "JavaMoney{" +
        "amount=" + amount +
        '}';
  }

}

 

  Java에서는 두 객체를 비교하기 위해 다음과 같이 구현합니다.

public class Lec04Main {

  public static void main(String[] args) {
    JavaMoney money1 = new JavaMoney(2_000L);
    JavaMoney money2 = new JavaMoney(1_000L);
    if (money1.compareTo(money2) > 0) {
      System.out.println("Money1이 Money2보다 금액이 큽니다.");
    }
  }
}

 

  Kotlin에서는 비교 연산자 사용 시 자동으로 compareTo를 호출해 줍니다.

fun main() {
    val money1 = JavaMoney(2_000L)
    val money2 = JavaMoney(1_000L)
    if (money1 > money2) {
        println("Money1이 Money2보다 금액이 큽니다.")
    }
}

 

동등성(Equality)

• 두 객체의 값이 같은가 입니다.
• Java에서 equals 를 사용합니다.
• Kotlin에서는 == 를 사용합니다. == 를 사용하면 간접적으로 equals를 호출합니다.

 

동일성(Identity)

• 완전히 동일한 객체인지, 즉 주소가 같은지 입니다.
• Java에서 == 를 사용합니다.
• Kotlin에서는 === 를 사용합니다.

    val money3 = JavaMoney(1_000L)
    val money4 = money3
    val money5 = JavaMoney(1_000L)

    println(money3 === money4) // 동일성
    println(money3 == money5)  // 동등성

 

논리 연산자 / 코틀린에 있는 특이한 연산자

  Java와 Kotlin 완전 동일합니다. Java처럼 Lazy 연산을 수행합니다.

• 논리 연산자: AND(&&), OR(||), NOT(!)

fun main() {
  // Lazy 연산
  if (fun1() || fun2()) {
    println("fun1()이 true면 fun2()는 수행되지 않습니다.")
  }
}

fun fun1(): Boolean {
  return true
}

fun fun2(): Boolean {
  return false
}

 

코틀린에 있는 특이한 연산자

• in / !in: 컬렉션이나 범위에 포함되어 있거나 포함되어 있지 않을 때 사용합니다.
• a..b: a부터 b 까지의 범위 객체를 생성할 때 사용합니다.
• a[i]: a에서 특정 Index i로 값을 가져옵니다.
• a[i] = b: a의 특정 index i에 b를 넣습니다.

 

연산자 오버로딩

  Kotlin에서는 객체마다 연산자를 직접 정의할 수 있습니다.

class Money(val amount: Long) {
    operator fun plus(other: Money): Money {
        return Money(this.amount + other.amount)
    }

    override fun toString(): String {
        return "Money(amount=$amount)"
    }
}

fun main() {
    ... 생략 ...
    
    // 연산자 오버로딩
    val money6 = Money(1_000L)
    val money7 = Money(2_000L)
    println(money6 + money7) // money6.plus(money7)
}

 

감사합니다.