지난 글에서 생성자를 다뤘으니, 이번엔 클래스 확장 얘기다. Kotlin에서 인터페이스 여러 개 구현하던 습관대로, Dart에서도 클래스 여러 개를 한 번에 상속하려고 하면 바로 막힌다.

class Flyer {
  void fly() => print('난다');
}

class Swimmer {
  void swim() => print('헤엄친다');
}

class Duck extends Flyer, Swimmer { // 여기서 에러남
}

Only one extends clause allowed. extends는 정확히 하나의 부모만 허용한다. 두 개 이상의 클래스로부터 뭔가를 가져오고 싶으면 extends가 아니라 다른 문법을 써야 한다.

셋 중 뭘 얼마나 가져오는지 먼저 정리하자

Dart에는 클래스끼리 연결하는 방법이 셋 있고, 각각 "가져오는 양"이 다르다.

이 표를 기억해두고 하나씩 보자.

implements — 이름과 타입만 강제, 내용은 0% 재사용

class Flyer {
  void fly() => print('난다');
  int speed = 10;
}

class Duck implements Flyer {
  @override
  void fly() => print('오리가 난다'); // 내용은 완전히 새로 작성
  @override
  int speed = 5;
}

implements가 강제하는 건 시그니처(이름 + 타입 + 파라미터 구성)뿐이다. "fly라는 이름의, 파라미터 없고 반환값 없는 메서드가 있어야 한다", "speed라는 이름의 int 필드가 있어야 한다"까지만 검사하고, 그 안의 실제 내용({ } 몸통, = 값)은 전적으로 새로 채워야 하는 자유 영역이다. 하나라도 빠뜨리면 Missing concrete implementation 에러가 난다 — 전부 다 이행해야 하는 계약이라, "이건 필요 없으니 빼자"가 안 된다.

Swift 해봤으면 이게 정확히 protocol이다.

protocol Flyer {
    func fly()
    var speed: Int { get }
}
class Duck: Flyer {
    func fly() { print("오리가 난다") } // 직접 구현
    var speed: Int = 5
}

extends — 전부 그대로, 원하는 것만 덮어쓰기

class Flyer {
  void fly() => print('난다');
  int speed = 10;
}

class Duck extends Flyer {
  @override
  void fly() => print('오리가 난다'); // fly()만 바꿈

  // speed는 안 건드림 - 원본(10) 그대로 사용됨
}

void main() {
  final duck = Duck();
  duck.fly();        // 오리가 난다
  print(duck.speed); // 10
}

extends는 부모가 가진 걸 전부 자동으로 물려받는다. 그중 바꾸고 싶은 것만 @override로 재정의하면 되고, 안 건드린 건 원본 그대로 쓰인다. 다만 "이건 받지 말고 저건 받자" 식으로 골라서 받는 건 안 된다 — 받는 건 항상 전부고, 고를 수 있는 건 "받은 것 중 뭘 override할지"뿐이다. 이건 Swift/Kotlin의 평범한 클래스 상속과 똑같다.

mixin + with — extends처럼 전부 다, 근데 여러 개 동시에

mixin Flyer {
  void fly() => print('난다');
}

mixin Swimmer {
  void swim() => print('헤엄친다');
}

class Duck with Flyer, Swimmer {
  // fly(), swim() 둘 다 다시 안 써도 그대로 사용 가능
}

void main() {
  final duck = Duck();
  duck.fly();  // 난다
  duck.swim(); // 헤엄친다
}

class를 mixin으로 선언하고, Duck에서 with 뒤에 쉼표로 여러 개 나열하면 된다. extends와 똑같이 전체가 그대로 딸려오는데, 유일한 차이는 여러 개를 동시에 가져올 수 있다는 것.

mixin은 생성자를 가질 수 없다

mixin Flyer {
  Flyer(); // 에러! mixin은 생성자를 가질 수 없음
  void fly() => print('난다');
}

mixin은 "독립적으로 객체를 만들 수 있는 단위"가 아니라, 다른 클래스에 코드를 얹어주는 용도로만 존재한다. 그래서 Flyer()처럼 단독으로 인스턴스화하는 것도 안 된다.

mixin은 왜 따로 생겼나 — 다중 상속의 위험을 피하려고

옛날 언어들은 클래스를 여러 개 그냥 상속하게 해줬다가, 두 부모가 같은 이름의 메서드/필드를 가진 경우 "누구 걸 물려받아야 하는지" 애매해지는 다이아몬드 문제가 생겼다. Dart는 이걸 피하려고 역할을 나눴다 — extends는 족보가 꼬일 일 없게 하나만, implements는 코드가 아예 없으니 충돌할 것도 없게, mixin은 코드를 재사용하되 생성자를 못 갖게 제한해서 위험을 줄였다.

Kotlin, Swift와 비교하면

Kotlin과 Swift는 implements/mixin을 나누지 않고, 인터페이스(프로토콜) 하나로 둘 다 처리한다.

// Kotlin - 인터페이스에 기본 구현을 직접 넣을 수 있음
interface Flyer {
    fun fly() = println("난다")
}
interface Swimmer {
    fun swim() = println("헤엄친다")
}
class Duck : Flyer, Swimmer // fly(), swim() 다시 안 써도 그대로 사용

// Swift - protocol만으로는 형태만 강제되지만, extension으로 기본 구현을 얹으면 재사용됨
protocol Flyer { func fly() }
extension Flyer {
    func fly() { print("난다") } // 기본 구현
}
protocol Swimmer { func swim() }
extension Swimmer {
    func swim() { print("헤엄친다") }
}
class Duck: Flyer, Swimmer {} // 기본 구현이 그대로 딸려옴

세 언어를 나란히 정리하면:

Kotlin/Swift는 인터페이스(프로토콜) 하나가 "형태 강제"와 "코드 재사용"을 상황에 따라 다 겸하는 반면, Dart는 이 둘을 implements와 mixin으로 아예 문법 자체를 나눠놨다는 게 핵심 차이다.

정리

• implements는 시그니처(이름·타입)만 강제하고, 내용은 100% 직접 채워야 한다 — Swift의 순수 protocol과 같다
• extends는 부모의 전체를 그대로 물려받고, 원하는 것만 @override로 재정의할 수 있다 — 단, 하나만 가능하다
• mixin + with는 extends처럼 전체가 그대로 딸려오는데, 여러 개를 동시에 섞을 수 있다 — 대신 mixin은 생성자를 가질 수 없다
• Kotlin/Swift는 인터페이스(프로토콜) 하나로 형태 강제와 코드 재사용을 다 처리하고, Dart는 이걸 implements/mixin으로 문법 자체를 나눠뒀다

다음 글에서는 extension을 다뤄보겠다.