🎊 클래스(class)의 모든 것 !

Classes | Dart
Mixins | Dart

[Dart] Class 총 정리 (상속 / 재정의 / 추상화)
Instance 관점에서 Class, Singleton, Static 알아보기

Singleton Pattern(싱글톤 패턴) ?
Factory Pattern(팩토리 패턴) ?

copyWith에 NULL 사용하는 방법

이번 글에서는 Flutter&Dart Class에 대한 내용을 다뤄보도록 하겠다.

Dart OOP(Object Oriented Programming) ?

먼저 Flutter는 Dart언어를 사용해 개발된 FrameWork이며, Flutter FrameWork에서도 Dart를 사용해 개발되어 지고 있다.

Dart 언어에서는 모든 것이 객체(object)이다.

Dart는 클래스(class)와 Mixin기반의 상속을 지원하는 완전 객체 지향 프로그래밍 언어(Super OOP)이며, 모든 객체는 클래스(class)의 인스턴스(instance)이고, NULL을 제외한 모든 class는 Object에서 비롯된다.
Mixin 기반 상속은 모든 클래스(class)가 하나의 객체(Object)를 가지고 있지만, 클래스(class)의 바디는 다양한 클래스(class) 계층에서 재사용 될 수 있음을 의미한다고 공식 문서에서 설명하고 있다.

" Dart is an object-oriented language with classes and mixin-based inheritance. Every object is an instance of a class, and all classes except Null descend from Object. Mixin-based inheritance means that although every class (except for the top class, Object?) has exactly one superclass, a class body can be reused in multiple class hierarchies. Extension methods are a way to add functionality to a class without changing the class or creating a subclass. Class modifiers allow you to control how libraries can subtype a class. "

위의 설명이 잘 이해되지 않을 수도 있다. 이해가 안되더라도 천천히 자주 개발을 하다보면 자연스럽게 개념을 습득할 수 있으니 크게 걱정하지 않아도 되고, 외울 필요는 없다.

Dart Class

Dart Class를 다루기 위해서 4가지 키워드를 알고 있어야 한다.

• object
• class
• constructor
• instance

클래스(class)에 대해서 자세히 다루면서 추가적으로 설명할 예정이고, 우선 개념 정도만 알고 있도록 하자.

자 자동차를 만드는 공장이라고 가정해보자.

자동차는 수 만가지 부품의 조합으로 만들어 진다. 만드는 것 외에도 출고 전 테스트 과정도 거쳐야 한다.
이렇게 복잡한 구조의 자동차가 단 하나의 구조로 이뤄지지 않고, 내부적으로 종류도 다양하게 존재한다.

공장에서는 다양한 종류의 자동차를 생산하기 위한 생산표를 공통화된 기준으로 관리를 해야 하는데, 부품 종류 및 사용되는 부품 갯수, 테스트 과정등의 집합체를 객체(object)라고 볼 수 있으며, 자동차를 생산하기 위한 설계도가 클래스(class)에 해당 된다.
설계도는 속성(attribute)과 동작(behavior)을 구성할 수 있는데, 속성은 멤버변수(member variable), 동작은 메서드(method)로 표현 된다.

자동차가 생산 되기 위해 컨베이어 벨트에 올라가기 위해서는 설계도의 속성을 초기화하는 과정을 거쳐야 하는데, 이 때 생성자를 사용해 초기화를 할 수 있다. 생성자가 바로 constructor 이다.

클래스(class)를 통해 만들어진 객체를 인스턴스(instance)라고 한다.

흔히 인스턴스화라고 하는 의미가 바로 메모리에 올려지는 순간을 의미한다.

적절한 예시인지는 모르겠지만, 가볍게만 보고 class를 만들고 다루면서 개념을 더 정확히 익혀보도록 하자.

글을 자주 게시하지만 항상 느끼는게 글로만 설명 한다는 것은 참 힘든 것 같다 ...

Class

이제 클래스(class)를 생성하고 사용하는 방법에 대해서 본격적으로 코드를 통해 알아보도록 하자.

기본적인 클래스(class) 구조이다.

클래스(class)는 멤버 변수와 멤버 함수를 가질 수 있으며, 클래스 명을 정할 때에는 첫 글자를 대문자로 시작하는 PascalCase 표기법을 기준으로 사용해야 한다.

class Person {
  String name = "tyger";
}

클래스(class)를 사용해 보도록 하자.

Person 클래스를 tyger라는 변수로 만들어 주고, 해당 object(객체)가 사용 되어질 때에 instance 된다.

(인스턴스)instance란 메모리에 할당 되어지는 것을 의미한다.

void main() {
  Person tyger = Person();
  print(tyger.name);
  // tyger
}

instance

인스턴스(instance)란 뭘까 ?

" 인스턴스란 Class를 기반으로 생성되며, Class의 기능과 속성을 동일하게 가지고 있는 프로그래밍 상에서 사용되는 대상이다. "

인스턴스(instance)는 클래스(class)가 Object(객체)로 선언되고, 선언되어진 Object(객체)가 메모리에 할당 되어 실제 사용될 때가 바로 인스턴스(instance)이다.

즉, Object(객체)를 실체화한 개념이다

🔥 Instance 관점에서 Class, Singleton, Static 알아보기

아래에서 클래스(class)의 기능들을 살펴보면서, 인스턴스(instance)에 대한 부분은 계속해서 설명할 예정이니, 개념 정도만 알고 있으면 된다.

자세하게 알고 싶다면 공유한 글을 참고하시면 좋을 것 같다.

Constructor

Class의 기본 구조에 대해서는 알아 봤으니, 이번엔 constructor에 대해서 알아보도록 하자.

Constructor는 생성자라고 한다. 그렇다면 생성자는 무엇일까 ?

클래스(class)는 생성자를 가질 수 있고, 한 개의 생성자 뿐만 아니라 여러 개의 생성자도 가능하다.

생성자는 " 객체가 생성될 때에 호출되는 '인스턴스 초기화 메서드' "이다.

먼저, 생성자(constructor)의 기본 구조를 살펴보자.

처음에 class의 기본 구조를 배울 때에 클래스 내부의 변수에 초기 값을 생성하여 만들었었다.
이번에는 초기 값 없이 constructor(생성자)를 통해 클래스를 만들어 줬다.

이 둘의 차이점은 뭘까 ? 왜 생성자를 사용하는 것일까 ?

class Person {
  final String name;
  
  const Person(this.name);
}

생성자가 없다면, 클래스를 객체로 인스턴스할 때에 초기 값을 다르게 줄 수가 없다.

예를 들어, tyger와 alice라는 두 개의 Person 클래스를 사용한다고 가정해 보자. 생성자를 사용하지 않으면 객체로 생성한 후에 person.name에 접근하여 값을 변경해 주어야 한다.

그렇기 때문에 생성자를 사용하여 클래스를 초기화하여 사용해야 한다.

void main() {
  Person tyger = Person("tyger");
  print(tyger.name);
  
  // tyger
}

Default Constructor

class에서 생성자를 선언하지 않으면 기본 사용자가 생성된다고 한다.

기본 생성자의 형태이다. 생성자는 클래스명과 동일한 이름을 기본 생성자로 사용할 수 있다.

Person 클래스를 인스턴스할 때에 name, age 변수를 순서대로 전달하여 생성할 수 있다.

생성자에서 변수의 순서대로 꼭 넣을 필요는 없다. 인스턴스할 때에만 생성자에서 정의한 순서대로 변수를 할당해주면 된다.

class Person {
  final String name;
  final int age;
  
  const Person(this.name, this.age);
}

// Person("tyger", 100);

위의 생성자는 변수 이름을 사용하지 않아 변수가 많아진다면 순서가 헷갈리게 되기 때문에 "Named"를 사용하면 된다.

생성자는 함수를 생성할 때에도 Argument를 가져오기 위해 자주 사용하는 방법 이므로 익숙한 내용일 듯 하다.

Named로 생성자(constructor)를 선언할 경우 반드시 중괄호 "{}" 안에서 등록해야 하며, 필수로 전달 받을 파라미터라면 required 키워드를 넣어주면 된다.

class Person {
  final String name;
  final int age;
  
  const Person({
  	required this.name,
    required this.age,
  });
}

// Person(name: "tyger", age: 100);

혼합해서 사용할 수도 있다.

class Person {
  final String name;
  final int age;

  const Person(
    this.name, {
    required this.age,
  });
}

// Person("tyger", age: 100);

Named Constructor

이번에는 이름있는 생성자를 만들어 보도록 하자.

위에서 Default Constructor에 대한 내용을 다룰 때에 생성자는 클래스의 이름과 동일하게 기본 생성자로 사용된다고 했었다.

이름이 있는 생성자로도 만들어 줄 수 있으며, 생성 규칙은 클래스명에 쩜(.)을 입력하고 원하는 생성자 명을 CamelCase 표기법으로 생성해주면 된다.

" 생성자는 한 개가 아닌 여러 개의 생성자를 자유롭게 추가하여 사용할 수 있다. "

class Person {
  final String name;
  final int age;
  
  // Default
  const Person(this.name, this.age);
  
  // Named
  const Person.init(this.name, this.age);
}

// Person.init("tyger", 100);

생성자는 이미 익숙한 내용이라 class의 다른 내용 들을 다루면서 더 익혀보도록 하자.

Members

위에서 클래스를 설명할 때에 " class는 속성(attribute)과 동작(behavior)을 구성할 수 있는데, 속성은 멤버변수(member variable), 동작은 메서드(method)로 표현 된다. " 라고 했었다.

속성과 동작에 대해서 살펴보도록 하자.

Method

변수를 다루기 앞서 동작과 관련된 클래스 내부 함수에 대해서 간단하게 살펴보자.

클래스는 내부에 Method를 구성할 수 있으며, Instance Method와 Static Method를 사용할 수 있다.

class Person { 
  final String name;

  const Person(this.name);

  void printName() {
    print("My name is ${this.name}");
  }

  String returnName() => this.name;
}

Person 클래스를 인스턴스한 후에 내부 함수에 접근하여 호출해 주면 된다.

void main() {
  Person tyger = Person("Tyger");
  
  tyger.printName();
  // My name is Tyger
  
  print(tyger.returnName());
  // Tyger
}

추가로 정적 메서드도 사용할 수 있다.

class Person {
  final String name;
  
  const Person(this.name);
  
  static void test(){
    print("Static Mehtod");
  }
}

// Person.test();
// Static Mehtod

Member Variable

" 해당 글은 클래스(class)에 관한 내용으로 변수의 타입 등의 관한 내용은 여기서 다루지 않음 "

속성에 해당하는 멤버변수(MemberVaribale)에 대해서 알아보자.

멤버 변수에도 메서드와 동일하게 Instance Varibale와 Static Varibale이 사용 가능하다.

위에서 이름을 사용하기 위한 name 변수를 생성 했었다. name에 해당하는 class의 속성을 변수(Varibale)라고 한다.

아래 코드를 보면 Person 클래스의 변수를 생성할 때에 name은 기본 값을 지정하지 않고 생성한 변수이고, age는 기본 값을 100으로 주었기에 생성자를 통한 초기화 변수에 등록하지 않아도 사용 가능하다.

class Person {
  final String name;
  int age = 100;
  
  Person(this.name);
}

abstract

클래스(class)의 기본적인 구성 요소 및 사용 방법을 간단하게 알아봤다.

원래 클래스(class)에 대해서 배울 때에는 클래스의 구성 요소를 배우고, 일반적으로는 상속에 대해서 배우게 된다. 하지만 상속을 배우기 앞서 추상 클래스에 대해서 먼저 배우고 가도록 하겠다.

왜 Abstract Class(추상 클래스)를 먼저 배워야 하는지에 대해서 설명 하자면, 상속에 대한 개념을 배울 때에 반드시 알고 있어야 하는 사전 지식 중 하나가 바로 추상 클래스라고 생각해서 이다.
개인적으로 프로그래밍 언어를 접했을 때에 추상 클래스의 개념이 이해가 가지 않고, 상속에서 추상 클래스가 하는 역할에 대해서 납득이 되지 않았었다.
알고 보면 어렵지도 않고, 간단한 개념이니 빠르게 살펴보도록 하자 !

그렇다면 추상(abstract) 클래스는 뭘 하는 걸까 ?

"추상 클래스는 코드를 정직하게 유지하고 유형을 안전하게 유지합니다. 모든 구현 하위 클래스가 추상 클래스가 정의하는 모든 속성과 메서드를 정의하도록 보장 하지만 구현은 각 하위 클래스에 맡깁니다."

