class 이름{
 
}

클래스를 선언할 때 위와 같은 방식으로 선언한다.

• 클래스에 넣어줄 값으로는 다음과 같다
  // name(팀이름) - 변수
  // members(맴버들) - 변수
  // sayHello(인사) - 함수
  // introduce(멤버소개) - 함수

void main() {

}
// Team class
// name(팀이름) - 변수
// members(맴버들) - 변수
// sayHello(인사) - 함수
// introduce(멤버소개) - 함수
class Team{
  String name = '리버풀';
  List<String> members = ['알리송', '반다이크', '핸더슨', '살라'];
  
  void sayHello(){
    print('안녕하세요 리버풀입니다.');
  }
  
  void introduce(){
    print('저희 맴버는 알리송, 반다이크, 핸더슨, 살라 입니다.');
  }
}

• 클래스를 사용해서 인스턴스를 선언하기

void main() {
Team이라는 클래스를 사용해서 변수를 만들 때 Team이라는 타입을 지정해주고 변수이름을 작성하면 된다.

  Team liverpool = Team();
  //Team liverpool = new Team(); new를 넣어도 되고 안넣어도 된다.
  
  print(liverpool.name);
  print(liverpool.members);
  liverpool.sayHello();
  liverpool.introduce();
}

// Team class
// name(팀이름) - 변수
// members(맴버들) - 변수
// sayHello(인사) - 함수
// introduce(멤버소개) - 함수

class Team{
  String name = '리버풀';
  List<String> members = ['알리송', '반다이크', '핸더슨', '살라'];
  
  void sayHello(){
    print('안녕하세요 리버풀입니다.');
  }
  
  void introduce(){
    print('저희 맴버는 알리송, 반다이크, 핸더슨, 살라 입니다.');
  }
}
=>
리버풀
[알리송, 반다이크, 핸더슨, 살라]
안녕하세요 리버풀입니다.
저희 맴버는 알리송, 반다이크, 핸더슨, 살라 입니다.

• 클래스를 사용해서 여러 인스턴스를 생성 할 수 있는데 위에 작성한 방식으로는 한 팀 밖에 작성할 수 밖에 없다.
• 함수에서 파라미터를 받아 반복적인 코드를 제거 할 수 있었던 것처럼 클래스에서도 파라미터를 받을 수 있다.
• constructor 생성자를 사용한다.

void main() {
// 6. 생성자를 만드는 순간 파라미터 값에 에러가 발생한다. 
//    positional parameter를 사용했기 때문에 파라미터 값을 넣어줘야 한다.
  Team liverpool = Team(
    '리버풀',
    ['알리송', '반다이크', '핸더슨', '살라']
  );
  
  print(liverpool.name);
  print(liverpool.members);
  liverpool.sayHello();
  liverpool.introduce();
  
  Team manutd = Team(
    '맨유',
    ['데헤아', '바란', '에릭센', '호날두']
  );
  
  print(manutd.name);
  print(manutd.members);
  manutd.sayHello();
  manutd.introduce();
}

// Team class
// name(팀이름) - 변수
// members(맴버들) - 변수
// sayHello(인사) - 함수
// introduce(멤버소개) - 함수
// constructor (생성자)

class Team{
// 7. 외부에서 값을 받기로 했기 때문에 값을 지워줘도 상관없다.
  String name;
  List<String> members;
  
  // 1. 생성자는 class안에 작성한다.
  // 2. 생성자는 클래스이름(); 형식으로 작성한다. Team()
  // 3. Team(); 파라미터로 바꾸고 싶은 값을 넣어준다. name, members
  // 4. positional parameter 와 named parameter를 사용한다.
  // 5. 파라미터를 받으면 클래스에 저장을 해야한다. 이때 this를 사용한다.
  Team(String name, List<String> members)
     : this.name = name, // this.name은 클래스를 뜻하고 name은 파라미터를 뜻한다.
       this.members = members;
  void sayHello(){
    print('안녕하세요 리버풀입니다.');
  }
  
  void introduce(){
    print('저희 맴버는 알리송, 반다이크, 핸더슨, 살라 입니다.');
  }
}

• 팀이름과 맴버들은 바뀌었지만 인사, 맴버소개는 바뀌지 않았다.
• String 값을 넣어주었기 때문에 바뀌지 않는 것이다.
• 해결하기 위해 this를 활용하면 된다.

void main() {
  Team liverpool = Team('리버풀', ['알리송', '반다이크', '핸더슨', '살라']);

  print(liverpool.name);
  print(liverpool.members);
  liverpool.sayHello();
  liverpool.introduce();

  Team manutd = Team('맨유', ['데헤아', '바란', '에릭센', '호날두']);

  print(manutd.name);
  print(manutd.members);
  manutd.sayHello();
  manutd.introduce();
}

