1
void main() {
2
  Team barca = Team(
3
    '바르샤',
4
    ['메시', '수아레즈', '네이마르']
5
  );
6

7
  print(barca.name);
8
  print(barca.members);
9
  barca.sayHello();
10
  barca.introduce();
11

12
  Team real = Team(
13
    '레알',
14
    ['호날두', '카시야스', '라모스']
15
  );
16
  print(real.name);
17
  print(real.members);
18
  real.sayHello();
19
  real.introduce();
20
}
21

22
class Team {
23
  String name;
24
  List<String> members;
25

26
  // 생성자(constructor) : 클래스가 인스턴스화 될 때 호출되는 함수
27
  Team(String name, List<String> members) :
28
    this.name = name,
29
    this.members = members;
30

31

32
  void sayHello( ) {
33
    print('안녕하세요, ${this.name}입니다.');
34
  }
35

36
  void introduce( ) {
37
    print('우리 팀의 선수들은 ${this.members}입니다.');
38
  }
39
}

1
// 생성자(constructor) : 클래스가 인스턴스화 될 때 호출되는 함수
2
Team(String name, List<String> members) :
3
	this.name = name,
4
	this.members = members;
5

6
Team(this.name, this.members); // 위와 동일한 코드 (생성자 축약형)

1
void main() {
2
  Team barca = Team('바르샤', ['메시', '수아레즈', '네이마르']);
3

4
  print(barca.name);
5
  print(barca.members);
6
  barca.sayHello();
7
  barca.introduce();
8

9
  Team real = Team.fromList([
10
    ['호날두', '카시야스', '라모스'],
11
    '레알',
12
  ]);
13
  print(real.name);
14
  print(real.members);
15
  real.sayHello();
16
  real.introduce();
17
}
18

19
class Team {
20
  String name;
21
  List<String> members;
22

23
  // 생성자(constructor) : 클래스가 인스턴스화 될 때 호출되는 함수
24
  Team(this.name, this.members);
25

26
  // 📌 이름있는 생성자(named constructor) : 생성자를 여러개 만들 수 있음
27
  Team.fromList(List values)
28
      : this.members = values[0],
29
        this.name = values[1];
30

31
  void sayHello() {
32
    print('안녕하세요, ${this.name}입니다.');
33
  }
34

35
  void introduce() {
36
    print('우리 팀의 선수들은 ${this.members}입니다.');
37
  }
38
}
39

1
void main() {
2
  // 📌 const로 선언된 객체는 불변 객체
3
  Team barca = const Team('바르샤', ['메시', '수아레즈', '네이마르']);
4

5
  print(barca.name);
6
  print(barca.members);
7
  barca.sayHello();
8
  barca.introduce();
9

10
  Team real = Team.fromList([
11
    ['호날두', '카시야스', '라모스'],
12
    '레알',
13
  ]);
14
  print(real.name);
15
  print(real.members);
16
  real.sayHello();
17
  real.introduce();
18
}
19

20
class Team {
21
    // 📌 final : 한번 설정되면 변경 불가능
22
  final String name;
23
  final List<String> members;
24

25
  // 생성자(constructor) : 클래스가 인스턴스화 될 때 호출되는 함수
26
  // 📌 const : 객체를 불변 생성자로 만들어줌
27
  const Team(this.name, this.members);
28

29
  // 📌 이름있는 생성자(named constructor) : 생성자를 여러개 만들 수 있음
30
  Team.fromList(List values)
31
      : this.members = values[0],
32
        this.name = values[1];
33

34
  void sayHello() {
35
    print('안녕하세요, ${this.name}입니다.');
36
  }
37

38
  void introduce() {
39
    print('우리 팀의 선수들은 ${this.members}입니다.');
40
  }
41
}

1
void main() {
2
  Team barca = Team('바르샤', ['메시', '수아레즈', '네이마르']);
3
  Team barca2 = Team('바르샤', ['메시', '수아레즈', '네이마르']);
4

5
  print(barca == barca2); // false
6
}
7

8
class Team {
9
  final String name;
10
  final List<String> members;
11

12
  // 생성자(constructor) : 클래스가 인스턴스화 될 때 호출되는 함수
13
  const Team(this.name, this.members);
14
}

1
void main() {
2
  Team barca = const Team('바르샤', ['메시', '수아레즈', '네이마르']);
3
  Team barca2 = const Team('바르샤', ['메시', '수아레즈', '네이마르']);
4

5
  print(barca == barca2); // true
6
}
7