• 추상 메서드를 포함하는 클래스
• 인스턴스(instance)할 수 없는 클래스
• 추상 메서드는 선언만 되고 정의는 없는 메서드

인스턴스(instance)할 수 없는 클래스라는 의미에 대해서는 이미 위에서 인스턴스에 대해서 살펴 봤기 때문에, 무슨 의미인지 알고 있을 것이다.
추상 클래스로 생성이 되면, 객체로 인스턴스화 할 수 없다는 것이다.

추상 클래스를 만든는 방법은 간단하다. 바로 abstract 키워드를 넣어주면 된다.

이제 Person 클래스는 추상 클래스로 선언 됬기 때문에, 인스턴스할 수 없어 단독적으로 사용이 불가능하게 되었다.

abstract class Person {}

단독적으로 사용이 불가능 하고 인스턴스할 수 없다면 왜 사용하는 걸까 ?

추상(abstract) 클래스를 사용하는 목적에 대해서 알아보자.

추상 클래스를 사용하여 하위 클래스에서 공통된 특징과 동작을 추상화하여, 강제할 수 있으며 다형성(polymorphism) 및 코드 재사용성을 높힐 목적으로 사용이 된다.

Person 클래스를 introduce() 메서드를 추가한 추상(abstract) 클래스로 생성하였다.

introduce() 메서드를 보면 선언은 되었지만 정의는 없는 것을 알 수 있다.

이제 Person 추상 클래스를 사용하고자 하는 하위 클래스에서 정의 부분을 구현하면 된다.

abstract class Person {
  void introduce();
}

추상(abstract) 클래스에 대해서는 이 정도만 알고 있으면, 상속을 배우는 데는 문제가 없을 것 같다.

상속

이제 이어서 class의 상속에 대해서 살펴보도록 하겠다.

먼저 상속은 왜 필요할까 ?

Flutter에서 사용되는 Dart 언어는 위에서 설명한데로 객체 지향 언어이다.

객체 지향 언어에서의 상속은 정말 중요한 개념이며, 상속을 통해 코드의 재사용성과 구조화, 모듈화 및 확장성을 높혀주기 때문이다.

부모님의 재산을 자식에게 물려주는 것을 상속이라고 한다. Dart에서도 동일한 개념이다. 즉, 부모 클래스(슈퍼클래스)의 요소를 자식 클래스(서브클래스)에서 사용할 수 있도록 한다는 것이다.

---

예를 들어, 자동차의 여러 모델에 대해서 설명하는 기능을 만든다고 가정하자. 자동차의 모델은 각기 다른 스펙을 가지고 있겠지만, 자동차라는 관점에서는 자동차 자체가 가지고 있는 고유 속성은 모두 동일할 것이다.

자동차의 모델별 출력과 마력 외에도 많은 스펙에서는 차이가 있을 것이지만, 자동차라는 것의 목적에는 모두 동일한 속성을 가지게 된다. 바퀴가 4개 라던지, 출력 또는 토크라는 값을 가지고 있던지 .. 등등

이런 부분을 공통적으로 사용할 수 있도록 자동차의 속성을 담고 있는 Car라는 클래스를 생성해, 각 자동차 모델별 Car 클래스를 상속 받게 하면 공통적인 속성에 대해 반복적으로 코드를 작성할 필요가 없어 코드 재사용성도 높아지고, 모듈화를 하여 관리할 수 있게 된다.

---

Flutter에서 상속 방법은 일반적으로 extends, implements, mixin 이렇게 3가지의 키워드를 사용하는 방법이 있다.

세 가지 방법 모두 부모 클래스(슈퍼클래스)를 상속받아 자식 클래스(서브클래스)를 만드는 방법이지만, 차이가 있으니 각 차이에 대해서 살펴보면서 상속에 대해서 알아보자.

extends

첫 번째로 extends 상속 키워드에 대해서 알아보자.

extends 키워드를 사용한 상속에서는 부모 클래스(슈퍼클래스)의 멤버변수, 메서드, 생성자 요소를 그대로 상속 받아서 구현 없이 사용 가능하며, 필요에 따라 재정의 할 수도 있다.

Car 클래스에 멤버변수로 name을 선언 해주고, 생성자를 통해 초기화할 수 있도록 해주고 printName() 이라는 name을 출력해주는 메서드를 추가하여 생성해 보자.

class Car {
  final String name;

  const Car(this.name);

  void printName() => print("자동차 이름은 $name 입니다");
}

이제 G70이라는 클래스를 생성하여 extends 키워드를 사용하여 Car 클래스를 상속 받도록 해주자.

이렇게 상속 받게 되면, 에러가 발생할 것이다.

class G70 extends Car {}

에러가 발생하는 이유는 Car 클래스에서 name을 초기화하기 위한 생성자를 추가 하였기 때문에 발생하는 이유이다.

Car 클래스의 생성자를 자식 클래스(서브클래스)에서 초기화 해주어야 한다 (생성자가 없다면 상관없다)

class G70 extends Car {
  const G70(super.name);
}

이제 G70 클래스가 Car 클래스를 상속 받았는지 확인해 보자. 정상적으로 상속을 받았다.

void main() {
  final G70 g70 = G70("G70");
  g70.printName();
  // 자동차 이름은 G70 입니다
}

Car 클래스로 부터 상속 받은 메서드인 printName()의 출력 문구를 수정하고 싶어졌다. 이럴 때 부모 클래스(슈퍼클래스)의 메서드를 수정해야만 하는 걸까 ?

그럴 필요 없다. 재정의(override) 해주면 된다.

재정의(override)는 Dart annotation 문법을 사용하는 키워드로 부모 클래스(슈퍼클래스)의 메서드를 자식 클래스(서브클래스)에서 다시 정의할 수 있도록 해주는 기능이다.

재정의(override)에 대해서는 이미 익숙하게 자주 봤을 것이다. StatelessWidget의 build 부분의 재정의가 바로 build를 다시 정의 하겠다는 의미이다.

재정의(override)하는 방법은 매우 심플하다. 바로 "@override" annotation을 추가해 준 뒤, 부모 클래스(슈퍼클래스)의 메서드를 다시 정의해 주면 된다.

class G70 extends Car {
  const G70(super.name);

  @override
  void printName() => print("$name 입니다");
}

이제 다시 출력해보면, 재정의된 메서드가 실행되는 것을 확인할 수 있다.

여기서 궁금하실 수 있는 부분이 바로 "@override" annotation을 꼭 넣어줘어야 하는 건지에 대해서다. 왜냐하면 사실 annotation을 추가하지 않아도 재정의가 가능하기 때문이다. 하지만 Dart 언어의 문법이자 규칙이기 때문에, 개발자들은 코드를 보고 주석문이 있으면 해당 메서드는 부모 클래스(슈퍼클래스)의 메서드를 재정의한 것인가를 바로 알 수 있기 때문에, 반드시 어노테이션을 추가하는 습관을 가져야 한다.

"annotation은 사전적 의미로는 주석이지만, 일반적으로 사용하는 주석이 아닌 프로그램에게 추가적인 정보인 메타데이터(metadata)를 전달하기 위해 추가하는 문법"

G80 클래스도 Car 클래스를 상속 받아 생성해주자.

class G80 extends Car {
  const G80(super.name);
}

G80 클래스는 재정의 해주지 않았기 때문에, 부모 클래스(슈퍼클래스)의 메서드가 출력이 된다.

void main() {
  final G70 g70 = G70("G70");
  final G80 g80 = G80("G80");
  g70.printName();
  // G70 입니다

  g80.printName();
  // 자동차 이름은 G80 입니다
}

Car 클래스에 정수형 멤버변수 hp를 추가해 주고, getHorsePower() 라는 메서드를 추가하여 생성해 주도록 하자.

class Car {
  final int hp;
  final String name;

  const Car(this.name, this.hp);

  void getHorsePower() => print("$name 마력 : $hp");
}

이제 기존 G70, G80 클래스에서는 코드를 추가하라는 에러가 보일 것이다. hp를 초기화 하여야 하기 때문이다.

이번에는 자식 클래스(서브클래스)를 인스턴스할 때에 생성자(constructor)를 통해서 초기화 값을 받아오지 않고, 초기화 값을 내부에 선언하여 인스턴스시 값을 받아와도 되고 받아오지 않아도 될 수 있도록 생성자를 만들어 주도록 하자.

일반적으로 클래스에서 생성자(constructor)의 데이터를 옵셔널로 넣으려면 아래 코드처럼 해주면 된다.

class Test {
  final String name;
  const Test({this.name = ""});
}

하지만 G70 클래스에서 생성자(constructor)를 옵셔널하게 넣으려고 하면 에러가 발생한다.

그 이유는 부모 클래스(슈퍼클래스)의 생성자에는 기본 값 없이 생성자가 구현되어 있기 때문에, 상속 받은 자식 클래스(서브클래스)도 생성자의 데이터를 옵셔널하게 생성할 수 없기 때문이다.

부모 클래스(슈퍼클래스)의 생성자를 옵셔널로 변경해주고, 대신 기본 값을 반드시 넣어야 하기 때문에 기본 값을 생성해주면 된다.

class Car {
  final int hp;
  final String name;

  const Car({this.name = "", this.hp = 0});

  void getHorsePower() => print("$name 마력 : $hp");
}

이제 자식 클래스(서브클래스)에서는 멤버 변수를 초기화할 필요가 없으므로, 생성자(constructor)는 선택 사항이 되므로 생성자가 있어도 되고 없어도 된다.

G80 클래스의 생성자 안에서 부모 클래스(슈퍼클래스)의 멤버변수를 옵셔널하게 처리할 수 있게 된다.

class G80 extends Car {
  const G80({super.name = "G80", super.hp = 250});
}

이제 G80 클래스를 인스턴스할 때에 Default 생성자를 옵셔널하게 받아올 수 있게 되었다.

void main() {
  G80 g80 = G80();
  g80.getHorsePower();
  // G80 마력 : 250
}

자식 클래스(서브클래스)에서 멤버변수를 추가하는 방법에 대해서 살펴보도록 하자.

G80 모델에는 세단형 타입의 모델만 있지만, G70 모델에는 세단형과 왜건형 두 가지 유형의 모델이 있다. 이러한 유형을 나타내기 위해 subName이라는 문자열 변수를 추가하려고 한다. 이런 경우 Car 클래스에 변수를 추가해야 하는게 맞을까 ? 아니다.

G80 모델에는 필요가 없고, G70 모델에만 subName 변수가 필요하기 때문에, 부모 클래스(슈퍼클래스)인 Car 클래스에 변수를 추가하지 않고 자식 클래스(서브클래스)인 G70 클래스에만 추가해서 사용하는게 맞다.

class G70 extends Car {
  final String subName;
}

멤버변수 subName도 생성자(constructor)를 통해 초기화 해주도록 하겠다.

기본 초기화 값을 주지 않았기에 required를 사용해 필수로 인스턴스시 값을 받아올 수 있게 해주었다.

기존 클래스 생성하는 방법과 동일하게 사용하면 된다.

class G70 extends Car {
  final String subName;
  
  const G70({
    super.name = "G70",
    super.hp = 230,
    required this.subName,
  });
}

여기서 super?, this? 의 궁금중이 생겼을거다. 차이점에 대해서 알아보자.

super와 this는 간단한 문법이다.

this란 현재 클래스의 인스턴스란 의미이다. 여기서는 현재 클래스인 자식 클래스(서브클래스)의 멤버변수 지정을 위해 사용되는 키워드이다.

super는 상속 받은 부모 클래스(슈퍼클래스)의 멤버변수를 참조할 수 있도록 해주는 키워드이다.

Dart 언어에서는 super 키워드 없이 사용시 부모 클래스(슈퍼클래스)에서 상속 받은 멤버변수를 참조하지만, this의 영향으로 인하여 자식 클래스(서브클래스)에서 재정의 되었다면 자식 클래스(서브클래스)의 멤버변수를 참조하게 된다.

Person 클래스를 멤버변수로 name을 추가한 클래스를 만들어 주자.

class Person {
  final String name = "Empty";
}

Tyger 클래스는 Person 클래스를 상속 받도록 해주고, Tyger 클래스 내부의 멤버변수로 name을 추가해 주도록 하자.

super.name은 부모 클래스(슈퍼클래스)인 Person 클래스의 name이다. this 키워드는 생략 가능하다.

class Tyger extends Person {
  final String name = "Tyger";