// Team class
// name(팀이름) - 변수
// members(맴버들) - 변수
// sayHello(인사) - 함수
// introduce(멤버소개) - 함수
// constructor (생성자)

class Team {
  String name;
  List<String> members;

  Team(String name, List<String> members)
      : this.name = name,
        this.members = members;

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

  void introduce() {
    print('저희 맴버는 ${this.members} 입니다.');
  }
}

• 생성자 코드를 좀 더 간결하게 수정할 수 있다.

void main() {
  Team liverpool = Team('리버풀', ['알리송', '반다이크', '핸더슨', '살라']);

  print(liverpool.name);
  print(liverpool.members);
  liverpool.sayHello();
  liverpool.introduce();

  Team manutd = Team('맨유', ['데헤아', '바란', '에릭센', '호날두']);

  print(manutd.name);
  print(manutd.members);
  manutd.sayHello();
  manutd.introduce();
}

class Team {
  String name;
  List<String> members;

  Team(this.name, this.members);
  // 클래스의 name과 members를 바로 받아온다.

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

  void introduce() {
    print('저희 맴버는 ${this.members} 입니다.');
  }
}

• named constructor

void main() {
  Team liverpool = Team('리버풀', ['알리송', '반다이크', '핸더슨', '살라']);

  print(liverpool.name);
  print(liverpool.members);
  liverpool.sayHello();
  liverpool.introduce();

  Team manutd = Team.fromList([
    ['데헤아', '바란', '에릭센', '호날두'],
    '맨유'
  ]);

  print(manutd.name);
  print(manutd.members);
  manutd.sayHello();
  manutd.introduce();
}

// Team class
// name(팀이름) - 변수
// members(맴버들) - 변수
// sayHello(인사) - 함수
// introduce(멤버소개) - 함수
// constructor (생성자)

class Team {
  String name;
  List<String> members;

  Team(this.name, this.members);

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

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

  void introduce() {
    print('저희 맴버는 ${this.members} 입니다.');
  }
}

final, const

• 코드의 불변성을 지키기 위해 final, const를 사용한다.
• class에 final를 사용하는 습관을 가져야한다.

void main() {
  Team liverpool = Team('리버풀', ['알리송', '반다이크', '핸더슨', '살라']);

  print(liverpool.name);
  print(liverpool.members);
  liverpool.sayHello();
  liverpool.introduce();

  Team manutd = Team.fromList([
    ['데헤아', '바란', '에릭센', '호날두'],
    '맨유'
  ]);

  print(manutd.name);
  print(manutd.members);
  manutd.sayHello();
  manutd.introduce();
}

// Team class
// name(팀이름) - 변수
// members(맴버들) - 변수
// sayHello(인사) - 함수
// introduce(멤버소개) - 함수
// constructor (생성자)
// immutable

class Team {
  final String name;
  final List<String> members;

  const Team(this.name, this.members);

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

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

  void introduce() {
    print('저희 맴버는 ${this.members} 입니다.');
  }
}

getter / setter

void main() {
  Team liverpool = Team('리버풀', ['알리송', '반다이크', '핸더슨', '살라']);

  Team manutd = Team.fromList([
    ['데헤아', '바란', '에릭센', '호날두'],
    '맨유'
  ]);

  print(liverpool.firstMember);
  print(manutd.firstMember);

  liverpool.firstMember = '고메즈';
  manutd.firstMember = '프레드';

  print(liverpool.firstMember);
  print(manutd.firstMember);
}

// getter / setter
// 데이터를 가져올때 / 데이터를 설정할때
// 데이터를 간단하게 가공할 때 사용한다.

class Team {
  String name;
  List<String> members;

  Team(this.name, this.members);

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

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

  void introduce() {
    print('저희 맴버는 ${this.members} 입니다.');
  }

  // getter
  String get firstMember {
    return this.members[0];
  }

  // setter 무조건 한개 파라미터
  set firstMember(String name) {
    this.members[0] = name;
  }
}

상속

void main() {
  print('---------Team---------');
  Team liverpool = Team(name: '리버풀', membersCount: 11);

  liverpool.sayName();
  liverpool.sayMembersCount();
  
  England manutd = England('맨유', 11);
  
  manutd.sayMembersCount();
  manutd.sayName();
}

// 상속 - inheritance
//
// 상속을 받으면 부모 클래스의 모든 속성을
// 자식 클래스가 부여 받는다.

class Team {
  // 이름
  String name;
  // 멤버숫자
  int membersCount;

  Team({
    required this.name,
    required this.membersCount,
  });

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

