[ Swift ] 속성 초기화 시 바로 인스턴스화 하는 경우와 init 생성자를 통한 초기화 뭐가 다르지?

연락처 만들기 과제 해설 영상을 보다가 의문이 든 점이 있다. 

바로 인스턴스를 똑같이 선언하는 것 같은데 = 를 사용하는 경우와 : 을 사용하는 경우가 있었다. 

간단하게 보면 아래와 같다. 

 

= (등호)

등호(=)는 값을 할당할 때 사용된다. 즉, 변수나 상수를 선언하면서 초기 값을 지정한다. 

=을 사용하는 경우, 해당 속성은 클래스가 인스턴스화될 때 바로 값을 가지게 된다.

 

 

: (콜론)

콜론(:)은 타입을 지정할 때 사용된다. 즉, 변수나 상수를 선언할 때 해당 변수나 상수가 가질 수 있는 타입을 명시하는 것이다. 

:을 사용하는 경우, 초기 값을 할당하지 않고 타입만 지정합니다. 초기 값은 생성자에서 할당될 수 있다.

 

 

좀 더 자세하게 알아보자. 

---

🌟 1. 속성 초기화 시 바로 인스턴스화

이 방법은 특정 클래스의 인스턴스가 항상 같은 방식으로 초기화되는 경우에 적합하다.

예를 들어, CoreDataRepository나 PhoneBookMode가 항상 동일한 초기 상태를 가진다면 이 방법이 단순하고 편리할 수 있다.

 

장점

• 단순성과 편리함: 코드를 간단하게 작성할 수 있다. 클래스가 인스턴스화될 때 모든 속성이 즉시 초기화된다.
• 기본값: 특정 속성이 항상 같은 기본 값을 가질 때 유용하다.

단점

• 유연성 부족: 모든 인스턴스가 동일한 방식으로 초기화된다. 외부에서 다른 값을 전달하거나, 다른 방식으로 초기화할 수 없다.
• 테스트의 어려움: 테스트를 위해 특정 값을 가진 인스턴스를 생성하고 싶을 때 불편할 수 있다.

 

 

🌟 2. 생성자를 통한 초기화

이 방법은 클래스 인스턴스가 초기화될 때마다 다른 값이나 객체로 초기화되어야 하는 경우에 적합하다.

예를 들어, 여러 개의 CoreDataRepository 인스턴스가 존재하거나, 다양한 모드를 지원해야 하는 경우 유용하다.

또한, 유닛 테스트 작성 시 다양한 시나리오를 테스트할 수 있어 더 효과적이다.

 

장점

• 유연성: 외부에서 값을 전달받아 초기화할 수 있다. 이를 통해 다양한 설정으로 객체를 생성할 수 있다.
• 의존성 주입: 객체 지향 설계 원칙 중 하나인 의존성 주입(Dependency Injection)을 쉽게 구현할 수 있다. 이는 특히 테스트 용이성과 유지보수성에 큰 이점을 준다.
• 캡슐화: 객체의 상태를 더 잘 관리할 수 있다. 생성자를 통해 초기화되므로, 객체 생성 시 반드시 필요한 값들을 강제할 수 있다.

단점

• 초기 설정의 복잡성: 생성자에서 모든 필수 속성을 초기화해야 하므로 코드가 다소 길어질 수 있다.
• 부가적인 코드 작성: 기본 생성자 외에도 다른 생성자를 작성해야 하는 경우, 부가적인 코드가 필요하다.
• 예시: 유연성의 차이

 

 

🌟 변수를 선언할 때 초기화하지 않고 타입만 지정하는 것이 유용한 경우

1. 초기화가 외부로부터 이루어질 때

생성자나 메서드를 통해 초기화할 경우: 클래스나 구조체가 생성될 때 외부에서 초기화 값을 제공해야 하는 경우이다. 예를 들어, 데이터베이스 연결 객체나 네트워크 매니저와 같이 다양한 설정이 필요한 객체는 생성자를 통해 초기화된다.

class NetworkManager {
    let session: URLSession

    init(session: URLSession) {
        self.session = session
    }
}

//여기서 session은 초기화 시점에서 제공된 값으로 설정

 

 

2. 지연 초기화가 필요할 때

초기화 비용이 큰 객체나 리소스를 사용할 때까지 초기화하지 않도록 지연 초기화(lazy initialization)를 사용할 수 있다.

• 지연 초기화(lazy initialization)
  : lazy 키워드를 사용하여 선언된 속성은 해당 속성이 처음 접근될 때 초기화된다. 이와 같이 선언하면 초기화가 지연되어 실제로 heavyResource에 접근하기 전까지는 HeavyResource 인스턴스가 생성되지 않는다.
• 초기화 시점
  : 클래스 인스턴스가 생성될 때 즉시 초기화되지 않고, 처음 해당 속성에 접근할 때 초기화된다. 따라서 이 코드는 초기화할 때 즉시 인스턴스화하는 코드가 아니다.