  void log() => print("Person name: ${super.name}, Tyger name: ${this.name}");
}

Tyger 클래스를 인스턴스하고, log() 메서드를 호출해 보자.

void main() {
  Tyger tyger = Tyger();
  tyger.log();
  // Person name: Empty, Tyger name: Tyger
}

super, this 기능도 더 찾아보면 깊게 배워야 하는 내용이 많지만 크게 개념의 차이점에 대해서만 알고 있으면 문제가 없기 때문에, 디테일하게 알고 싶으신 분들은 댓글 남겨주시면 별도로 작성해 보도록 하겠다.

implements

지금까지 상속 키워드 중 extends에 대해서 배워봤다.

아직 이해가 잘 되지 않을 수도 있으나, 다른 방법에 대해서 살펴보면서 더 알아가 보도록 하자.

이번에 배우게 될 상속 받는 또 다른 방법인 implements에 대해서 알아보자.

implements 키워드를 사용하는 상속에서는 부모 클래스(슈퍼클래스)의 멤버변수, 메서드 등의 요소를 자식 클래스(서브클래스)에서 필수적으로 모두 구현하여 사용하는 상속 방법이다.

차이점을 보자면 extends 상속은 자식 클래스(서브클래스)에서 상속시 부모 클래스(슈퍼클래스)의 요소를 구현할 필요 없이 사용이 가능한 반면, implements 상속은 상속 받은 요소를 필수적으로 자식 클래스(서브클래스)에서 구현하여 사용한다는 부분에서 가장 큰 차이점이 있다.

위의 설명이 쉽게 이해되지 않을 수도 있으니, 코드를 작성해서 확인해 보도록 하자.

Test 클래스를 log()라는 메서드만 추가하여 생성해 주도록 하자.

class Test {
  void log() => print("Test !!");
}

extends

부모 클래스(슈퍼클래스) Test를 extends 방법으로 상속 받는 TestExtends 클래스를 만들어 주자.

큰 문제 없이 잘 생성이 되었다.

class TestExtends extends Test {}

implements

이번에도 부모 클래스(슈퍼클래스) Test를 implements 방법으로 상속 받는 TestImplements 클래스를 생성하였다.

여기서 문제가 발생한다. TestImplements에 에러 라인이 표시되었다.

class TestImplements implements Test {}

에러 부분에서 빠른 수정 기능을 사용해 보면 "Create 1 missing override" 라는 수정이 나오는 것을 알 수 있다.

수정을 해보면 부모 클래스(슈퍼클래스)의 log() 메서드를 override 하라고 나온다.

@override
void log() {
	// TODO: implement log
}

위에서 implements 상속 방법에서 설명한 "부모 클래스(슈퍼클래스)의 멤버변수, 메서드 등의 요소를 자식 클래스(서브클래스)에서 필수적으로 모두 구현" 해야 한다고 정의한 것처럼 생성자를 제외하고 자식 클래스(서브클래스)에서 재정의(override) 하여 사용하는 상속 방법이다.

우선 implements를 사용한 상속을 익혀보도록 하자.

Car 클래스에 getHorsePower() 라는 자동차 모델의 마력을 출력할 수 있는 메서드를 추가햐여 생성해 주자.

class Car {
  void getHorsePower(int hp) => print("마력은 $hp 입니다.");
}

Car 클래스를 implements를 사용해 상속받는 G70 클래스르 만들어 주자.

자식 클래스(서브클래스)에서 재정의(override)해야 하는데, 우선 아무것도 작성하지 않도록 하자.

class G70 implements Car {
  @override
  void getHorsePower(int hp) {}
}

G70 클래스를 인스턴스한 후에 getHorsePower 메서드를 호출해보자.

당연히 결과는 아무것도 출력되지 않는다. 자식 클래스(서브클래스)에서 메서드를 작성하지 않았기 때문이다.

void main() {
  G70 g70 = G70();
  g70.getHorsePower(250);
}

부모 클래스(슈퍼클래스)의 멤버변수를 상속 받으면 어떻게 될까 ?

문자열 name 변수를 추가해 주자.

class Car {
  final String name;
  const Car(this.name);
  void getHorsePower(int hp) => print("마력은 $hp 입니다.");
}

멤버변수도 마찬가지로 재정의(override) 해야 한다.

class G70 implements Car {
  @override
  String get name => "G70";
  
  @override
  void getHorsePower(int hp) {}
}

이쯤 되면 도대체 왜 implements 상속을 사용하는 걸까 ? 그냥 extends 상속을 사용하면 되는거 아닌가 ?

여기서 바로 사전 지식으로 살펴본 추상(abstract)클래스의 기능을 활용하면, 왜 implements 상속을 사용 하는지 이해할 수 있다.

혹시라도 추상(abstract)클래스에 대해서 모르시거나 위에 작성된 글을 보지 않으신 분은 한 번은 보시길 추천 합니다.
아직 완전히 이해가 되지 않더라도 걱정하지 않으셔도 된다.

추상(abstract)클래스는 앞서 설명 했듯이 단독적으로는 인스턴스(instance) 할 수 없는 클래스이며, 선언만 되고 정의는 없는 메서드라고 했었다.

여기서 중요한 부분은 바로 "정의는 없는 메서드" 라는 부분이다. 이 말의 의미는 선언만 하면 된다는 것이다.

implements 상속을 보면, 부모 클래스(슈퍼클래스)에서 선언하고 정의를 해도 자식 클래스(서브클래스)에서 필수적으로 재정의(override) 해야 되는 부분이 왜 implements 상속을 사용해야 하는지 의문이었던 부분이다.

추상(abstract)클래스를 사용하면 선언만 하면 되고 implements 상속 후에 정의를 구현해주면 된다.

Car 클래스를 추상(abstract)클래스로 생성하고 getHorsePower 메서드도 선언만 해주도록 하자.

abstract class Car {
  void getHorsePower(int hp);
}

이제 G70 클래스에서 Car 클래스를 implements 상속을 사용해 상속 받도록 하자.

상속 받은 G70 클래스에서 메서드를 정의해 주면 된다. 간단하다.

class G70 implements Car {
  @override
  void getHorsePower(int hp) => print("마력은 $hp");
}

재정의(override)한 메서드가 정상적으로 실행이 된다.

void main() {
  G70 g70 = G70();
  g70.getHorsePower(250);
  // 마력은 250
}

이번에는 멤버변수를 추상(abstract)클래스에 선언하려면 어떻게 해야 하는지 알아보자.

우선 추상(abstract)클래스안에서 멤버변수를 어떻게 선언하는지에 따라 사용 방법이 다양하다.

일반적으로는 Getter를 사용해 선언해 준다.

멤버변수도 메서드와 동일하게 선언만 해주면 된다. 정의는 필요 없다.

abstract class Car {
  String get name;
}

G70 클래스에서도 Getter를 사용한 정의를 하면 된다.

class G70 implements Car {
  final String _name;
  const G70(this._name);

  @override
  String get name => _name;
}

지금까지 상속 방법 중 extends, implements 상속 방법에 대해서 알아 봤다.

동일한 상속 기능이라 생각할 수 있겠지만, 사실 전혀 다른 상속 방법인 것이다.

여기서 궁금점이 있을 수 있는데, 추상(abstract)클래스를 extends 상속하게 되면 어떻게 될까 ?

추상(abstract)클래스의 메서드가 정의가 된 상태라면 extends 상속을 해도 재정의(override) 할 필요가 없지만, 정의가 되지 않고 선언만 되었다면 extends 방법도 implements 상속과 마찬가지로 재정의(override) 해주어야 한다.

abstract class Person {
  void printName(String name);
}

자식 클래스(서브클래스)에서 재정의(override)해야 한다.

class Tyger extends Person {
  @override
  void printName(String name) => print("이름은 Tyger !");
}

아직 이해가 잘 되지 않을 수도 있지만, 여러가지 클래스를 구축하다 보면 자연스럽게 익혀지는 부분이니 천천히 배워가면 된다.

extends 상속은 부모 클래스(슈퍼클래스)의 멤버변수, 메소드 등의 요소를 전부 상속 받아 사용하는 반면 implements 상속은 추상(abstract)클래스를 활용하여 자식 클래스(서브클래스) 에서 재정의(override)하여 사용한다고 이해하면 된다.

---

Example

extends, implements 중 어떤 상속 방법을 선택해야 하는지에 대해서 예제를 통해 좀 더 알아보도록 하겠다.

슈퍼 히어로에 대한 정보를 보여주는 기능을 만든다고 가정해보자.

슈퍼 히어로한테는 공격력과 방어력을 나타내주는 메서드가 존재해야 한다.

마블 히어로에게는 tier 라는 등급을 갖는 멤버변수를 추가하였다. tier는 1~9까지의 순서로 1이 가장 높은 등급인데, 공격력이라는 getAttack 메서드는 10에서 tier를 빼준 값에 곱하기 100을 해주고 방어력은 20을 곱해주기로 하였다.

class Hero {
  final String name;
  final int tier;
  const Hero({
    required this.tier,
    required this.name,
  });

  int getAttack() => (10 - tier) * 100;
  int getDefence() => (10 - tier) * 20;
}

이제 마블 히어로인 아이언맨과 헐크의 클래스를 생성할 것인데, Hero 클래스를 extends 상속을 받도록 하겠다.

아이언맨의 tier는 9등급 이고, 헐크의 tier는 7등급으로 해주었다.

class IronMan extends Hero {
  const IronMan({super.tier = 9, super.name = "IronMan"});
}

class Hulk extends Hero {
  final String name = "Hulk";
  const Hulk({super.tier = 7, super.name = "Hulk"});
}

이제 클래스를 인스턴스(instance)한 후에 부모 클래스(슈퍼클래스) 메서드를 호출해 주자.

void main() {
  IronMan ironMan = IronMan();
  Hulk hulk = Hulk();
  print(
      "${ironMan.name}의 공격력은 ${ironMan.getAttack()}, 방어력은 ${ironMan.getDefence()}이다.");
  // IronMan의 공격력은 100, 방어력은 20이다.

  print("${hulk.name}의 공격력은 ${hulk.getAttack()}, 방어력은 ${hulk.getDefence()}이다.");
  // Hulk의 공격력은 300, 방어력은 60이다.
}

extends 상속을 사용해 간단하게 기능을 만들었다.
그런데 여기서 문제가 발생한다. DC 히어로가 새롭게 추가 되었는데, DC 히어로는 tier라는 등급이 없는 상태이며, 공격력과 방어력을 계산하는 식이 마블 히어로와 다르다.

하지만 공격력과 방어력은 마블 히어로, DC 히어로 모두에게 필요한 메서드이다.

자 이럴 경우 extends 상속이 효율적인 방법일까 ? 클래스의 요소를 강제하고 싶은데, 자식 클래스(서브클래스)에서 전부 재정의 하게 해야할 것이다.

이렇 때에 implements 상속으로 구현해 보도록 하자.

Hero 클래스에서 name 변수와 getAttack, getDefence를 추상(abstract)클래스를 추상화하여 선언만 하였다.
이렇게 되면 Hero를 상속 받는 자식 클래스(서브클래스)에서는 Hero의 클래스 요소를 전부 강제할 수 있게 되었다.

abstract class Hero {
  final String name;
  const Hero(this.name);

  int getAttack();
  int getDefence();
}

코드가 길어져 아이언맨과 슈퍼맨만 클래스를 생성하였다.

class IronMan implements Hero {
  final int tier = 9;
  @override
  int getAttack() => (10 - tier) * 100;

  @override
  int getDefence() => (10 - tier) * 20;

  @override
  String get name => "IronMan";
}

class SuperMan implements Hero {
  @override
  int getAttack() => 1000;

  @override
  int getDefence() => 100;

  @override
  String get name => "SuperMan";
}

이제 결과를 출력해 보도록 하자.

void main() {
  IronMan ironMan = IronMan();
  SuperMan superMan = SuperMan();
  print(
      "${ironMan.name}의 공격력은 ${ironMan.getAttack()}, 방어력은 ${ironMan.getDefence()}이다.");
  // IronMan의 공격력은 100, 방어력은 20이다.
  
  print(
      "${superMan.name}의 공격력은 ${superMan.getAttack()}, 방어력은 ${superMan.getDefence()}이다.");
  // SuperMan의 공격력은 1000, 방어력은 100이다.
}

이제 extends, implements 상속에 대해서는 이해했을 거라 생각한다.

