object 키워드 다루기

static 함수와 변수

• static: 클래스가 인스턴화 될 때, 새로운 값이 복제되는게 아니라 정적으로 인스턴스끼리의 값을 공유
• companion object: 클래스와 동행하는 유일한 오브젝트

class Person private constructor(
    private val name: String,
    private val age: Int
){
    companion object{
        private val MIN_AGE = 1; // 런타임 시에 변수 할당
        private const val MIN_AGE = 1; // 컴파일 시에 변수 할당
        fun newBaby(name: String): Person {
            return Person(name, MIN_AGE)
        }
    }
}

• 런타임 시에 변수가 할당됨
• 컴파일 시에 변수가 할당됨
  • 진짜 상수에 붙이기 위한 용도로 기본 타입과 String에 붙일 수 있다.
• 사용법

println(Person.newBaby("user"))

• 자바와 차이점
  • companion object. 즉, 동반객체도 하나의 객체로 간주된다.
  • 따라서 이름을 붙일 수도 있고, interface를 구현할 수도 있다.

interface Log {
    fun log()
}

class Person private constructor(
    private val name: String,
    private val age: Int
){
    companion object Factory : Log{
        private const val MIN_AGE = 1;
        fun newBaby(name: String): Person {
            return Person(name, MIN_AGE)
        }

        override fun log() {
            println("LOG")
        }
    }
    override fun toString(): String {
        return "Person(name='$name', age=$age)"
    }
}

• 자바에서 Kotlin companion object를 사용하려면 @JvmStatic을 붙여야한다.
  • 만약 companion object 이름이 있으면, 이름을 사용하면 된다.

@JvmStatic
fun newBaby(name: String): Person {
    return Person(name, MIN_AGE)
}

public static void main(String[] args) {
    Person user = Person.newBaby("user");
	//Person user = Person.Factory.newBaby("user");
    System.out.println("user = " + user);
}

싱글톤

• 자바에서 싱글톤
  • 동시에 인스턴스를 사용할 경우를 대비하여 동시성 처리를 조금 더 해주거나
  • 싱글톤이 어떤 클래스에 상속받을 필요가 없다면 enum class를 활용하는 방법도 있다.

public class JavaSingleton {

  private static final JavaSingleton INSTANCE = new JavaSingleton();

  private JavaSingleton() { }

  public static JavaSingleton getInstance() {
    return INSTANCE;
  }

}

• 코틀린에서 싱글톤

object Singleton {}

println(Singleton.a)
Singleton.a += 10
println(Singleton.a)

익명 클래스

• 특정 인터페이스나 클래스를 상속받은 구현체를 일회성으로 사용할 때 쓰는 클래스

public interface Movable {

  void move();

  void fly();

}

public static void main(String[] args) {
    Person user = Person.newBaby("user");
    //    Person user = Person.Factory.newBaby("user");
    System.out.println("user = " + user);

    moveSomething(new Movable() {
      @Override
      public void move() {
        System.out.println("움직이기!!");
      }

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

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

interface Movable {
    fun move()
    fun fly()
}

fun main() {
    println(Person.newBaby("user"))

    println(Singleton.a)
    Singleton.a += 10
    println(Singleton.a)

    moveSomething(object : Movable {
        override fun move() {
            println("움직이기!!")
        }
        override fun fly() {
            println("날기!!")
        }
    })
}

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

정리

• 자바의 static 변수와 함수를 만드려면 코틀린에서는 companion object를 사용해야 한다.
  • companion object 도 하나의 객체로 간주되기 때문에 이름을 붙일 수 있고, 다른 타입을 상속받을 수도 있다.
• 코틀린에서 싱글톤 클래스를 만들 때, object 키워드를 사용해야 한다.
• 코틀린에서 익명 클래스를 만들 때, object : 타입을 사용해야 한다.