8
class Team {
9
  final String name;
10
  final List<String> members;
11

12
  // 생성자(constructor) : 클래스가 인스턴스화 될 때 호출되는 함수
13
  const Team(this.name, this.members);
14
}

1
void main() {
2
  Team barca = Team('바르샤', ['메시', '수아레즈', '네이마르']);
3

4
  Team real = Team.fromList([
5
    ['호날두', '카시야스', '라모스'],
6
    '레알',
7
  ]);
8

9
  print(barca.firstMember); // 메시
10
  print(real.firstMember); // 호날두
11

12
  barca.firstMember = '피케';
13
  real.firstMember = '베일';
14

15
  print(barca.firstMember); // 피케
16
  print(real.firstMember); // 베일
17
}
18

19
class Team {
20
  String name;
21
  List<String> members;
22

23
  // 생성자(constructor) : 클래스가 인스턴스화 될 때 호출되는 함수
24
  Team(this.name, this.members);
25

26
  Team.fromList(List values)
27
      : this.members = values[0],
28
        this.name = values[1];
29

30
  // getter
31
  String get firstMember {
32
    return this.members[0];
33
  }
34

35
  // setter : 무조건 1개의 인자만 받아야 함
36
  set firstMember(String name) {
37
    this.members[0] = name;
38
  }
39
}

1
void main() {
2
  _Team barca = _Team('바르샤', ['메시', '수아레즈', '네이마르']);
3

4
  _Team real = _Team.fromList([
5
    ['호날두', '카시야스', '라모스'],
6
    '레알',
7
  ]);
8

9
  print(barca.firstMember); // 메시
10
  print(real.firstMember); // 호날두
11

12
  barca.firstMember = '피케';
13
  real.firstMember = '베일';
14

15
  print(barca.firstMember); // 피케
16
  print(real.firstMember); // 베일
17
}
18

19
class _Team {
20
  final String name;
21
  final List<String> members;
22

23
  // 생성자(constructor) : 클래스가 인스턴스화 될 때 호출되는 함수
24
  _Team(this.name, this.members);
25

26
  _Team.fromList(List values)
27
      : this.members = values[0],
28
        this.name = values[1];
29

30
  // getter : 데이터를 간단하게 가공해서 반환할 때 사용
31
  String get firstMember {
32
    return this.members[0];
33
  }
34

35
  // setter : 무조건 1개의 인자만 받아야 함
36
  set firstMember(String name) {
37
    this.members[0] = name;
38
  }
39
}

1
void main() {
2
  print('--------------팀----------------');
3
  Team barca = Team(name: '바르샤', membersCount: 25);
4
  barca.sayName();
5
  barca.sayMembersCount();
6

7
  print('--------------야구팀------------');
8
  BaseballTeam samsung = BaseballTeam(name: '삼성라이온즈', membersCount: 30);
9
  samsung.sayName();
10
  samsung.sayMembersCount();
11
  samsung.sayBaseballTeamName();
12

13
  print('--------------농구팀------------');
14
  BasketballTeam bulls = BasketballTeam(name: '시카고 불스', membersCount: 15);
15
  bulls.sayName();
16
  bulls.sayMembersCount();
17
  bulls.sayBasketballTeamName();
18

19
  print('--------------타입 비교------------');
20
  print(barca is Team); // true
21
  print(barca is BaseballTeam); // false
22
  print(barca is BasketballTeam); // false
23

24
  print('--------------타입 비교2------------');
25
  print(samsung is Team); // true
26
  print(samsung is BaseballTeam); // true
27
  print(samsung is BasketballTeam); // false
28
}
29

30
class Team {
31
  String name;
32
  int membersCount;
33

34
  Team({
35
    required this.name,
36
    required this.membersCount,
37
  });
38

39
  void sayName() {
40
    print('팀명 : $name');
41
  }
42

43
  void sayMembersCount() {
44
    print('팀원 수 : $membersCount');
45
  }
46
}
47

48
class BaseballTeam extends Team {
49
  // super() : 부모 클래스의 생성자를 호출
50
  BaseballTeam({
51
    required String name,
52
    required int membersCount,
53
  }) : super(name: name, membersCount: membersCount);
54

55
  sayBaseballTeamName() {
56
    print('야구팀에서만 쓰는 멘트');
57
  }
58
}
59

60
class BasketballTeam extends Team {
61
  BasketballTeam({
62
    required String name,
63
    required int membersCount,
64
  }) : super(name: name, membersCount: membersCount);
65

66
  sayBasketballTeamName() {
67
    print('농구팀에서만 쓰는 멘트');
68
  }
69
}