위의 예제를 보면, 아직도 뭔가 부족한 느낌이고 불편하다. 마블 히어로인 경우는 tier가 반드시 존재하는데, DC 히어로의 tier가 없다는 이유 때문에, 자식 클래스(서브클래스)에서 tier 변수를 추가해서 사용해야만 하고, 이러한 클래스가 100개 1000개가 된다고 가정해 보면 너무 귀찮은 일이 발생한다.

여러 부모 클래스(슈퍼클래스)를 상속 받을 수 없을까 ?

다중상속

이제 부터 한 개의 부모 클래스(슈퍼클래스)가 아닌 여러 부모 클래스(슈퍼클래스)를 상속 받는 다중상속에 대해서 살펴보도록 하겠다.

Dart 언어가 객체지향언어(OOP)라는 것은 이미 알고 있는 내용이다. 객체지향언어의 장점 중 하나는 코드의 재사용성인데, 여러 계층의 클래스(class)를 다중으로 상속 받아 사용하고 싶은 경우가 있을 것이다.
하지만 대체적으로 OOP에선 다중상속을 지원하지 않는 경우가 많이 있는데, 이는 OOP 다중상속에 있어 죽음의 다이아몬드 문제 때문이다.

죽음의 다이아몬드 문제란 위의 이미지처럼 A 클래스를 B, C가 상속을 받고 D 클래스에서 다중상속으로 B, C를 상속 받았다면, 이미지와 같은 다이아몬드 구조가 형성되게 된다.

이 때에 문제가 발생하는데, B, C에서 재정의(override)된 print() 메서드를 D 클래스에서 호출을 한다면 어느 부모 클래스(슈퍼클래스)에서 정의된 메서드가 호출이 되어야 할까 ? 이런 모호성으로 충돌이 발생하게 되는데, 이것을 죽음의 다이아몬드 문제라고 한다.

Dart 언어에서 이러한 모호성을 해결하여 다중상속을 어떻게 구현하는지 알아보도록 하자.

우선 다중상속 방법을 알아보기에 앞서, extends 상속은 다중상속이 불가능하다.

Flutter 3 버전이 나오기 전에는 extends에서도 다중상속을 with 키워드를 사용해 구현할 수 있었다. 하지만 Flutter 3 부터는 다중상속을 하기 위해서는 다른 방법을 사용해야 한다.

그렇다면 implements는 다중 상속이 가능할까 ? implements 상속은 자식 클래스(서브클래스)에서 부모 클래스(슈퍼클래스)의 요소를 재정의(override)해야 하기 때문에, 여러 부모 클래스(슈퍼클래스)를 상속 받을 수 있다.

Hero의 공격력과 방어력을 가지는 메서드가 있는 클래스와, 마블 히어로의 요소인 tier를 가지는 MarvelHero 클래스를 생성해 주자.

abstract class Hero {
  int getAttack();
  int getDefence();
}

abstract class MarvelHero {
  final int tier;

  const MarvelHero(this.tier);
}

Hero, MarvelHero 클래스를 다중상속으로 상속 받는 IronMan 클래스를 생성한 뒤, 재정의(override) 해주면 된다.

class IronMan implements Hero, MarvelHero {
  @override
  int getAttack() => (10 - tier) * 100;

  @override
  int getDefence() => (10 - tier) * 20;

  @override
  int get tier => 9;
}

만약에 MarvelHero 클래스에 Hero에 있는 동일한 메서드를 추가하게 되면 어떻게 될까 ?

결과는 동일한 메서드가 추가 되더라도, 자식 클래스(서브클래스)에서 재정의(override) 한 메서드가 실행되기 때문에 동일한 메서드가 존재해도 상관없다.

class MarvelHero {
  final int tier;
  int getAttack() => 100;
  int getDefence() => 100;
  const MarvelHero(this.tier);
}

클래스 하나를 더 생성해서 총 세개의 클래스를 상속 받도록 해주자.

class Actor {
  final String name;

  const Actor(this.name);
}

Actor 클래스를 추가하더라도 문제가 없다. 재정의(override)만 해주면 된다.

implements 상속에서는 단일 클래스를 상속 받던 다중상속을 받던 동일하게 사용하면 된다.

class IronMan implements Hero, MarvelHero, Actor {
  @override
  int getAttack() => (10 - tier) * 100;

  @override
  int getDefence() => (10 - tier) * 20;

  @override
  int get tier => 9;

  @override
  String get name => "Robert John Downey Jr";
}

위에서 extends 상속은 다중상속이 불가능하고, 다중상속을 구현하기 위해서는 다른 방법을 사용해야 한다고 했는데, 그 방법이 바로 mixin 상속 이다.

mixin

Mixins | Dart

이어서 한 개의 부모 클래스(슈퍼클래스)가 아닌 여러 부모 클래스(슈퍼클래스)를 extends 상속을 사용해 상속 받는 방법인 mixin에 대해서 알아보도록 하자.

상속에 대한 부분을 설명할 때에 extends, implements, mixin 이렇게 세 가지 방법이 있다고 했었다.

지금까지는 mixin에 대한 설명은 하지도 않고, extends, implements에 대해서만 설명 했었는데, 그 이유가 바로 mixin은 단일 부모 클래스(슈퍼클래스)를 상속 받는 것이 아닌, 여러 개의 부모 클래스(슈퍼클래스)를 extends 상속을 사용해 다중상속 받는 방법이기 때문이다.

앞서 설명 했듯이 Flutter 3에서 업그레이드된 부분이 바로 mixin이다. 이전에는 with 키워드를 사용해 다중상속 기능을 만들 수 있었는데, 3 버전으로 넘어오면서, mixin을 사용해서만 다중상속이 가능해 졌다.

이전 버전의 다중상속 기능인 with에 대해서 궁금하시다면 아래 글을 참고하시길 바란다.

- [Dart] Class 총 정리 (상속 / 재정의 / 추상화)

여기서는 mixin을 사용한 다중상속만 다루도록 하겠다.

Dart에서 mixin에 대한 설명을 뭐라고 하고 있을까 ?

"다수의 클래스 계층에서 클래스의 코드를 재사용하는 방법이다."

이전에는 with를 사용해 다중상속을 할 수 있었었다.

class A {}

class B {}

class C extends A with B {}

이제 다중상속을 하기 위해서는 mixin을 해주면 된다.

class A {}

mixin B {}

class C extends A with B {}

이제 본격적으로 mixin에 대해서 자세히 다뤄보도록 하자. 참고로 기능이 생각보다 많다.

먼저 mixin 클래스를 자식 클래스(서브클래스)에서 사용할 때에는 with 키워드를 사용해 다중상속 할 수 있다.

여기서 with는 mixin을 위한 키워드라고 생각하면 된다. mixin으로 생성된 클래스를 상속 받기 위해서는 반드시 with 키워드가 있어야만 상속이 가능하다.

A 클래스는 일반 클래스이고, B는 mixin으로 생성하였다.

C 클래스에서 다중상속을 위해 일반 클래스인 A 클래스를 extends 상속을 받고, with 키워드를 사용해 mixin으로 생성한 B를 상속 받게 되면 C 클래스는 A의 요소와 B의 요소를 모두 상속 받을 수 있게 된다.

class A {
  void logA() => print("A Class");
}

mixin B {
  void logB() => print("B Mixin");
}

class C extends A with B {}

C 클래스는 A와 B의 메서드를 모두 사용할 수 있게 되었다.

void main() {
  C c = C();
  c.logA();
  // A Class

  c.logB();
  // B Mixin
}

참고로 mixin 클래스로 생성된 클래스를 implements 상속에서도 사용할 수 있는데, with 키워드 없이 사용하면 된다.

하지만 implements 상속으로 mixin 클래스를 상속 받더라도, 자식 클래스(서브클래스)에서 당연히 재정의(override)해야 한다.

mixin A {
  void logA();
}

mixin B {
  void logB();
}

mixin 클래스로 생성된 A, B 클래스를 단일 클래스만 상속 받아도 되고, 다중상속 받아도 된다.

class C implements A, B {
  @override
  void logA() => print("A mixin");

  @override
  void logB() => print("B mixin");
}

다시 extends를 사용한 다중상속을 위한 mixin 상속으로 돌아오자.

읿반 클래스가 없이 mixin 클래스만 다중상속하려면 어떻게 해야 할까 ?

with 키워드로 extends 없이도 다중상속이 가능하다.

mixin A {
  void logA() => print("A mixin");
}
mixin B {
  void logB() => print("B mixin");
}

class C with A, B {}

여기서 한 가지 의문점이 발생한다. 만일 부모 클래스(슈퍼클래스)의 메서드가 동일하다면 어떻게 될까 ?

A,B 클래스는 각각 log() 라는 동일한 메서드가 존재한다. 두 개의 클래스 중 어느 메서드가 실행이 될까 ? 아니면 에러가 발생할까 ?

mixin A {
  void log() => print("A mixin");
}
mixin B {
  void log() => print("B mixin");
}

class C with A, B {}

정답은 B의 메서드가 실행이 되었다.

void main() {
  C c = C();
  c.log();
  // B mixin
}

mixin 우선순위

mixin 다중상속은 동일 메서드에 대해 우선 순위가 정해져 있다.

바로 with 키워드의 가장 마지막 mixin 클래스 부터 우선순위를 갖게 된다.

테스트를 해보자. D mixin 클래스를 추가로 생성해보자.

mixin D {
  void log() => print("D mixin");
}

D mixin 클래스가 가장 우선순위가 높도록 다중상속을 하도록 하자.

class C with A, B, D {}

예상대로 D의 메서드가 실행이 되었다.

void main() {
  C c = C();
  c.log();
  // D mixin
}

동일한 구조에서 A 클래스만 일반 클래스로 변경해 주자.

class A {
  void log() => print("A mixin");
}

class C extends A with B, D {}

결과는 동일하게 with 키워드의 가장 마지막 mixin 클래스의 메서드가 실행이 된다.

void main() {
  C c = C();
  c.log();
  // D mixin
}

mixin 다중상속에서는 부모 클래스(슈퍼클래스)의 순서를 기준으로 우선순위가 정해지기 때문에, with 키워드에 따른 순서를 주의해서 사용해야 한다.

메서드 외에도 멤버변수의 우선순위도 동일하다.

mixin A {
  final String name = "A";
}

mixin B {
  final String name = "B";
}

class C with A, B {}

void main() {
  C c = C();
  print(c.name);
  // B
}

on

on 키워드에 대해서도 알아보도록 하자.

mixin 에서는 on 키워드에 대한 설명이다.

Sometimes you might want to restrict the types that can use a mixin.
For example, the mixin might depend on being able to invoke a method
that the mixin doesn’t define.
As the following example shows, you can restrict a mixin’s use
by using the on
keyword to specify the required superclass:

on 키워드는 mixin의 사용을 특정 클래스 내에서 제한하고 싶을 때 사용할 수 있는 키워드이다.

mixin으로 생성된 클래스의 상속을 특정 클래스를 상속 받았을 때에만, 상속이 가능하도록 제어할 수 있다는 의미다.

코드를 통해 어떻게 특정 클래스에서만 사용 가능하도록 mixin 클래스를 생성할 수 있는지 알아보자.

디바이스에 사용할 수 있는 기능을 만든다고 가정해 보자.
하지만 디바이스마다 사용 가능한 기능이 있고, 사용할 수 없는 기능이 있을 것이다.

Phone과 PC 클래스를 생성하고, 멤버변수로 name을 추가해 주었다.

abstract class Phone {
  String get name;
}

abstract class PC {
  String get name;
}

이제 기능들을 생성해 주도록 하겠다. Photo 클래스는 사진첩 기능을 가지고 있고, Lock 클래스는 디바이스 잠금에 대한 기능을 가지고 있다.

mixin Photo {
  void openPhotos() => print("사진첩 오픈 !");
}
mixin Lock {
  void unLock() => print("잠금 해제 !");
}

그런데, 여기에 추가로 카메라로 사진을 찍는 기능을 추가하는 Camera 클래스를 추가하도록 하자. 다만, 카메라 기능은 PC 클래스에서는 상속받지 못하게 하고, Phone 클래스에서만 상속 받을 수 있도록 해주자.

이럴 때 사용하는 키워드가 바로 on 키워드이다.

이제 Camera 클래스는 Phone 클래스를 상속 받은 자식 클래스(서브클래스)에서만 사용 하도록 제한이 되었다.

mixin Camera on Phone {
  void takePicture() => print("사진 촬영 !");
}