  void sayMembersCount() {
    print('${this.name}은 ${this.membersCount}명의 멥버가 있습니다.');
  }
}

class England extends Team {
  England(
    String name,
    int membersCount,
  ) : super(name: name, membersCount: membersCount);
}

@override

void main() {
  TimesTwo tt = TimesTwo(2);

  print(tt.calculate());
  
  TimesFour tf = TimesFour(2);
  
  print(tf.calculate());
}

// method - function (class 내부에 있는 함수)
// override - 덮어쓰다. (우선시하다)

class TimesTwo {
  final int number;

  TimesTwo(
    this.number,
  );

  // method
  int calculate() {
    return this.number * 2; // 클래스에 number 하나만 존재할 경우 this 생략가능.
  }
}

class TimesFour extends TimesTwo{
  TimesFour(
    int number,
  ): super(number);
  
//	 @override
//   int calculate(){
//     return super.number * 4;
//   }
  @override
  int calculate(){
    return super.calculate() * 2; // 부모 클래스에서 calculate()를 불러와서 사용할 수도 있다.
  }
}

static

• static은 인스턴스에 귀속되지 않고 클래스에 귀속된다.

void main(){
  Empoloyee tom = Empoloyee('톰');
  Empoloyee james = Empoloyee('제임스');
  
  tom.name = '마이크';
  tom.printNameAndBuilding();
  james.printNameAndBuilding();
  // 인스턴스에 귀속된다는 것은 인스턴스를 만든 후에 실행하거나 값을 변경할 수 있다는 것을 의미한다.
  
  Empoloyee.building = 'A타워';
  tom.printNameAndBuilding();
  james.printNameAndBuilding();
  // 클래스에 귀속된다는 것은 클래스 이름에 바로 접근할 수 있다는 것이다.
  // static은 클래스 이름에 바로 접근 할 수 있다.
  
  Empoloyee.printBuilding();
}

class Empoloyee{
  // static은 인스턴스에 귀속되지 않고 클래스에 귀속된다.
  // 알바생이 일하고 있는 건물
  static String? building;
  // 알바생 이름
  String name;
  
  Empoloyee(
    this.name,
  );
  
  void printNameAndBuilding(){
    print('제 이름은 $name 입니다. $building 건물에서 근무하고 있습니다.');
  }
  
  static void printBuilding(){
    print('저희는 $building 건물에서 근무중입니다.');
  }
}

interface

• 어떤 특수한 구조를 강제한다.

void main(){
  
}

// interface
class IdolInterface{
  String name;
  
  IdolInterface(this.name);
  
  void sayName(){}
}

class BoyGroup implements IdolInterface{
  
}

• BoyGroup 클래스를 틀을 작성하고 나면 에러가 발생한다.
• 변수 name과 함수 sayName()이 정의되지 않았다는 내용의 에러가 발생한다.
• 에러를 없애주기 위해 아래 코드와 같이 IdolInterface 클래스와 형태를 맞춰줘야 한다.

void main(){
  
}

// interface
class IdolInterface{
  String name;
  
  IdolInterface(this.name);
  
  void sayName(){}
}

class BoyGroup implements IdolInterface{
  String name;
  
  BoyGroup(this.name);
  
  void sayName(){}
}

• interface를 인스턴스화를 방지하기 위해 abstract를 interface를 클래스 앞에 작성해주면 된다.

void main(){
  BoyGroup bts = BoyGroup('BTS');
  GirlGroup redVelvet = GirlGroup('레드벨벳');
  
  bts.sayName();
  redVelvet.sayName();
}

// abstract 사용
// 추상화를 하여 사용을 하지 못하게한다.
// 함수 body 부분을 지워줘도 된다.
abstract class IdolInterface{
  String name;
  
  IdolInterface(this.name);
  
  void sayName()
}

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

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

generic

void main() {
  Lecture<String> lecture1 = Lecture('123', 'lecture');

  lecture1.printIdType();
  
  Lecture<int> lecture2 = Lecture(123, 'lecture');
  
  lecture2.printIdType();
}

// generic - 타입을 외부에서 받을 떄 사용

class Lecture<T> {
  final T id;
  final String name;

  Lecture(this.id, this.name);

  void printIdType() {
    print(id.runtimeType);
  }
}

=> 
String
int

• generic을 여러 번 넣어줄 수 있다.

객체지향 프로그래밍

• Test라는 클래스를 만들고 인스턴스를 작성했다
• test. 을 하면 이미 4개의 속성들이 존재하고 있다.

• 클래스를 선언하면 선언하자마자 Object를 상속 받는다.

class Test extends Object

• extends Object는 모든 클래스들이 상속 받기 때문에 생략이 가능하다.