[Dart/Fluter] Dart 언어 배우기 4

링크

• https://www.youtube.com/playlist?list=PLmEhRs1HB7RHX6VbXslXLRYH3HK0fm_Lj
• https://dartpad.dev/?null_safety=true

---

17. Class #1 선언 및 Constructor

• class는 비슷한 성격, 기능의 변수와 함수들을 모아놓는 것이다.
• class는 대문자로 시작.

기본적인 class 선언 및 사용

void main() {
  // OOP - Object Oriented Programming
  // 객체지향 프로그래밍
  
  // Map, List 선언하는 것과 비슷하다
  // Map map = new Map();
  // List list = new List();
  
  // class를 사용하려면 변수로 변경을해서 사용해야한다
  // Instantiation 인스턴스화: class를 인스턴스로 바꾸는 것
  // Instance 인스턴스
  Laptop macBook = new Laptop();
  
  macBook.sayName(); // 제 이름은 맥북입니다.
  
  print(macBook.name); // 맥북
}

class Laptop {
  String name = '맥북';
  
  // this는 class를 가르킨다
  void sayName() {
    print('제 이름은 ${this.name}입니다.');
  }
}

constructor 사용

void main() {
  Laptop macBook = new Laptop(
    '맥북',
    '애플',
  );
  
  macBook.sayName(); // 제 이름은 맥북입니다.
  print(macBook.name); // 맥북
  print(macBook.group); // 애플
}

class Laptop {
  String name;
  String group;

  // 외부에서 가져온 name과 group이 this.name, this.group이 된다
  // constructor
  Laptop(
    String name,
    String group,
  )   : this.name = name,
        this.group = group;

  void sayName() {
    print('제 이름은 ${this.name}입니다.');
  }
}

named 파라미터 활용

void main() {
  Laptop macBook = new Laptop(
    // named parameter를 활용하면 순서가 바뀌어도 상관없다
    group: '애플',
    name: '맥북',
  );

  macBook.sayName(); // 제 이름은 맥북입니다.
  print(macBook.name); // 맥북
  print(macBook.group); // 애플
  
  Laptop chromeBook = new Laptop.fromMap({
    'name': '크롬북',
    'group': '구글',
  });
  
  chromeBook.sayName(); // 제 이름은 크롬북입니다.
  print(chromeBook.name); // 크롬북
  print(chromeBook.group); // 구글
}

class Laptop {
  // final을 사용해서 한 번 선언을 하면 변수의 값을 바꿀 수 없도록 한다
  final String name;
  final String group;

  // #1
  // 외부에서 가져온 name과 group이 this.name, this.group이 된다
  // constructor
  Laptop({String name, String group})
      : this.name = name,
        this.group = group;

  // #2
  // named constructor
  // 한 class 안에서 여러개의 constructor를 생성할 수 있다
  // 즉, class를 인스턴스화 하는 방법이 여러개가 된다는 말
  Laptop.fromMap(
    Map input,
  )   : this.name = input['name'],
        this.group = input['group'];

  void sayName() {
    print('제 이름은 ${this.name}입니다.');
  }
}

---

18. Class #2 Getter and Setter

void main() {
  // Getter Setter
  // Getter -> 값을 가져올때
  // Setter -> 값을 변경할때
  // 다른 파일에서 private 변수를 가져올 때, Getter와 Setter를 사용한다

  Idol seulgi = new Idol(name: '슬기', group: '레드벨벳');

  seulgi.sayName(); // 저는 슬기입니다.

  // 특이한 점은 함수처럼 ()로 호출하는 것이 아니라, 그냥 변수를 가져오는 것처럼 작성한다.
  // _name은 class Idol의 name
  print(seulgi._name); // 슬기
  // name은 Getter의 name
  print(seulgi.name); // 슬기

  // '개발자'가 아래의 Setter의 파라미터로 들어간다
  seulgi.name = '개발자';
  print(seulgi.name); // 개발자
}

class Idol {
  // '_'를 붙이면 private 변수(variable)가 된다
  // Dart는 같은 파일에서 코드가 작성이 되어야만 private 변수를 가져올 수 있다.(JAVA나 다른 언어는 같은 class 안에서만)
  String? _name;
  String? _group;

  Idol({
    String? name,
    String? group,
  })  : this._name = name,
        this._group = group;

  void sayName() {
    print('저는 ${this._name} 입니다.');
  }