기능에 대한 클래스는 모두 생성 했으니, 이제 IPhone 클래스를 생성하고 다중상속으로 Phone, Photo, Lock, Camera 클래스를 받도록 하자.

class IPhone extends Phone with Photo, Lock, Camera {
  @override
  String get name => "iPhone 15";
}

이번에는 Macbook 클래스를 생성하고 PC, Photo, Lock 클래스를 다중상속 받도록 하자.

class Macbook extends PC with Photo, Lock {
  @override
  String get name => "Macbook";
}

Macbook 클래스에 추가로 Camera 클래스를 상속에 추가해보자.

class Macbook extends PC with Photo, Lock, Camera {
  @override
  String get name => "Macbook";
}

이렇게 되면 Camera 클래스에 에러가 발생할 것이다.

'Camera' can't be mixed onto 'PC' because 'PC' doesn't implement 'Phone'.
Try extending the class 'Camera'.

Phone 클래스에서만 상속 받을 수 있다는 내용이다.

Camera 클래스는 Phone을 상속 받아야지만 사용 가능하도록 제한 하였기 때문에, 반드시 Phone 클래스를 상속 받게 되어있다.

그렇기 때문에, Phone 클래스의 멤버변수(member variable), 메서드(method)의 사용이 가능하게 된다.

mixin Camera on Phone {
  void takePicture() => print("$name 사진 촬영 !");
}

일반 클래스만 상속을 제한할 수 있는 것은 아니고, mixin 클래스도 가능하다.

mixin A {}
mixin B on A{}

on 키워드에는 여러 개의 mixin 을 추가하여도 된다. 단 이렇게 되면 추가된 모든 mixin을 먼저 상속 받아야만 한다.

mixin A {}
mixin B {}
mixin C on A, B {}

아래 코드는 A, B 클래스에서만 사용 가능하도록 C 클래스를 제한 하였는데, B 클래스가 상속되지 않았기 때문에 에러가 발생한다.

class Test with A, C {}

아래 케이스는 B를 추가 하였는데도 에러가 발생한다. 사용이 불가능한 코드다.
위의 케이스에서는 B를 추가하지 않았기 때문에 에러가 발생 하였는데, 아래 코드는 왜 에러가 발생할까 ?

class Test with A, C, B {}

이유는 순서에 있다. C 클래스를 A, B 클래스가 상속된 경우에만 상속 가능하도록 제한 하였기 때문에, 상속 이루어지는 자식 클래스(서브클래스)에서도 on 키워드로 제한한 클래스를 먼저 상속 받아와야만 하게 된다.

A, B 클래스가 먼저 상속을 추가해야 C 클래스를 상속 받을 수 있게 된다.

class Test with A, B, C {}

이번에는 좀 더 복잡하게 다중상속을 제한하도록 해보자.

A를 생성하고, B는 A클래스가 상속된 경우에만 상속이 가능하도록 하고, C는 B의 상속이 이루어져야만 상속이 가능하도록 해주었다.

해당 케이스에서 A를 제외하고는 전부 특정 클래스에서만 상속이 가능하게 되었다.

mixin A {}
mixin B on A {}
mixin C on B {}

A 클래스는 제한이 없기 때문에 당연히 상속이 가능하다.

class Test with A {}

C 클래스를 상속 받아보자. C는 B 클래스가 상속 되어야만 가능하기에 B를 먼저 상속해 주도록 하였다.

하지만 역시나 에러가 발생한다. B는 A 클래스가 상속된 상태에서만 상속이 가능하기 때문이다.

class Test with B, C {}

결국 on 키워드로 제한된 클래스에서의 상속을 구현할 때에는 구조의 설계에 대해 고민을 해봐야 할 것이다.

class Test with A, B, C {}

복잡하더라도 on 키워드로 특정 클래스에서만 상속이 가능하도록 제한하게 되면, 잘못된 상속을 사전에 제어할 수 있게 된다.

mixin을 사용한 간단한 예제를 만들어보자.

포르쉐 자동차의 특징 및 속성에 대한 기능을 만든다고 가정해보자.

먼저, 자동차의 종류를 나타내는 ElectircCar(전기차), EngineCar(내연기관차), HybridCar(하이브리드차) 클래스를 각각 추상(abstract)클래스로 생성해 주자.

abstract class ElectricCar {}

abstract class EngineCar {}

abstract class HybridCar {}

자동차의 종류를 생성하였고, 다음으로는 부품이나 속성들에 대한 클래스를 만들어보도록 하자.

자동차에 사용될 동력원인 Electric(전기), Engine(엔진)을 mixin 클래스로 생성해 주었다.

mixin Electric {}

mixin Engine {}

연료 부분을 만들어 줄 것인데, Fuel(연료) 클래스는 반드시 Engine(엔진) 클래스를 상속 받은 클래스에서만 사용 가능하도록 해주었다.

연료의 종류인 Gasoline(휘발유), Diesel(경유) 클래스는 Fuel(연료), Engine(엔진) 클래스를 상속 받아야만 사용 가능하도록 제한 하였다.

mixin Fuel on Engine {}

mixin Gasoline on Engine, Fuel {}

mixin Diesel on Engine, Fuel {}

이번에는 Battery 클래스를 생성하는데, 동력원인 Electric(전기) 클래스에서만 상속 받도록 제한하고, 배터리를 충전할 Charger(충전기) 부품은 Electric, Battery 클래스를 상속 받은 클래스에서 사용을 제한하였다.

mixin Battery on Electric {}

mixin Charger on Electric, Battery {}

마지막 부품으로 DPF(연료저감장치) 클래스를 생성하는데, 해당 부품은 Engine(엔진), Fuel(연료), Diesel(경유) 속성을 상속 받아야만 사용이 가능하고, 만일 Gasoline(휘발유)를 연료로 사용하면, 상속 받을 수 없도록 해주었다.

mixin DPF on Engine, Fuel, Diesel {}

자 이제 자동차의 종류 부터 부품까지 추상화를 하였으니, 각 모델마다 특징 및 속성을 다중상속 받을 수 있도록 해주자

class Boxter extends EngineCar with Engine, Fuel, Gasoline {}

class Taycan extends ElectricCar with Electric, Battery, Charger {}

class Cayenne extends EngineCar with Engine, Fuel, Diesel, DPF {}

class PanameraHybrid extends HybridCar with Engine, Electric, Fuel, Gasoline, Battery, Charger {}

쉽고 간단하게 mixin을 사용해 여러 클래스의 특징이나 속성들을 다중상속 받아 재사용성을 높히면서, 확장성 있는 구조를 만들 수 있다.

드디어 상속에 대한 부분이 끝이 났다.

단일 클래스를 상속 받는 방법 부터 다중상속 까지를 살펴 봤으며, extends, implements, mixin을 사용한 부모 클래스(슈퍼클래스)의 속성을 자식 클래스(서브클래스)에서 상속 받는 방법 및 사용 방법 및 특징에 대해서도 알아봤다.

상속 부분은 익숙하지 않으면, 어려운 내용이니 익숙해질 때까지 연습을 많이 해보시길 바란다.

factory

Factory Pattern(팩토리 패턴) ?

Flutter로 클래스(class)를 다루다 보면 자주 접하는 키워드 중에 하나가 바로 factory 키워드이다.

factory 키워드의 대표적인 사용은 JSON 직렬화를 생성할 때에 사용되기에 낯선 키워드는 아닐 것이다.

그렇다면 factory는 뭘까 ?

용어적 해석으로 보면, 공장을 떠올릴 수가 있어 인스턴스를 생산해내는 공장이라고 생각할 수 있지만, 공장보다는 창고(warehouse)의 기능을 가지고 있다고 보는 것이 더 적합하다.

또한 factory는 키워드이기도 하고, 패턴(Pattern) 이기도 한다.

먼저 키워드로 factory의 역할이 무엇인지 알아보도록 하자.

factory Keyword

factory 키워드는 생성자(constructor)와 유사해 보이지만 완전히 다른 역할과 특징을 가지고 있는데, 생성자(constructor)가 호출시마다 인스턴스(instance)를 생산하는 것과는 다르게 factory는 이미 생산된 인스턴스(instance)가 있다면 이를 반환하여 재생산 한다는 특징이 있다. 또한 서브클래스의 인스턴스(instance)를 반환할 수 있는 역할을 만들어 줄 수 있다.

위의 설명 중 인스턴스(instance)가 있다면 이를 반환하여 재생산 한다는 특징을 싱글톤 패턴(Singleton Pattern) 으로 이해하고 설명하는 글들이 많은데, factory는 싱글톤 패턴(Singleton Pattern) 내에서 사용될 때에만 인스턴스(instance)를 생산하지 않도록 제어할 수 있고, 일반 클래스 내에서는 여러 유형의 인스턴스(instance)를 생산하고 제어할 수 있는 특징을 가진다라고 이해하면 된다.

싱글톤 패턴(Singleton Pattern) 에 대해서는 아래에서 자세히 다루게 될 것이다.

지금까지 설명으로는 이해가 안되겠지만, 전혀 복잡한 내용이 아니다.

Device 클래스를 생성해주자.

class Device {
  final int id;
  final String name;

  const Device(this.id, this.name);
}

factory를 생성해주자.

factory는 반드시 해당 클래스를 반환할 수 있고, 다른 유형의 타입은 반환할 수 없다.

class Device {
  final int id;
  final String name;

  const Device({required this.id, required this.name});

  factory Device.test() => Device(id: 1, name: "name");
}

Device 클래스의 인스턴스(instance)를 생성자(constructor)를 사용하지 않고, factory를 사용해 인스턴스(instance)를 할 수 있다.

void main() {
  Device test = Device.test();
  print(test.name);
  // name
}

factory의 유용한 방법 중 하나가 여러 인스턴스(instance) 유형을 만들어 줄 수 있다는 것이다.

Device 클래스를 iPhone, Mac, watch 이렇게 3개의 객체로 만든다고 가정해보자.

이렇게 각각 생성해야 하는데, 문제는 클래스(class)의 멤버변수가 더 많다면 불필요한 코드를 작성해야 할수도 있다.

void main() {
  Device iPhone = Device(id: 0, name: "iPhone");
  Device mac = Device(id: 1, name: "Mac");
  Device watch = Device(id: 2, name: "Watch");
}

이럴 때에 factory 키워드를 사용한 클래스(class)내에 여러 유형의 인스턴스(instance)를 추가할 수 있는 기능을 활용하면 좋다.

class Device {
  final int id;
  final String name;

  const Device({required this.id, required this.name});

  factory Device.iPhone() => Device(id: 0, name: "iPhone");
  factory Device.mac() => Device(id: 1, name: "Mac");
  factory Device.watch() => Device(id: 2, name: "Watch");
}

간단하게 여러 유형의 인스턴스(instance)를 사용할 수 있다.

void main() {
  Device iPhone = Device.iPhone();
  Device mac = Device.mac();
  Device watch = Device.watch();
}

factory 키워드를 제가 주로 활용하는 부분은 바로 기본 클래스를 미리 생성해주는 기능이다.

클래스를 Nullable로 사용하고 싶지 않고, 기본 값을 가지는 클래스를 생성해서 사용하고 싶다면, factory를 활용해 주면 된다.

class Device {
  final int id;
  final String name;

  const Device({required this.id, required this.name});

  factory Device.empty() => Device(id: 0, name: "");
}

이번에는 factory의 주요 특징 중 하나인 서브클래스의 인스턴스(instance)를 반환할 수 있는 특징에 대해서 알아보겠다.

Device 클래스를 생성해 주자.

class Device {
  final int id;

  const Device(this.id);
}

Phone 클래스를 생성하는데, 부모 클래스(슈퍼클래스)로 Device 클래스를 상속 받도록 하자.

class Phone implements Device {
  final String model;

  const Phone(this.model);

  @override
  int get id => 0;
}

이제 다시 Device 클래스로 와서, 서브클래스의 인스턴스(instance)를 생성할 수 있도록 코드를 추가해 주자.

Device 클래스에서 서브클래스인 Phone 클래스의 인스턴스(instance)를 반활할 수 있게 되었다.

class Device {
  final int id;

  const Device(this.id);

  factory Device.phone() => Phone("iPhone");
}

factory Pattern

팩토리 패턴(factory Pattern)은 앞서 배웠던 factory 키워드의 특징을 활용한 디자인 패턴 중 하나로써, 부모 클래스(슈퍼클래스)에서 알려지지 않은 구체 클래스를 자식 클래스(서브클래스)에서 결정하게 하는 패턴이다.

