Dart-객체지향프로그래밍

생성자(constructor)와 getter,setter

void main(){
_Idol blackPink=_Idol(
'블랙핑크'
['지수', '제니','리사','로제'],
);  //인스턴스

_Idol bts=_Idol.fromList([
['RM','진','슈가','제이홉','지민','뷔','정국'],
'BTS'
]
); //인스턴스

print(blackPink.firstMember); //지수

blackPink.firstMember='영지'
print(blackPink.firstMember); //영지

}

class _Idol {
	final String name;
    final List<String> members;
    
   const _Idol(this.name, this.members); //기본 constructor
   
   _Idol.fromList(List values)
   :this.members=values[0],
    this.name=values[1];  //named constructor
 
     
	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;
}

}

단, getter와 setter를 사용할때는 값을 변경하는 경우가 많기 때문에 const나 final을 없애고 사용해야한다
이러한 이유로 데이터의 변경을 만드는 setter는 잘 안쓰는 추세

상속

dart에서는 자식 클래스의 생성자가 부모 클래스의 생성자를 명시적으로 호출해야한다
이를 위해 super 키워드를 사용해야한다

void main(){
  print apink= Idol(name: '에이핑크', memebersCount:5);
  apink.sayName(); // 저는 에이핑크입니다.
  apink.sayMembersCount(); // 에이핑크는 5명의 멤버가 있습니다.
  
  BoyGroup bts =BoyGroup('BTS', 7);
  bts.sayMembersCount(); // BTS는 7명의 멤버가 있습니다.
  bts.sayName();  // 저는 BTS입니다.
  bts.sayMale(); //저는 남자 아이돌입니다.
  
  
  GirlGroup redvelvet = GirlGroup('red velvet',5);
  redvelvet.sayMembersCount();  // redvelvet은 5명의 멤버가 있습니다.
  redvelvet.sayName();  // 저는 red velvet입니다.
  redvelvet.sayFemale(); // 저는 여자아이돌 입니다.
  
  print(apink is Idol); // true
  print(apink is BoyGroup); //false
  print(apink is GirlGroup); //false
  
   print(BTS is Idol); // true
  print(BTS is BoyGroup); //true
  print(BTS is GirlGroup); //false
}

class Idol{
  String name;
  int membersCount;
  
  Idol ({
  required this.name,
  required this.membersCount,
  });
 
 void sayName(){
  print('저는 ${this.name}입니다.');
 }
 void sayMembersCount(){
  print('${this.name}은 ${this.membersCount}명의 멤버가 있습니다.');
 }
 
 class BoyGroup extends Idol{
 BoyGroup(
   String name, 
   int membersCount,
 ):super(
   name:name,
   membersCount:membersCount,
 );
 
 void sayMale(){
   print('저는 남자 아이돌입니다.');
 }
 
 }
 
 class GirlGroup extends Idol{
   GirlGroup(
   String name, 
   int membersCount,
   ): super(name:name, membersCount:membersCount);
   
   void sayFemale(){
    print('저는 여자 아이돌입니다.')
   }
 }
  
}

override

void main(){
 TimesTwo tt= TimesTwo(2);
 print(tt.calculate()); //4
 
 TimesFour tf= TimesFour(2);
 print(tf.calcutate()); //8
}

class TimesTwo{
 final int number;
 
 TimesTwo(
  this.number,
 );
 
// method(function,class내부에 있는 함수)
 int calculate(){
   return number*2;
 }
} 

class TimesFour extends TimesTwo{
  TimesFour(
  int number,
  ):super(number);
  
//  칼큘레이터를 가져와서 4를 곱하는 방법으로 덮어씀
  @override 
  int calculate(){
   return super.number*4 ;
  }
  
// 부모 메소드를 가져와서(number*2) 거기에다가 *2
  @override
  int calculate(){
   return suepr.calculate*2;
  }
}

static

void main(){
 Employee jenney = Employee('제니'); //인스턴스에 귀속 
 Employee.building = '오투타워';  //클래스에 귀속  
 jenny.printNameAndBuilding(); // 제 이름은 제니입니다. 오투타워 건물에서 근무하고 있습니다.
 Employee.printBuilding(); // 저는 오투타워 건물에서 근무중입니다.
}

class Employee{
// static은 instance에 귀속되지 안고 class에 귀속된다
 static String? building;
 final String name;

 Employee(
  this.name,
 );
 
 void printNameAndBuilding(){
 print(`제 이름은 $name입니다. $building 건물에서 근무하고 있습니다.`)
 }
 
static void printNameAndBuilding(){
 print(`$building 건물에서 근무중입니다.`)
 }
 
 }
 

interface

다른 언어에서는 interface 키워드가 따로 있는 경우가 많은데 dart는 추상 클래스로 interface를 생성한다
(앞에 abstract를 붙이는 이유는 인스턴스화를 피하기 위해)

void main(){
 BoyGroup bts = BoyGroup('BTS');
 bts.sayName(); // 제 이름은 BTS입니다.
 
 print(bts is IdolInterface); // true
}

//interface
abstract class IdolInterface{
  string name;
  
  IdolInterface(
  this.name
  );
  
   // abstract를 붙였기 때문에 어떤 형태인지만 작성하면 선언할 수 있다 
  void sayName()

}

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

interface와 enum의 차이

• interface
  특정 메서드 또는 속성을 구현하도록 강제하는 계약을 정의
  dart에서는 abstract class로 정의하고 implements로 키워드를 사용하여 구현
  즉, 클래스간의 공통된 메서드 또는 속성을 정의하는데 사용
• enum
  열거형은 제한된 상수 집합을 정의
  enum키워드를 사용하여 정의하고 고정된 상수 값들을 정의하고 관리하는데 사용

Generic

타입을 외부에서 받을때 사용

void main(){
 Lecture<String> lecture1 = Lecture('123','lecture1');
 lecture1.printIdType(); //Stirng
 
 Lecture<int> lecture2 = Lecture(123,'lecture2');
 lecture2.printIdType(); //int
}

class Lecture<T>{
 final T id;
 final String name;
 
 Lecture(this.id, this.name);
 
 void printIdType(){
   print(id.runtimeType);
 }
}