1
void main() {
2
  TimesTwo timesTwo = TimesTwo(2);
3
  print(timesTwo.calculate()); // 4
4

5
  TimesFour timesFour = TimesFour(2);
6
  print(timesFour.calculate()); // 8
7
}
8

9
class TimesTwo {
10
  final int number;
11

12
  TimesTwo(
13
    this.number
14
  );
15

16
  // method
17
  int calculate() {
18
    return number * 2;
19
  }
20
}
21

22
class TimesFour extends TimesTwo {
23
  TimesFour(int number) : super(number);
24

25
  @override // 오버라이딩 annotation(주석)
26
  int calculate() {
27
    return super.number * 4;
28
    // return super.calculate() * 2; // 위 코드와 동일한 결과
29
  }
30
}

1
void main() {
2
  Employee seulgi = Employee('슬기');
3
  Employee chorong = Employee('초롱');
4

5
  seulgi.name = '뭐시기';
6
  seulgi.printNameAndBuilding();
7
  chorong.printNameAndBuilding();
8

9
  // 인스턴스가 아닌 class에 귀속되어서,
10
  // 모든 인스턴스에서, 클래스의 건물 이름을 공유한다.
11
  Employee.building = '오투타워';
12
  seulgi.printNameAndBuilding();
13
  chorong.printNameAndBuilding();
14
}
15

16
class Employee {
17
  // static를 붙이면, instance에 귀속되지 않고, class에 귀속된다.
18
  static String? building; // 알바생이 일하고 있는 건물
19
  String name; // 알바생 이름
20

21
  Employee(this.name);
22

23
  void printNameAndBuilding() {
24
    print('이름: $name, 건물: $building');
25
  }
26

27
  static void printBuilding() {
28
    print('건물: $building');
29
  }
30
}

1
void main() {
2
  BoyGroup bts = BoyGroup('BTS');
3
  GirlGroup twice = GirlGroup('TWICE');
4

5
  bts.sayName();
6
  twice.sayName();
7
}
8

9
class IdolInterface {
10
  String name;
11

12
  IdolInterface(this.name);
13

14
  void sayName() {}
15
}
16

17
class BoyGroup implements IdolInterface {
18
  String name;
19

20
  BoyGroup(this.name);
21

22
  void sayName() {
23
    print('그룹명은 $name');
24
  }
25
}
26

27
class GirlGroup implements IdolInterface {
28
  String name;
29

30
  GirlGroup(this.name);
31

32
  void sayName() {
33
    print('그룹명은 $name');
34
  }
35
}

1
void main() {
2
  BoyGroup bts = BoyGroup('BTS');
3
  GirlGroup twice = GirlGroup('TWICE');
4

5
  bts.sayName();
6
  twice.sayName();
7

8
  print(bts is IdolInterface); // true
9
  print(bts is BodyGroup); // true
10
  print(bts is GirlGroup); // false
11

12
  print(twice is IdolInterface); // true
13
  print(twice is BodyGroup); // false
14
  print(twice is GirlGroup); // true
15
}
16

17
abstract class IdolInterface {
18
  String name;
19

20
  IdolInterface(this.name);
21

22
  // 추상적(abstract)이기 때문에 메서드의 body를 지워도 됨
23
  void sayName()
24
}
25

26
class BoyGroup implements IdolInterface {
27
  String name;
28

29
  BoyGroup(this.name);
30

31
  void sayName() {
32
    print('그룹명은 $name');
33
  }
34
}
35

36
class GirlGroup implements IdolInterface {
37
  String name;
38

39
  GirlGroup(this.name);
40

41
  void sayName() {
42
    print('그룹명은 $name');
43
  }
44
}

1
void main() {
2
  Lecture<String, String> lec1 = Lecture('123', '강의1');
3
  lec1.printIdType(); // id의 타입은 String입니다.
4

5
  Lecture<int, String> lec2 = Lecture(123, '강의2');
6
  lec2.printIdType(); // id의 타입은 int입니다.
7
}
8

9
// generic : 타입을 외부에서 받을 떄 사용
10
class Lecture<T, X> {
11
  final T id;
12
  final X name;
13

14
  Lecture(this.id, this.name);
15

16
  void printIdType() {
17
    print('id의 타입은 ${T}입니다.');
18
  }
19
}

1
void main() {
2
  Test t = Test();
3
}
4

5
class Test {}
6
// class Test extends Object {}
7
// 위 코드가 없어도, 모든 클래스가 Object를 상속받는다.