Flutter에서 팩토리 패턴(factory Pattern)은 주로 UI 작업에 주로 사용이 되고 있다.

Flutter는 여러 종류의 플랫폼을 개발하는 멀티 플랫폼 프레임워크이다 보니, UI 요소를 만들 때에도 각 플랫폼 마다 작동되거나 구현되는 부분을 다르게 개발하는 경우가 많아 팩토리 패턴(factory Pattern)을 활용하고 있다. 물론 팩토리 패턴(factory Pattern)이 필수적인 요소는 아니다. 사용하지 않고도 얼마든지 구현 하는데는 문제가 없다.

간단한 예제를 만들어보자.

플랫폼별로 다른 동작을 하는 컴포넌트들을 팩토리 패턴(factory Pattern)을 사용해 만들어보도록 하자.

해당 글은 Dart 언어만 사용되고 있고, Flutter를 사용하지 않기에 텍스트로만 구현하도록 하겠다.

PlatformComponent 추상(abstract)클래스를 생성해 주도록 하자.

abstract class PlatformComponent {
  void onTap();

}

해당 클래스를 상속 받는 각각의 버튼을 생성해주도록 하자.

class AndroidButton implements PlatformComponent {
  @override
  void onTap() => print("안드로이드 버튼");
}

class IOSButton implements PlatformComponent {
  @override
  void onTap() => print("iOS 버튼");
}

class WebButton implements PlatformComponent {
  @override
  void onTap() => print("웹 버튼");
}

이제 PlatformComponent 추상(abstract)클래스에 팩토리 패턴(factory Pattern)을 추가해보자.

UI 컴포넌트 중 버튼을 만들어 줄 것인데, 플랫폼은 고유 id를 기준으로 하겠다. 일반적으로 Flutter에서는 enum(열거형) 을 사용하는데, Dart 언어에는 enum(열거형) 개념이 없어 정수형을 사용하였다.

각각 플랫폼 별로 생성한 버튼을 팩토리 패턴(factory Pattern)을 통해 자식 클래스(서브클래스)가 기능을 결정할 수 있도록 하였다.

abstract class PlatformComponent {
  void onTap();
  factory PlatformComponent.button(int type) {
    return switch (type) {
      0 => IOSButton(),
      1 => AndroidButton(),
      2 => WebButton(),
      _ => IOSButton(),
    };
  }
}

각 플랫폼 별로 고유의 버튼을 사용하지만, 동일하게 부모 클래스(슈퍼클래스)에서 인스턴스(instance) 할 수 있게 되었다.

void main() {
  PlatformComponent button = PlatformComponent.button(0);
  button.onTap();
  // iOS 버튼
}

팩토리 패턴(factory Pattern)을 구현할 때에 factory 키워드는 사용하지 않아도 되며, 정적메서드(StaticMethod)로도 패턴을 만들어 줄 수도 있다.

상속 과정과 헷갈릴 수도 있지만, factory의 특징인 여러 유형의 인스턴스(instance)를 제어할 수 있다는 것과 서브클래스의 인스턴스(instance)를 반환한다는 특징을 활요한 디자인 패턴이라고 생각하면 된다.

UI 컴포넌트 관리를 팩토리 패턴(factory Pattern)을 사용해 구현해보면 더 쉽게 이해해 볼 수 있고, UI에서 팩토리 패턴(factory Pattern)의 장점을 발휘할 수 있는 내용에 대해서도 별도로 글을 작성해 보도록 하겠다.

singleton

Singleton Pattern(싱글톤 패턴) ?

팩토리 패턴(factory Pattern)에 의해서 OOP(Object Oriented Programming)의 대표적인 디자인 패턴 중 하나인 싱글톤 패턴(Singleton Pattern)에 대해서 알아보도록 하겠다.

싱글톤 패턴(Singleton Pattern)은 꼭!! 반드시!! 알고 있어야 하는 디자인 패턴이기 때문에, 개념을 확실히 이해시길 바란다.

앞서 팩토리 패턴(factory Pattern)에 대해서 살펴볼 때에, 잠시 싱글톤 패턴(Singleton Pattern)에 대해서 언급한 적이 있었다.

싱글톤이란 클래스의 인스턴스시에 호출되는 클래스의 객체를 여러 개 생성하지 않고, 이미 생성된 인스턴스(instance)를 반환하여 단 하나의 인스턴스(instance)만 생성할 수 있도록 하는 방법이고, 싱글톤 패턴(Singleton Pattern)은 이러한 싱글톤의 개념을 사용한 디자인 패턴이라고 할 수 있다.

자 그렇다면 싱글톤으로 생성된 클래스와 일반 클래스의 차이점이 뭘까 ?

차이점을 확인하기 위해 간단한 Person 클래스를 각각 일반 클래스를 사용한 GeneralPerson과 싱글톤으로 생성한 SingletonPerson 클래스를 만들어 주도록 하겠다.

class GeneralPerson {}

일반 클래스로 생성된 GeneralPerson 클래스의 인스턴스(instance)를 2개를 만들어 주도록 하겠다.

void main() {
  GeneralPerson general1 = GeneralPerson();
  GeneralPerson general2 = GeneralPerson();
}

지금까지 게시글을 잘 보셨으면, general1 객체와 general2 객체는 동일 객체가 아니라는 것은 이해하셨을 거다.

아직 이해가 되지 않으셨다면, 왜 다른가 의문이 생길 수도 있는데, 클래스를 통해 생성된 객체(object)를 인스턴스(instance)라고 하고, 위의 과정을 인스턴스화라고 하게 된다. 즉, 메모리 영역에 올려지게 된다는 것인데, 인스턴스(instance)된 객체는 고유의 메모리 영역을 할당 받는다는 것이다.

즉, 메모리 영역이 서로 다르기 때문에 general1과 general2는 당연히 서로 다른 인스턴스(instance)가 된다. 확인을 해보자.

클래스는 동일 클래스이지만, 인스턴스(instance)는 다른 것이다.

void main() {
  GeneralPerson general1 = GeneralPerson();
  GeneralPerson general2 = GeneralPerson();
  print(general1.hashCode);
  // 820663644

  print(general2.hashCode);
  // 26539618
}

비교 연산자를 사용하여도 서로 다르다는 것을 알 수 있다.

print(general1 == general2);
// false

그렇다면 싱글톤으로 생성된 인스턴스(instance)는 어떤 차이점이 있는지도 확인해 보자.

싱글톤을 만드는 코드는 아래에서 설명할 것이다. 우선 차이점만 확인해 보자.

class SingletonPerson {
  static final SingletonPerson instance = SingletonPerson._internal();
  factory SingletonPerson() => instance;
  SingletonPerson._internal();
}

동일하게 singleton1, singleton2 2개의 인스턴스(instance)를 생성해보자.

void main() {
  SingletonPerson singleton1 = SingletonPerson();
  SingletonPerson singleton2 = SingletonPerson();
}

싱글톤으로 생성된 인스턴스(instance)의 hashCode를 출력해보면, 동일한 값이 반환되는 것을 알 수 있고, 비교 연산자에서도 true를 반환하는 것을 확인할 수 있다.

즉 동일 인스턴스(instance)인 것이다.

void main() {
  print(singleton1.hashCode);
  // 96990887
  
  print(singleton2.hashCode);
  // 96990887
  
  print(singleton1 == singleton2);
  // true
}

아직 이해가 되지 않으셨다면 또 다른 예제를 만들어보자. 클래스에 정수형 count 변수를 넣어주고, 값을 증가 시켜보면서 직관적으로 차이점을 확인해 볼 것이다.

GeneralCount 클래스를 생성해주자.

class GenralCount {
  int count = 0;
}

count1, count2 2개의 인스턴스(instance)를 생성하고 count1의 count 값을 1 증가해보자.

count1 객체의 count 값은 당연히 1이 증가된 1로 출력이되고, count2 객체는 아무것도 해주지 않았으니 0으로 출력이 된다.

void main() {
  GenralCount count1 = GenralCount();
  GenralCount count2 = GenralCount();
  count1.count = count1.count + 1;
  print(count1.count);
  // 1
  
  print(count2.count);
  // 0
}

동일 기능을 싱글톤으로 만들어보자.

class SingletonCount {
  static final SingletonCount instance = SingletonCount._internal();
  factory SingletonCount() => instance;
  SingletonCount._internal();

  int count = 0;
}

이번에도 count1 객체의 count 값만 1 증가 시켰다. 결과는 count2 객체의 count도 0이 아닌 1로 출력이된다.

count1, count2의 인스턴스(instance)가 동일하기 때문이다.

void main() {
  SingletonCount count1 = SingletonCount();
  SingletonCount count2 = SingletonCount();
  count1.count = count1.count + 1;
  print(count1.count);
  // 1
  
  print(count2.count);
  // 1
}

싱글톤에 대해 이해가 되셨을거라 생각한다.

이제 싱글톤 클래스를 생성하는 방법에 대해서 살펴보도록 하자.

기본이 되는 싱글톤 구조이다.

class Singleton {
  static final Singleton _instance = Singleton._internal();
  factory Singleton() => _instance;
  Singleton._internal();
}

먼저 클래스를 만들어 주고, 정적메서드(static)를 사용해 클래스의 인스턴스(instance)에 귀속될 수 있도록 해준다.

Singleton._internal() 은 생성자인데, 생성자 이름은 private(_) 생성자로만 만든다면, 어떤 이름도 상관 없다. Dart 언어에서는 이름 없는 생성자를 선언할 경우 자동으로 public 생성자가 만들어지기에 이를 막기 위해서 Dart의 private을 만드는 언더바(_) 키워드를 사용해주면 된다.
참고로 생성자를 public 생성자로 만들게 되면, public 생성자가 호출될 때마다 새로운 인스턴스(instance)가 생성되기 때문에 싱글톤 클래스가 아닌, 일반 클래스가 된다.

추상(abstract)클래스를 사용해 인스턴스(instance)를 반환해주면 된다.

싱글톤 패턴(Singleton Pattern)을 사용하면, 인스턴스(instance)를 단 하나의 인스턴스만 생성할 수 있어 고정 메모리를 사용하게 되고, 여러 영역에서 인스턴스를 공유하고 싶을 때에도, 동일 인스턴스를 보장할 수 있다는 장점이 있다. 하지만 멀티쓰레딩 환경을 구축하고 싶을 때에, 동시성 문제가 발생할 수 있으며 테스트가 어렵다는 단점이 있다.

프로그래밍 실행 부터 종료까지 싱글톤 패턴(Singleton Pattern)으로 구현되는 패턴은 메모리를 해제하고, 가용상태로 전환해주는 GC(Garbage Collector)의 대상이 아니기 때문에, 살아있는 인스턴스로 남게된다.

Flutter 개발을 하다보면, 싱글톤 패턴(Singleton Pattern)은 널리 사용되는 기본적인 패턴이기에 알아두면 분명히 사용 가치가 있는 기능이다.

callable

Callable objects

To allow an instance of your Dart class to be called like a function, implement the call() method.

The call() method allows an instance of any class that defines it to emulate a function. This method supports the same functionality as normal functions such as parameters and return types.

Dart 언어의 클래스를 사용해 보면서, call 메서드에 대해서 사용해 보셨거나 들어본 적이 있을 것이다.

call 메서드는 클래스(class)의 인스턴스(instance)를 함수 처럼 호출할 수 있는 메서드이고, 일반 함수와 동일하게 매개변수, 반환 타입과 같은 기능을 지원한다.

인스턴스를 함수 처럼 호출한다는 것은 어떤 의미일까 ?

User 클래스를 생성하고 call 메서드를 구현 하는데, 매개변수 name을 입력 받아 문자열(String)을 반환해 주도록 해주자.

class User {
  String call(String name) => "사용자 이름은 $name 입니다";
}

User 클래스의 인스턴스 user를 함수 형태로 호출을 해보자. 결과는 정상적으로 call 메서드를 실행시켰다.

void main() {
  User user = User();
  String name = user("Tyger");
  print(name);
  // 사용자 이름은 Tyger 입니다
}

User 클래스에 call 메서드가 선언되어 있지 않았다면, 어떻게 될까 ? 당연히 인스턴스를 함수로 호출하는 것이 불가능하고, 에러가 발생하게 된다.

call 메서드 구현시 메서드 네임은 반드시 call() 이어야 하고, call 메서드는 한 개만 등록이 가능하지만 상속 관계인 경우 클래스 마다 호출 가능한 call 메서드를 구현할 수 있다.

