오브젝트 & 옵저버 패턴

오브젝트

• 생성자 없이 직접 객체를 만들어낸다.
• 오브젝트 그 자체가 객체가 될 수 있다. 그래서 생성자가 필요 없다.
• 클래스는 내부에 있는 속성이나 함수를 사용하려면 생성자를 통해 실체가 되는 인스턴스 객체를 만들어야한다.
• 하지만 여러개의 인스턴스 객체가 필요하지 않고 하나의 객체만으로 공통적인 속성과 함수를 사용해야하는 코드에서는 클래스를 쓸 필요 없이 오브젝트를 사용하면 된다.
• 싱글톤 패턴을 언어차원에서 지원하는것이다.
  • 싱글톤 패턴 : 클래스의 객체를 단 하나만 만들어 사용하도록 하는 디자인 패턴

 

 

오브젝트 예제

• 아무곳에나 호출하여 호출한 횟수를 세거나 초기화 할 수 있는 Counter라는 오브젝트를 만들어보자.
• 오브젝트는 별도의 인스턴스를 생성하지 않기 때문에 오브젝트 이름에 직접 참조연산자를 붙여서 사용한다.

fun main(){
    println(Counter.count)

    Counter.countUp()
    Counter.countUp()

    println(Counter.count)
    
    Counter.clear()
    
    println(Counter.count)
}

object Counter{
    var count = 0

    fun countUp(){
        count++
    }

    fun clear(){
        count = 0
    }
}

출력
0
2
0

 

• 오브젝트로 선언된 객체는 맨처음 사용할때부터 자동으로 생성된다.
• 이후에는 코드 전체에서 공용으로 사용될 수 있기 때문에 프로그램이 종료되기 전까지 공통적으로 사용할 내용들을 묶어 만드는것이 좋다.

 

 

컴패니언 오브젝트(Companion Object)

• 클래스 안에서 오브젝트를 만들 수 있다.
• 클래스의 인스턴스 기능은 그대로 사용하고, 인스턴스간의 공용으로 사용할 속성과 함수를 별도로 만든다.
  • 스태틱(Static) 멤버랑 비슷하다고 생각하면 된다. 
    • Static 멤버 : 클래스 내부에서 별도의 영역에 고정적으로 존재한다. 인스턴스를 생성하지 않아도 공용적으로 사용할 수 있는 속성이나 함수다.

 

 

컴패니언 오브젝트 예제

닭발과 곰장어 중 어느것이 좋은지 선택하는 설문조사를 해보자. 각각의 투표수와 총 투표수가 동시에 집계되도록 할것이다.

fun main(){
    var chicken_feet = FoodPoll("닭발")   // 닭발 인스턴스 생성
    var hagfish = FoodPoll("곰장어")   // 곰장어 인스턴스 생성

    chicken_feet.vote()
    chicken_feet.vote()
    chicken_feet.vote()
    hagfish.vote()
    hagfish.vote()
    chicken_feet.vote()

    println("${chicken_feet.name} : ${chicken_feet.count}")
    println("${hagfish.name} : ${hagfish.count}")
    println("총계 : ${FoodPoll.total}")
}

class FoodPoll(val name : String){
    companion object{
        var total = 0   // 총 투표수
    }

    var count = 0   // 개별 투표수

    fun vote(){
        count++
        total++
    }
}

출력
닭발 : 4
곰장어 : 2
총계 : 6

닭발과 곰장어는 서로 다른 인스턴스 임에도  컴패니언 오브젝트에 있는 total을 공유하고 있기 때문에  닭발과 곰장어 둘의 인스턴스에서 동시에 투표수를 누적할 수 있다.

 

 

옵저버 패턴

• 옵저버는 이벤트가 일어나는 것을 감시하는 역할을 한다.
• 안드로이드에서의 이벤트는 함수로 직접 요청하지 않았지만 시스템에 의해서 발생하게 되는 동작들이다.
  • ex ) 키 입력, 터치 발생, 데이터 수신
• 이 이벤트들이 발생할때마다 즉각적으로 처리할 수 있도록 만드는 프로그래밍 패턴들을 옵저버 패턴이라고 한다.

 

 

옵저버 동작 방식

• 옵저버 패턴을 구현할 때는 두개의 클래스가 필요하다.
  • 이벤트를 수신하는 클래스
  • 이벤트를 발생시켜 전달해주는 클래스
