12강. 코틀린에서 object 키워드를 다루는 방법

1. static 함수와 변수
2. 싱글톤
3. 익명 클래스

 

static 함수와 변수

  다음은 static 함수와 변수를 가지는 JavaPerson 클래스입니다.

public class JavaPerson {

  private static final int MIN_AGE = 1; // static 변수
  private final String name;
  private final int age;

  private JavaPerson(String name, int age) {
    this.name = name;
    this.age = age;
  }

  public static JavaPerson newBaby(String name) { // static 함수
    return new JavaPerson(name, MIN_AGE);
  }

}

 

  Kotlin으로 구현하면 다음과 같습니다.

class Person private constructor(
    private val name: String,
    private val age: Int,
) {

    companion object {                   // Java의 static 변수와 함수처럼 사용됩니다.
        private const val MIN_AGE = 0    // 컴파일 시 변수가 할당됩니다.
        // private val MIN_AGE = 0       // 런타임 시 변수가 할당됩니다.
        fun newBaby(name: String): Person {
            return Person(name, MIN_AGE)
        }
    }
}

• Kotlin에서는 static 대신 companion object를 사용합니다.
• const: 진짜 상수에 붙이기 위한 용도입니다. 기본 타입과 String에 붙일 수 있습니다.

 

  companion object, 즉 동반객체도 하나의 객체로 간주됩니다. 그러므로 이름을 붙일 수도 있고, interface를 구현할 수도 있습니다.

interface Log {
    fun log()
}

    companion object Factory : Log {     // Java의 static 변수와 함수처럼 사용됩니다.
        private const val MIN_AGE = 0    // 컴파일 시 변수가 할당됩니다.
        // private val MIN_AGE = 0       // 런타임 시 변수가 할당됩니다.
        fun newBaby(name: String): Person {
            return Person(name, MIN_AGE)
        }

        override fun log() {
            println("나는 Person 클래스의 동행객체 Factory 입니다.")
        }
    }

 

  Java에서 Kotlin의 companion object를 사용하려면 @JvmStatic을 붙여줘야 합니다.

Person person = Person.newBaby("Kotlin");

    companion object Factory : Log {                   // Java의 static 변수와 함수처럼 사용됩니다.
        private const val MIN_AGE = 0    // 컴파일 시 변수가 할당됩니다.
        // private val MIN_AGE = 0       // 런타임 시 변수가 할당됩니다.
        @JvmStatic
        fun newBaby(name: String): Person {
            return Person(name, MIN_AGE)
        }

        override fun log() {
            println("나는 Person 클래스의 동행객체 Factory 입니다.")
        }
    }

 

  만약 companion object 이름이 있으면, 이름을 사용하면 됩니다. 기본 이름은 Companion입니다.

Person person = Person.Factory.newBaby("Kotlin");

// 이름이 없는 경우, 기본 이름을 사용할 수 있습니다.
Person person = Person.Companion.newbaby("Kotlin");

 

싱글톤

  싱글톤이란 단 하나의 인스턴스만을 갖는 클래스입니다.

 

  다음은 Java의 Singleton 클래스 입니다.

public class JavaSingleton {

  private static final JavaSingleton INSTANCE = new JavaSingleton();

  private JavaSingleton() {
  }

  public static JavaSingleton getInstance() {
    return INSTANCE;
  }

}

 

  Kotlin에서 싱글톤은 object 키워드만 붙여주면 됩니다.

fun main() {
    println(Singleton.a)
    Singleton.a += 10
    println(Singleton.a)
}

object Singleton { // 싱글톤
    var a: Int = 0
}

 

익명 클래스

  익명 클래스란 특정 인터페이스나 클래스를 상속받은 구현체를 일회성으로 사용할 때 쓰는 클래스입니다.

 

  다음은 익명클래스를 사용한 Java 코드입니다.

public interface Movable {

  void move();

  void fly();

}

  public static void main(String[] args) {
    moveSomething(new Movable() {
      @Override
      public void move() {
        System.out.println("Move!!");
      }

      @Override
      public void fly() {
        System.out.println("Fly!!");
      }
    });
  }

  private static void moveSomething(Movable movable) {
    movable.move();
    movable.fly();
  }

 

  Kotlin으로 구현하면 다음과 같습니다.

fun main() {
    moveSomething(object : Movable {
        override fun move() {
            println("Move!!")
        }

        override fun fly() {
            println("Fly!!")
        }
    })

}

private fun moveSomething(movable: Movable) {
    movable.move()
    movable.fly()
}

• 익명 클래스라는 개념 자체는 동일합니다.
• Java에서는 new 타입이름(), Kotlin에서는 object : 타입이름을 사용합니다.

 

 

 

감사합니다.