지난 글들에서 기본 생성자(UserProfile(this.name))는 이미 써봤다. 근데 실무 코드에서는 "이 클래스를 만드는 방법이 딱 하나"인 경우가 별로 없다. 예를 들어 사용자 프로필을 만들 때, 일반 회원가입으로 만들 수도 있고, "게스트로 시작하기"처럼 이름 없이 만들 수도 있다. 이럴 때 Kotlin 하던 습관대로 짜면 바로 막힌다.

class UserProfile {
  final String name;

  UserProfile(this.name);

  UserProfile(); // 여기서 에러남
}

The default constructor is already defined. 어? 파라미터 개수가 다른데 왜 안 되지? Java나 Kotlin의 오버로딩(overloading)에 익숙하면 자연스럽게 이렇게 짤 것 같다.

원인: Dart는 "이름 없는 생성자"를 클래스당 딱 하나만 허용한다

Kotlin/Java는 "파라미터 목록이 다르면 같은 이름의 함수(생성자)를 여러 개 만들 수 있다"(오버로딩)는 규칙이 있다. Dart는 이 규칙이 없다. UserProfile(...)처럼 이름 없이 쓰는 생성자는 클래스에 딱 하나만 가질 수 있다. 파라미터 개수가 달라도 소용없다 — Dart 입장에서는 둘 다 그냥 "이름 없는 생성자"라서, 두 번째로 정의하는 순간 "너 이미 정의했잖아"라며 막는다.

고친 코드: 이름을 붙여서 구분한다 (named constructor)

class UserProfile {
  final String name;

  UserProfile(this.name);          // 기본 생성자
  UserProfile.guest() : name = '게스트'; // 이름 붙은 생성자

  void printName() => print(name);
}

void main() {
  final user1 = UserProfile('홍길동');
  final user2 = UserProfile.guest();

  user1.printName(); // 홍길동
  user2.printName(); // 게스트
}

UserProfile.guest()처럼 클래스 이름 뒤에 .이름을 붙이면, 완전히 별개의 생성자를 하나 더 만들 수 있다. 이게 named constructor다. UserProfile.guest() : name = '게스트'; 부분에서 콜론(:) 뒤에 오는 걸 initializer list라고 부르는데, 함수 몸통({ })이 아니라 **"필드에 값을 대입하는 전용 슬롯"**이다. 이 자리는 규칙이 딱 하나다 — 표현식 하나만 올 수 있다.

근데 initializer list엔 복잡한 로직을 못 넣는다

class UserProfile {
  final String name;

  UserProfile.fromJson(Map<String, dynamic> json)
      : name = json['name'] ?? '이름없음'; // 표현식 하나 - 이건 됨
}

이 정도 ?? 처리는 괜찮은데, 여기서 로그를 찍거나, 여러 줄에 걸쳐 값을 검증하거나, 조건에 따라 다른 처리를 하고 싶으면? initializer list는 표현식 하나만 허용해서 안 된다. 함수 몸통이 아니니까, if문이나 print 같은 여러 줄 코드를 그 자리에 그냥 넣을 수가 없다.

여기서 factory 생성자가 나온다

class UserProfile {
  final String name;

  UserProfile._(this.name); // 이름 앞에 _ 를 붙여서 외부에서 직접 못 만들게 막음

  factory UserProfile.fromJson(Map<String, dynamic> json) {
    print('파싱 시작'); // 여러 줄 로직 자유롭게 가능
    final rawName = json['name'];
    if (rawName == null || rawName.toString().isEmpty) {
      return UserProfile._('이름없음');
    }
    return UserProfile._(rawName);
  }
}

void main() {
  final user = UserProfile.fromJson({'name': ''});
  print(user.name); // 이름없음
}

factory를 붙이면, 이 생성자는 몸통이 일반 함수처럼 자유로워진다. if, 반복문, 여러 줄 로그, 뭐든 넣을 수 있고, 마지막에 return으로 실제 객체를 하나 골라서 돌려주면 된다.

여기서 실제로 값을 채우는 생성자는 UserProfile._(this.name) 하나뿐이다. _를 붙인 이유가 "이 진짜 생성자는 외부에서 직접 못 부르게 잠가라"는 뜻이다. factory UserProfile.fromJson(...)은 그 자체가 값을 채우는 게 아니라, 값을 다듬은 다음 진짜 생성자를 대신 호출해주는 창구 역할만 한다. 즉 "만드는 방법이 여러 개"라는 건 값을 채우는 로직 자체가 여러 개라는 뜻이 아니라, 하나뿐인 그 로직으로 들어가는 문(진입로)이 여러 개라는 뜻이다.