  // name은 아무거나 지정해도 상관없지만, 일반적으로 private 변수에서 '_'를 뺀 나머지 이름을 사용한다.
  String? get name {
    return this._name;
  }

  // Setter 변수는 딱 하나만, 위의 '개발자'
  // (String name)은 실제로 입력할 파라미터 name
  set name(String? name) {
    // class Idol의 _name에 파라미터 name을 지정하겠다는 말
    this._name = name;
  }

  // 아래와 같이 함수를 써도 되지만, 일반적으로 private 변수를 변경하거나 바꿀 때, Getter와 Setter를 쓴다. 그 외에는 일반적으로 함수 사용. 뉘앙스적으로 차이가 있다...
  // 함수로 Getter와 Setter와 똑같은 기능을 만들 수는 있다.
  String? getName() {
    return this._name;
  }

  void setName(String name) {
    this._name = name;
  }
}

---

19. Inheritance(상속)

void main() {
  // Inheritance
  // 상속

  print('-----Idol----');
  Idol seulgi = new Idol(name: '슬기', group: '레드벨벳');

  seulgi.sayName();
  seulgi.sayGroup();
  // seulgi.sayMale(); Error

  print('-----BoyGroup----');
  BoyGroup rm = new BoyGroup('RM', 'BTS');

  // 자식은 부모의 모든 함수 및 변수를 상속 받지만
  // 부모는 자식의 어떠한 것도 절대 상속받지 않는다.
  rm.sayName();
  rm.sayGroup();
  rm.sayMale();

  print('-----GirlGroup-----');
  GirlGroup chorong = new GirlGroup('초롱', '에이핑크');
  chorong.sayName();
  chorong.sayGroup();
  chorong.sayFemale();
}

class Idol {
  String name;
  String group;

  Idol({
    required this.name,
    required this.group,
  });

  void sayName() {
    print('저는 ${this.name} 입니다.');
  }

  void sayGroup() {
    print('저는 ${this.group} 소속 입니다.');
  }
}

// extends - 상속 할 때 사용
// 부모 클래스, 자식 클래스
// 부모 클래스는 자식에게 딱 하나의 클래스가 되고, 부모 클래스에는 여러 개의 자식 클래스를 둘 수 있다
// extends 키워드를 사용하는 클래스가 자식 클래스고, extends 다음에 오는 클래스가 부모 클래스다

// #1 Idol클래스의 자식 클래스를 만들어보자
// #2 해석: BoyGroup이라는 클래스를 생성할건데, 이 클래스는 Idol이라는 클래스를 부모 클래스로 사용할 것이다
// #3 코딩에서의 상속은 모든 자식 클래스들이 부모의 클래스를 똑같이 물려받는다.
class BoyGroup extends Idol {
  BoyGroup(
    String name,
    String group,
    // 자식 클래스 안에서 super라는 키워드를 사용하면, 부모 클래스의 constructor를 그대로 사용할 수 있다
    // super 키워드는 부모 클래스(부모 클래스의 constructor)를 의미한다(참고, this는 자기 자신 클래스)
  ) : super(
          name: name,
          group: group,
        );
    // (name: name) super 안의 왼쪽의 name(Idol의 name)에 오른쪽의 name(BoyGroup이 받은 name)을 집어넣는다. group도 마찬가지.

  void sayMale() {
    print('저는 남자 아이돌입니다.');
  }
}

class GirlGroup extends Idol {
  GirlGroup(
    String name,
    String group,
  ) : super(
          name: name,
          group: group,
        );

  void sayFemale() {
    print('저는 여자 아이돌입니다.');
  }
}

---

20. Method Overriding(메서드 덮어쓰기)

void main() {
  // Method Overriding
  // Method 덮어쓰기
  // Method: class 안의 함수

  Parent parent = new Parent(3);
  Child child = new Child(3);
  print(parent.calculate()); // 9
  print(child.calculate()); // 18
}

class Parent {
  final int number;

  Parent(
    int number,
  ) : this.number = number;

  // Function 함수
  // Method
  int calculate() {
    return this.number * this.number;
  }
}

class Child extends Parent {
  Child(int number)
      : super(
          number,
        );

  // @override라는 decorator를 사용해서 부모의 메서드를 덮어쓰기할 수 있다
  // decorator
  @override
  int calculate() {
    // super(부모)라는 키워드를 메서드 안에서도 쓸 수 있다
    int result = super.calculate(); // 3 * 3

    return result + result; // 9 + 9
  }
}