class ViewController: UIViewController {
    lazy var heavyResource: HeavyResource = {
        return HeavyResource()
    }()
}

 

 

3. 초기화 순서가 중요할 때

객체 간의 의존성이 있을 때: 특정 객체가 다른 객체에 의존하는 경우, 초기화 순서를 보장하기 위해 선언만 하고 초기화는 나중에 수행할 수 있다.

 

- 의존성 설명: DependencyInjector 클래스는 Service 객체에 의존하고 있다.

DependencyInjector 객체가 생성될 때 Service 객체가 필요하며, 이는 생성자의 매개변수로 전달되어 초기화된다.

 

- 의존성 초기화 순서: DependencyInjector 객체는 service 속성을 초기화할 때 Service 객체가 미리 초기화되어 있어야 한다.

따라서 Service 객체를 먼저 생성하고 이를 DependencyInjector의 생성자에 전달해야 한다.

class DependencyInjector {
    let service: Service
    
    init(service: Service) {
        self.service = service
        // 나중에 service를 사용하여 다른 초기화 수행
    }
}

// myService 객체가 먼저 초기화되고, 그 다음에 myInjector가 생성되면서 service 속성이 초기화된다. 
// 이는 객체 간의 의존성을 명확히 보여준다.
let myService = Service()
let myInjector = DependencyInjector(service: myService)

 

 

4. Optional 타입일 때

초기화 시점에 값이 없을 수 있을 때: 변수가 선언될 때 값을 가질 수도, 가지지 않을 수도 있는 경우 옵셔널 타입을 사용한다.

class UserProfile {
    var profilePicture: UIImage?
}

 

 

5. 복잡한 초기화 로직이 있을 때

초기화 로직이 복잡하여 초기화 시점에서 즉시 값을 제공하기 어려운 경우, 나중에 초기화를 수행할 수 있다.

class ComplexObject {
    let config: Config

    init() {
        // 복잡한 초기화 로직
        self.config = Config() 
    }
}

 

 

결론

생성자를 통해 초기화하는 방법은 더 유연하고 다양한 상황에 대처할 수 있는 장점을 제공한다.

특히, 의존성 주입과 테스트의 용이성을 고려할 때 더 좋은 선택일 수 있다.

반면, 모든 인스턴스가 동일한 방식으로 초기화되는 단순한 경우라면 초기화 시 바로 인스턴스화하는 방법이 더 적합할 수 있다.

---

🌟 의존성 주입이 객체 지향 설계에서 중요한 이유

테스트 용이성 (Testability)

단위 테스트: 의존성 주입을 통해 테스트할 객체에 가짜(mock) 객체나 스텁(stub) 객체를 주입하여 테스트할 수 있다. 이를 통해 테스트 환경을 제어하고 예측 가능하게 만들 수 있다.

 

유연성 (Flexibility)

다양한 구현체 주입: 인터페이스나 프로토콜을 통해 다양한 구현체를 주입할 수 있어 코드의 유연성이 높아진다.

protocol DatabaseService {
    func fetchData() -> [Data]
}

class LocalDatabaseService: DatabaseService {
    func fetchData() -> [Data] { /* 로컬 데이터베이스에서 데이터 가져오기 */ }
}

class RemoteDatabaseService: DatabaseService {
    func fetchData() -> [Data] { /* 원격 데이터베이스에서 데이터 가져오기 */ }
}

class DataManager {
    let databaseService: DatabaseService

    init(databaseService: DatabaseService) {
        self.databaseService = databaseService
    }
}

 

재사용성 (Reusability)

모듈화: 의존성 주입을 통해 각 구성 요소를 독립적으로 만들 수 있어 재사용성이 높아진다. 이를 통해 코드를 모듈화하고, 특정 구성 요소를 다른 프로젝트나 모듈에서 재사용할 수 있다.

 

유지보수성 (Maintainability)

단일 책임 원칙 (Single Responsibility Principle): 객체의 책임을 분리하여 유지보수성을 높인다. 의존성 주입을 통해 각 객체는 자신의 책임에만 집중할 수 있으며, 의존성 관리는 외부에서 담당하게 된다.

 

코드의 가독성 향상 (Readability)

명확한 의존성: 생성자를 통해 의존성을 주입함으로써, 어떤 객체가 어떤 의존성을 필요로 하는지 명확히 알 수 있다. 이는 코드의 가독성을 높이고, 다른 개발자가 코드를 이해하는 데 도움이 된다.

 

결론

의존성 주입은 객체 지향 설계에서 중요한 원칙으로, 테스트 용이성, 유연성, 재사용성, 유지보수성, 그리고 코드의 가독성을 높이는 데 크게 기여한다. 이를 통해 더 안정적이고 관리하기 쉬운 소프트웨어를 개발할 수 있다.