일반 함수와 동일하게 매개변수, 반환 타입을 사용할 수 있다.

class Calculator {
  int call(int a, int b, int c) => a + b + c;
}

void main() {
  Calculator calculator = Calculator();
  int add = calculator(20, 3, 45);
  print(add);
  // 68
}

User 클래스에 멤버변수로 name을 추가해 보도록 하자.

class User {
  final String name;
  const User(this.name);
}

User 클래스의 인스턴스를 출력해보면, "Instance of 'User'" 라고 출력이 되는데, call 메서드 기능을 사용해 클래스의 구성 요소를 출력할 수 있도록 할 수도 있다.

void main() {
  User name = User("Tyger");
  print(name);
  // Instance of 'User'
}

call 메서드에 멤버변수를 출력할 수 있도록 해주자.

class User {
  final String name;

  const User(this.name);
  void call() => print(name);
}

인스턴스 네임을 함수로 호출만 하면 된다.

void main() {
  User name = User("Tyger");
  name();
  // Tyger
}

이번에는 좀 더 실용적인 예제를 사용해 call 메서드를 사용해 보자.

DateTime 타입으로 날짜를 입력 받아 원하는 형태로 포맷팅 후 문자열(String) 타입을 반환하는 call 메서드를 만들도록 하겠다.

class Watch {
  String call(DateTime date) {
    return "${date.month.toString().padLeft(2, "0")}월 ${date.day.toString().padLeft(2, "0")}일, ${date.year}년";
  }
}

watch 인스턴스를 함수로 호출해 보면 원하는 결과를 얻을 수 있게 된다.

void main() {
  Watch watch = Watch();
  String message = watch(DateTime(2000, 1, 1));
  print(message);
  // 01월 01일, 2000년
}

call 메서드는 주로 구현하는 클래스의 기능은 아니지만 상속 관계의 클래스 계층에서 코드의 재사용성 및 유연성을 높힐 목적으로 사용되기도 하니 call 메서드를 사용하면 인스턴스가 함수로 호출이 가능 하다는 부분은 기억하시면 도움이 될 것이다.

JSON Serializable

클래스(class)를 다룰 때에 자주 언급되고 선언되는 내용의 코드가 바로 JSON 직렬화(serialize)이다.

JSON에 대한 개념을 알기 위해서는 클라이언트가 서버와 통신하는 방법인 REST API에 대한 개념도 선행 되어야 하지만, 여기서는 직렬화를 위한 Dart 클래스 개념 및 사용 방법을 이해하는 것에 집중해서 설명할 예정이다.

JSON이란, JavaScriptObjectNotation의 약자로 자바스크립트 객체 표기법 이라고 해석할 수 있다.

클라이언트 측에서 서버로 부터 데이터를 전송하거나 데이터를 수신 받을때에 JSON 구조로 데이터를 다루게 된다.

JSON 구조는 key-value 형태의 구조로 Dart 언어의 Map 타입과 비슷한 구조이다.

모바일 프로그래밍에서도 REST API로 서버와 통신을 할 때에, JSON 구조를 사용한다. 물론 JSON 외에도 xml 구조도 있다.

서버로 데이터를 전송하기 위해 Object(객체)를 JSON 구조로 변화하는 과정을 직렬화(serialization)라고 하고 서버로 부터 데이터를 수신 받아 JSON 구조를 Object(객체)로 변환하는 것을 역직렬화(deSerialization)라고 한다.

Flutter에서 JSON 직렬화를 더 쉽게 하는 방법은 패키지를 사용해서 할 수도 있고, 클래스 구조를 간단하게 Code Generator를 사용해 자동으로 선언해주는 기능을 사용해서도 쉽게 구현이 가능하다.
하지만 어떤 과정으로 JSON 직렬화를 구성할 수 있는지 개념 정도는 알고 있어야 하고, 심지어는 패키지 없이도 구성할 수 있어야 패키지를 더 잘 사용하고 활용할 수 있다고 생각한다.

먼저, Dart 객체(object)를 서버로 전송하기 위해 JSON으로 변환하는 코드에 대해서 작성해보도록 하자.

클래스를 생성해보도록 하자.

class Person {
  final int id;
  final String name;
  final DateTime birthday;
  final bool gender;

  const Person({
    required this.id,
    required this.name,
    required this.birthday,
    required this.gender,
  });
}

객체(object)를 JSON으로 변환할 수 있도록 코드를 추가해 주자.

toJson 메서드를 선언해주자

class Person {
	...
  Map<String, dynamic> toJson() {
    return {};
  }
}

toJson 메서드안에 반환 타입으로 Dart key-value 구조인 Map 타입을 사용하면 된다.

  Map<String, dynamic> toJson() {
    return {
      "id": id,
      "name": name,
      "birthday": birthday,
      "gender": gender,
    };
  }

Person 클래스에 추가한 toJson 메서드를 사용해 JSON 구조로 변환하여 서버로 데이터를 전송해주면 된다.

void main() {
  Person person = Person(
    id: 0,
    name: "tyger",
    birthday: DateTime(2000, 1, 1),
    gender: true,
  );
  Map<String, dynamic> data = person.toJson();
  print(data);
}

여기서 Person 클래스안에 객체(object) 타입이 있다면 어떻게 될까 ?

주소 정보를 가지고 있는 Address 클래스를 만들어보자.

class Address {
  final int postCode;
  final String address;
  final String detail;

  const Address({
    required this.postCode,
    required this.address,
    required this.detail,
  });
}

Person 클래스에 Address 타입의 변수를 추가해주고, toJson 메서드에도 address 필드를 추가해 주도록 하자.

class Person {
  final int id;
  final String name;
  final DateTime birthday;
  final bool gender;
  final Address address;

  const Person({
    required this.id,
    required this.name,
    required this.birthday,
    required this.gender,
    required this.address,
  });

  Map<String, dynamic> toJson() {
    return {
      "id": id,
      "name": name,
      "birthday": birthday,
      "gender": gender,
      "address" : address,
    };
  }
}

다시 toJson 메서드를 실행해 서버로 데이터를 전송하면 어떻게 될까 ? 전송에 문제가 없어 보이지만, 새로 추가한 Address 객체를 JSON 구조로 변환하지 않고, 객체(object) 자체가 전송이 되기 때문에 에러가 발생한다.

void main() {
  Person person = Person(
    id: 0,
    name: "tyger",
    birthday: DateTime(2000, 1, 1),
    gender: true,
    address: Address(
        postCode: 15000, address: "대한민국 서울특별시 ...", detail: "XX아파트 101동 101호"),
  );
  Map<String, dynamic> data = person.toJson();
  print(data);
}

Address 클래스에도 toJson 메서드를 추가하자.

class Address {
	...
  Map<String, dynamic> toJson() {
    return {
      "postCode": postCode,
      "address": address,
      "detail": detail,
    };
  }
}

이제 Person 클래스의 toJson 메서드를 수정해주도록 하겠다.

  Map<String, dynamic> toJson() {
    return {
      "id": id,
      "name": name,
      "birthday": birthday,
      "gender": gender,
      "address": address.toJson(),
    };
  }

이번에는 서버로 부터 데이터를 가져올 때에 JSON 구조를 객체(object)로 변환할 수 있는 코드를 작성해 보겠다.

공장에서 주문을 관린하기 위한 Order 클래스를 생성해보자.

class Order {
  final int id;
  final String name;
  final DateTime orderAt;
  final bool isPreOrder;

  const Order({
    required this.id,
    required this.name,
    required this.orderAt,
    required this.isPreOrder,
  });
}

이제 서버로 부터 전달 받는 JSON 구조가 객체(object)로 변환될 수 있도록 이미 생산된 인스턴스(instance)를 반환하는 팩토리(factory) keyword를 사용해 fromJson 메서드를 추가해 보도록 하자.

toJson 메서드와는 다르게 fromJson 메서드는 매개변수로 서버로 부터 전송 받은 JSON 구조를 받아올 수 있도록 해주어야 한다.

class Order {
	...
  factory Order.fromJson(Map<String, dynamic> json) => null;
}

JSON 구조를 Map 타입으로 받아온 후 객체(object)로 인스턴스(instance)를 반환 해주면 된다.

  factory Order.fromJson(Map<String, dynamic> json) {
    return Order(
      id: json["id"],
      name: json["name"],
      orderAt: json["orderAt"],
      isPreOrder: json["isPreOrder"],
    );
  }

이제 서버로 부터 전달 받은 JSON 데이터를 fromJson을 사용해 객체(obejct)로 변환해 주면 된다.

void main() {
  Order order = Order.fromJson(data);
  print(order);
}

Car 클래스를 새로 생성해주고, Order 클래스의 변수로 추가해 주자.

class Car {
  final String name;
  final int colorType;

  const Car({required this.name, required this.colorType});

  factory Car.fromJson(Map<String, dynamic> json) {
    return Car(
      name: json["name"],
      colorType: json["colorType"],
    );
  }
}

추가한 Car 클래스를 아래와 같은 구조로 변환할 수 없다. 이유는 이미 toJson 메서드를 사용해 보면서 알고 있을 것이다. Car 클래스도 동일하게 fromJson 메서드를 사용해야 한다.

class Order {
	...
  final Car car;

  const Order({
	...
    required this.car,
  });

  factory Order.fromJson(Map<String, dynamic> json) {
    return Order(
      id: json["id"],
      name: json["name"],
      orderAt: json["orderAt"],
      isPreOrder: json["isPreOrder"],
      car: json["car"],
    );
  }
}

JSON은 Dart Map 타입은 아니기 때문에 as 키워드를 사용해 Map 타입 변환을 추가하여 fromJson 메서드에 전달해주어야 한다.

  factory Order.fromJson(Map<String, dynamic> json) {
    return Order(
      id: json["id"],
      name: json["name"],
      orderAt: json["orderAt"],
      isPreOrder: json["isPreOrder"],
      car: Car.fromJson(json["car"] as Map<String, dynamic>),
    );
  }

이번엔 배열을 어떻게 JSON에서 객체(object)로 변환할 수 있는지 살펴보자.

Car 클래스를 배열 형태로 변경해 보자. 이제 앞서 작성한 fromJson 메서드에 에러가 발생할 것이다.

class Order {
	...
  final List<Car> cars;

  const Order({	
	...
    required this.cars,
  });
}

리스트 타입으로 전달 받는 JSON 구조는 배열 안에 담긴 각각의 JSON 구조를 map 메서드를 활용해 순환적으로 객체(object)로 변환하여 파싱하면 된다.

  factory Order.fromJson(Map<String, dynamic> json) {
    return Order(
		...
      cars: List<Car>.from(json["cars"])
          .map((e) => Car.fromJson(e as Map<String, dynamic>))
          .toList(),
    );
  }

getter ? setter ?

클래스(class)를 접근할 수 있는 getter, setter에 대해서 알아보자.

getter, setter에 대해 살펴 보기전 접근 지정자에 대해서 알아야 한다.

Dart 언어에서 클래스(class)의 멤버를 선언할 때에는 멤버에 접근이 가능한지 불가능한지에 대해 접근의 권한을 부여하는 접근 지정자가 있다.
Dart 언어에서 접근 지정자는 private, public 두 가지의 개념을 주로 사용하는데, private으로 멤버를 선언하게 되면 동일 파일 내에서만 접근이 가능하게 된다.

private으로 선언하는 방법은 언더스코어(_)를 사용하면 되고, 그 외의 모든 멤버는 public이 된다.

이어서 객체 지향의 4가지 중요한 특징도 가볍게 알아보도록 하자.

• 추상화
• 캡슐화
• 상속
• 다형성

지금까지 클래스(class)에 대해 설명하면서, 객체 지향의 특징에 대해서는 살펴보지 않았었다. 객체 지향의 특징을 설명 하기에는 글의 내용이 너무 길어져 다루지 않았었지만, getter, setter를 다루기 위해 특징 중 캡슐화와 정보 은닉의 개념은 설명해야 할 것 같다.

캡슐화란 연관된 목적을 가지는 객체(object)의 속성(attribute)이나 동작(behavior)을 하나의 집합으로 적절히 묶는다는 개념이고, 정보 은닉이란 이렇게 묶인 클래스(class)의 내부 정보를 함부로 공개하지 않아야 한다는 개념이다.

public으로 선언되면, 아무 곳에서나 접근이 가능하기 때문에 예상하지 못한 에러가 발생할 수 있다.