• 두 클래스 사이에는 인터페이스가 있어야한다. 
  • 이벤트를 발생시켜 전달해주는 클래스에서는 자신의 이벤트를 받을 수 있는 인터페이스를 만들어 공개하고 이벤트를 수신하는 클래스는 이를 구현하여 이벤트를 발생시켜 전달해주는 클래스에게 넘겨준다.
  • 이러면 인터페이스만 알아도 이벤트를 넘겨줄 수 있다. 
  • 이 때 이 인터페이스를 '옵저버' 또는 코틀린에서는 '리스너' 라고 부르며 이렇게 이벤트를 넘겨주는 행위를 '콜백' 이라고 한다.

 

 

옵저버 패턴 예제1

• 이벤트를 수신해서 출력하는EventPrinter 클래스와
• 숫자를 세며 5의 배수마다 이벤트를 발생시킬 Counter 클래스와
• 이 두 클래스를 연결시킬 인터페이스인 EventListener을 구현할것이다.

fun main(){
    EventPrinter().start()
}

// 이벤트가 발생할 때 숫자를 반환한다.
interface EventListener{
    fun onEvent(count: Int)     // 추상함수
}

// 이벤트가 발생하는 Counter 클래스
class Counter(var listener: EventListener){     // 이벤트를 발생시키기 위해 생성자에서 EventListener를 속성으로 받는다.
    fun count(){
        for(i in 1..100){
            if(i % 5 == 0)
                listener.onEvent(i)     // 5의 배수가 될때마다 EventListner의 onEvent() 호출
        }
    }
}

// 이벤트를 받아서 화면에 출력할 EventPrinter 클래스
class EventPrinter: EventListener{      // EventListener을 상속받는다
    override fun onEvent(count: Int) {  // onEvent 함수를 오버라이드하여 받아온 숫자와 대시문자를 출력한다.
        print("${count}-")      
    }
    
    fun start(){
        // Counter의 인스턴스를 만들때 this키워드로 EventListener 구현부를 넘겨준다.
        // this는 EventPrinter 객체 자신을 나타내지만 받는 쪽에서 EventListener만 요구했기 때문에 EventListener 구현부만 넘겨준다.
        // 이를 객체지향의 다형성 이라고 한다.
        // 상속받아 만든 클래스는 슈퍼 클래스의 기능을 포함하여 제작되었으므로 슈퍼클래스에서 정의한 부분만 따로 넘겨줄 수 있다.
        var counter = Counter(this)     
        counter.count()
    }
}

출력
5-10-15-20-25-30-35-40-45-50-55-60-65-70-75-80-85-90-95-100-

Counter가 5의 배수마다 이벤트를 발생시킨 것을 EventPrinter 내에서 구현된 EventListener에서 출력하고 있다.

 

 

옵저버 패턴 예제2 

• EventPrinter가 EventListener를 상속받아 구현하지 않고 임시로 만든 별도의 EventListener 객체를 대신 넘겨줄 수 도 있다.
• 이것을 이름 없는 개체라고 하여 '익명 객체' 라고 한다.
• 이번에는 EventListener를 상속받지 않고 바로 start함수를 만들어 보자.
• Counter 인스턴스를 만들때 파라미터에 익명객체를 만들어 넘길건데 여기에 object 키워드가 사용된다.
  • object라고 쓰고 이름없이 바로 콜론을 쓴 후 EventListener를 상속받도록 하고 중괄호를 친 후 onEvent함수를 오버라이드 하면 된다.
• 이렇게 만들면 인터페이스를 구현한 객체를 코드 중간에도 즉시 생성하여 사용할 수 있다.

fun main(){
    EventPrinter().start()
}

// 이벤트가 발생할 때 숫자를 반환한다.
interface EventListener{
    fun onEvent(count: Int)     // 추상함수
}

// 이벤트가 발생하는 Counter 클래스
class Counter(var listener: EventListener){     // 이벤트를 발생시키기 위해 생성자에서 EventListener를 속성으로 받는다.
    fun count(){
        for(i in 1..100){
            if(i % 5 == 0)
                listener.onEvent(i)     // 5의 배수가 될때마다 EventListner의 onEvent() 호출
        }
    }
}

class EventPrinter{
    fun start(){
        val counter = Counter(object:EventListener{
            override fun onEvent(count: Int) {
                print("${count}-")
            }
        })
        counter.count()
    }
}

출력
5-10-15-20-25-30-35-40-45-50-55-60-65-70-75-80-85-90-95-100-

 

 

 

💡오브젝트를 사용하는 경우는 세가지다. 생성자 없이 객체를 만들기,  클래스 안에서의 컴패니언 오브젝트, 옵저버 패턴에서의 익명 객체

💡옵저버 패턴은 이벤트를 기반으로 동작하는 모든 코드에서 광범위하게 쓰인다.