Dart의 _는 "클래스 비공개"가 아니라 파일 비공개다. 같은 파일 안이면 UserProfile._(...)도 직접 호출이 되긴 하는데, 실무에서는 클래스를 보통 별도 파일로 분리해서 쓰니까 사실상 외부에서 막힌다고 보면 된다.

named vs factory, 언제 뭘 쓰나

• named constructor: 만드는 방법이 여러 가지인데, 각 방법이 간단한 값 대입 정도(표현식 하나)일 때. UserProfile.guest()처럼 이름으로 의도를 드러내고 싶을 때.
• factory constructor: 객체를 만들기 전에 검증/변환/분기 같은 여러 줄 로직이 필요하거나, 조건에 따라 다른 값을 골라 돌려주고 싶을 때.

실무에서는 fromJson처럼 서버 데이터를 객체로 바꾸는 자리에 factory가 정말 자주 등장한다. API 응답을 다루기 시작하면 거의 항상 이 패턴을 쓰게 된다.

Kotlin과 비교하면

Kotlin은 named/factory처럼 "생성자에 이름을 붙이는" 문법 자체가 없다. 대신 이런 식으로 흉내낸다.

class UserProfile private constructor(val name: String) {
    companion object {
        fun guest(): UserProfile = UserProfile("게스트")

        fun fromJson(json: Map<String, Any?>): UserProfile {
            println("파싱 시작")
            val rawName = json["name"] as? String
            return if (rawName.isNullOrEmpty()) {
                UserProfile("이름없음")
            } else {
                UserProfile(rawName)
            }
        }
    }
}

val user1 = UserProfile.guest()
val user2 = UserProfile.fromJson(mapOf("name" to ""))

• companion object 안의 guest(), fromJson()은 진짜 생성자가 아니라 그냥 평범한 함수다. 다만 안에서 진짜 생성자(UserProfile(val name: String))를 대신 호출해주는 창구 역할을 한다 — Dart의 factory가 하는 일과 똑같다.
• private constructor는 Dart의 _와 같은 목적이다. "진짜 생성자는 못 부르게 막고, companion object의 함수로만 만들게 하자."
• Kotlin에는 initializer list처럼 "표현식 하나만 되는" 제약된 슬롯도 없다. 대신 init 블록이 있는데, 이건 처음부터 여러 줄, print, if 다 자유롭게 들어간다.

class UserProfile(rawName: String?) {
    val name: String
    init {
        println("파싱 시작")
        name = rawName ?: "이름없음"
    }
}

그래서 Dart처럼 "간단하면 initializer list, 복잡하면 factory"로 나눠 고민할 필요가 Kotlin에는 원래 없다 — init 하나로 간단한 것도 복잡한 것도 다 처리된다.

한눈에 정리

Kotlin은 "생성자는 하나, 나머지는 다 companion object의 함수"라는 단순한 원칙으로 밀고, Dart는 "생성자 자체를 여러 개, 필요하면 함수처럼 자유로운 것(factory)도" 허용하는 쪽으로 문법을 세분화했다. 호출하는 쪽 코드(ClassName.이름(...))는 둘 다 비슷해 보이지만, 내부 구현 방식의 자유도가 Dart 쪽이 조금 더 나뉘어 있다고 보면 된다.

정리

• Dart는 이름 없는 생성자를 클래스당 하나만 허용한다 — 파라미터 개수가 달라도 오버로딩이 안 된다
• 여러 방식으로 객체를 만들고 싶으면 ClassName.이름(...) 형태의 named constructor를 쓴다
• named constructor의 initializer list(: 뒤)는 함수 몸통이 아니라 값 대입 전용 슬롯이고, 표현식 하나만 가능하다
• 검증, 변환, 분기처럼 복잡한 로직이 필요하면 factory 생성자를 쓴다 — 실제로 값을 채우는 생성자는 보통 _로 숨기고, factory는 그리로 들어가는 창구 역할만 한다
• Kotlin은 이런 named/factory 문법이 없어서, companion object의 평범한 함수나 init 블록으로 같은 목적을 이룬다 — 대신 Kotlin의 init은 Dart의 initializer list보다 훨씬 자유롭다

다음 글에서는 상속과 mixin을 다뤄보겠다.