그렇기 때문에 객체 지향의 캡슐화에 따라 정보를 private을 사용해 은닉하여 인스턴스를 외부에서 접근해 변경할 수 없도록 하게된다.

private의 멤버를 어떻게 접근하고 변경할 수 있을까 ?

이걸 가능하게 해주는 기능이 바로 getter와 setter이다.
이름만으로 짐작해도 어떤 기능인지는 대충 알 수 있을 것이다.

getter는 클래스(class)의 멤버변수(MemberVaribale)를 검색 하는데 사용하는 기능이고 Dart에서는 get 키워드를 사용하여 구현할 수 있고, setter는 멤버변수(MemberVaribale)를 변경 하는데 사용하는 기능이다.

getter, setter는 클래스(class) 내의 멤버에 사용하는 기능이라 접근 지정자가 클래스에 종속될 것이라 생각할 수 있지만, Dart 에서는 동일 파일 내에서는 private에 접근할 수 있다.

MotoCycle 클래스를 생성하는데, 변수 name을 언더스코어(_)를 사용하여 private로 생성해주자.

class MotoCycle {
  final String _name;
  const MotoCycle(this._name);
}

이제 MotoCycle 클래스를 인스턴스 해주고, 인스턴스를 사용해 private 변수로 지정한 _name에 접근해보자.

void main() {
  MotoCycle vehicle = MotoCycle("R1");
  print(vehicle._name);
}

아래와 같은 에러가 발생하게 된다.

The getter '_name' isn't defined for the type 'MotoCycle'.
Try importing the library that defines '_name', correcting the name to the name of an existing getter, or defining a getter or field named '_name'.

get 키워드를 사용해 getter를 등록해주자.

class MotoCycle {
  final String _name;
  const MotoCycle(this._name);

  String get name => _name;
}

이제 다시 MotoCycle 클래스의 인스턴스에서 _name으로 접근하는 것이 아닌 getter에 선언한 name으로 접근하면 접근이 가능한 것을 알 수 있다.

void main() {
  MotoCycle vehicle = MotoCycle("R1");
  print(vehicle.name);
}

여기서 중요한 부분이 멤버변수와 getter의 네이밍 규칙인데, 일반적으로 언더스코어를 제거하여 사용해야 한다.

이렇게 getter의 네이밍은 자유롭게 지정해도 작동에는 문제가 없다.

String get motoCycleName => _name;

getter에는 반드시 멤버변수만을 반환하지 않아도 된다.
이번엔 brand라는 변수를 private으로 추가해주고, name을 반환할 때에 brand 변수를 붙여서 반환하도록 수정해 보자.

class MotoCycle {
  final String _name;
  final String _brand;
  const MotoCycle(this._name, this._brand);

  String get name {
    return "$_brand : $_name";
  }
}

getter를 사용하면, 클래스(class)의 정보를 원하는 형태로 제공할 수 있다.

void main() {
  MotoCycle vehicle = MotoCycle("R1", "Yamaha");
  print(vehicle.name);
  // Yamaha : R1
}

getter에 대해서 살펴봤는데, 한 가지 의문점이 생긴다.멤버변수를 private로 선언하여 정보은닉을 하였지만, getter를 사용해 어디서든 접근하게 되면, 객체지향의 특징인 캡슐화에 의미가 없는 것이 아닌가 ? 정보가 은닉되었다고 할 수 있는가 ?

이런 의문점이 바로 getter 사용을 지양해야 한다고 하는 이유다. 정보은닉에 의미가 없어지기 때문이다.
단순히 멤버변수의 상태를 전달하고자 할 때에만 사용하고 무분별한 getter사용은 지양하는 것이 좋다.

이어서 setter에 대해서 살펴보도록 하자.
저는 setter 를 거의 사용하지 않는다. 이유에 대해서는 우선 setter가 뭔지에 대해서 부터 확실히 알고 설명하도록 하겠다.

setter는 멤버변수의 상태를 변경하고자 할 때에 사용하는 기능이다.
setter와 getter는 중복된 이름을 사용할 수 있어서 일반적으로는 getter의 네이밍 규칙을 따라서 생성하게 된다.

set 키워드를 사용해 변경하고자 하는 상태를 받아와 멤버변수에 할당해주면 되는 간단한 구조이다.

class MotoCycle {
  String _name;
  MotoCycle(this._name);

  String get name => _name;
  set name(String value) => _name = value;
}

setter 사용은 public으로 생성된 멤버변수의 상태를 변경하고자 할 때에 사용하는 방법과 동일하게 사용할 수 있다.

void main() {
  MotoCycle vehicle = MotoCycle("R1");
  print(vehicle.name);
  // R1

  vehicle.name = "R6";
  print(vehicle.name);
  // R6
}

setter의 기능 및 역할은 알았으니, 왜 사용을 지양해야 하는지 살펴보자.

우선 setter 사용을 위해서는 상수(final)로 선언할 수가 없고, 무엇보다 중요한 점은 값을 변경하고자 하는 의도를 파악하기가 어렵게 된다.
의도를 파악하기 어렵기 때문에 상태가 왜 ? 어떻게 ? 어디서 ? 변경을 시도했는지 파악을 하기 위해 역추적을 해야만 한다.
또 하나의 문제는 객체(object)의 일관성을 유지하기 어렵다. 이 부분은 getter의 문제점과 동일한 문제로 모든 영역에서 접근할 수 있는 상태가 되기 때문이다.

getter, setter에 대해서 알아봤는데, 지양하라는 것은 남발하지 않아야 한다는 것이지 아예 사용 자체를 하지 말아야 한다는 의미가 아니다.

필요에 의해서 당연히 getter, setter가 필요한 순간은 있다.

추가로 Dart 클래스(class)는 멤버변수에 대해 암묵적으로 getter, setter가 생성이 되고, 멤버변수가 상수인 경우엔 getter만 생성이 되기 때문에, private이 아니라면 별도로 getter, setter를 구현하지 않았음에도 멤버변수에 대한 접근이 가능한 것이었다.

copyWith

setter를 사용해 객체(object)의 상태를 변경하는 방법을 살펴봤었다.

setter 사용시 상수(final)로 선언할 수가 없다고 앞서 언급 했는데, 이 부분을 setter 사용을 지양해야 한다는 이유 중 하나로 설명 하기도 하였다.
그렇다면, 왜 상수(final)로 선언 되어야 하고, 상수(final)로 선언된 인스턴스를 어떻게 변경할 수 있을까 ?
이제 setter에 대한 부분은 고려하지 않고 멤버를 public으로 생성해 보도록 하겠다.

User 클래스를 생성하고, name 변수를 변경해보자.

class User {
  final String name = "tyger";
}

변경하려고 하니 에러가 발생한다. 당연한 것이다.
상수(final)로 선언 되었기 때문에 상태를 변경할 수 없다.

void main() {
  User tyger = User();
  tyger.name = "TYGER";
}

'name' can't be used as a setter because it's final. Try finding a different setter, or making 'name' non-final.

그렇다면 상수로 선언하지 않으면 안되나 ? 그럼 쉽게 값을 변경하고 제어할 수 있을 텐데...

Dart 언어나 Flutter에서는 불변 객체(Immutable Object)를 생성해 퍼포먼스 향상 및 수정할 수 없는 객체를 생성 예측 가능한 동작을 구현하도록 하여 불필요한 버그를 감소 시키고, 코드의 가독성을 높힐 수 있도록 하고 있다.

변할 수 없는 객체, 즉 불변 객체(Immutable Object)를 생성하기 위해 상수(final) 타입을 사용하게 된다.
상수(final) 타입은 인스턴스 후에 객체의 속성을 변경할 수 없게 되기 때문에, 불변 객체(Immutable Object)의 속성을 변경하기 위한 방법으로는 새로운 인스턴스를 생성해야 한다.
이렇게 기존 인스턴스를 사용해 새로운 인스턴스를 복사(copy)하는 기능을 깊은복사(deepCopy)라 하고, copyWith 메서드를 구현하여 사용할 수 있다.

name, age 속성을 상수(final)로 선언하여 User 클래스를 만들어 보자.

class User {
  final String name;
  final int age;

  const User(this.name, this.age);
}

이제 age 속성을 변경하기 위해 깊은복사(deepCopy)인 새로운 인스턴스를 전달해 주도록 하자.

void main() {
  User tyger = User("tyger", 100);
  tyger = User(tyger.name, 90);
}

속성이 정상적으로 변경이 되었다. 하지만 뭔가 불편하다. 지금은 속성이 2개 뿐이지만 10개라면 코드만 늘어나게 될 것이다.

깊은복사(deepCopy)를 가능하게 해주는 copyWith 메서드를 추가해 보도록하자.

User 클래스의 속성들을 nullable 타입으로 매개변수를 등록해주고, 매개변수가 null이면 User 클래스의 속성을 사용하면 되고, null이 아니면 매개변수의 값을 사용하여 새로운 인스턴스를 생성자(constructor)로 반환해주면 된다.

  User copyWith({
    final String? name,
    final int? age,
  }) {
    return User(
      name ?? this.name,
      age ?? this.age,
    );
  }

이제 인스턴스를 사용해 copyWith 메서드를 호출하여 원하는 속성의 값을 전달해 주면 변경된 속성으로 새로운 인스턴스를 반환하게 된다.

void main() {
  User tyger = User("tyger", 100);
  tyger = tyger.copyWith(age: 20);
}

copyWith에서 반환되는 인스턴스가 새로 생성된 인스턴스인지 확인해보자. hashCode 값을 출력해보면, copyWith에서 반환한 인스턴스는 새로운 인스턴스라는 것을 알 수 있다.

void main() {
  User tyger = User("tyger", 100);
  print(tyger.hashCode);
  // 613218385
  
  tyger = tyger.copyWith(age: 20);
  print(tyger.hashCode);
  // 436920219
}

인스턴스는 메모리 영역에 할당된 것인데, 불변 객체(Immutable Object)는 동일 인스턴스에서 데이터를 변경하는 것이 불가능 하기 때문에, 새로운 인스턴스 영역에 객체(object)를 복사하는 개념이라고 생각하면 된다.

이렇게 되면, 메모리 영역을 자주 할당받게 되는 것 아닐까 ? 맞다. 깊은복사(deepCopy)는 새로운 인스턴스가 생성되는 것이기 때문에 복사를 하게되면, 새로운 인스턴스의 메모리 영역을 새로 할당 받고 기존 인스턴스의 메모리는 GC(GarbageCollector) 영역에 들어가게 된다.
이런 동작이 반복적으로 발생하면 메모리의 할당 및 반환이 반복적으로 발생하여 순간적으로 메모리 사용량이 늘어날 수 있다.
또한 깊은복사(deepCopy)는 객체(object)를 전부 복사하는 개념이기 때문에, 객체 구조가 복잡하게 되면 속도 저하가 지속적으로 발생할 수도 있다.

깊은복사(deepCopy)와 관련해서는 인스턴스, 얕은복사(shallowCopy), 객체 동등성 등의 추가적으로 다뤄야 하는 개념이 많아 이번 글에서는 간단한 개념 정도만 이해하고, 자세한 내용은 별도로 글을 작성하도록 하겠다.

copyWith는 nullable 타입을 사용하는 방법 떄문에, null 타입을 사용하지 못하는 문제가 있는데, 아래 공유한 게시글 참고하시면 다양한 copyWith에 구현 방법을 확인하실 수 있습니다.

copyWith에 NULL 사용하는 방법

마무리

Dart 언어에서 사용하는 클래스(class)에 대해 기본적인 사용 방법 부터, 추상화, 상속, 디자인 패턴 및 클래스에서 활용할 수 있는 것들에 대해 다뤄보았다.

자세히 다뤄본 기능도 있고, 깊게 들어가면 내용이 너무 길어져 어쩔 수 없이 개념만 살펴본 기능도 있었다. 기능들에 대해 자세한 설명이 추가적으로 필요한 부분들은 별도로 내용에 대해 글을 작성할 예정이다.

클래스를 다루기 위해 모든 기능을 당연히 알고 있는 것은 중요하지만, 개념 정도만 알고 있더라도 필요시에 적절히 원하는 기능에 대해서만 자세히 살펴볼 수 있으면 된다. 억지로 사용 방법을 외울 필요는 없는 것 같다.
자주 다뤄보면 자연스럽게 익숙해 질 수 있는 기능들이다.

클래스에 대해 궁금하시거나 이해가 잘 되지 않으신 내용들이 있다면 댓글 남겨주시기 바랍니다