다트 객체 지향 프로그램

1. 클래스

• 멤버 변수: 클래스에 종속된 변수
• 메서드: 클래스에 종속된 함수
• this 키워드: 클래스 내부 속성을 지칭하는데 사용, 함수 내부에 같은 이름의 변수가 없다면 생략가능

import 'dart:io';
//클래스
class Idol{
  //클래스에 종속되는 변수지정
  String name='블랙핑크';
  
  //클래스에 종속되는 함수=> 메서드

  void sayName(){
    //클래스 내부의 속성을 지칭하고 싶을때는 this 키워드 사용
    print('저는 ${this.name}입니다');
    //스코프 안에 같은 속성이름이 하나만 존재한다면 this 생략가능
    print('저는 $name 입니다');
  }
}

void main() {
  
  //인스턴스 생성
  Idol blackPink=Idol();
  //메서드 실행
  blackPink.sayName();
  
  
}

 

1.2 생성자

• 클래스의 인스턴스를 생성하는 메서드
• 생성자에서 입력받는 변수들은 일반적으로 final 사용

import 'dart:io';
//생성자
//인스턴스를 생성하는 메서드
class Idol{
  //생성자에서 입력받는 변수들은 일반적으로 final 키워드 사용
  final String name;
  // 생성자 선언
  // 클래스와 같은 이름이어랴함
  // 함수의 매개변수를 선언하는 것처럼 매개변수를 지정해줌
  Idol(String name):this.name=name;
   //변수 저장과정을 생략하는 버전
  //Idol(this.name);
  
  void sayName(){
    print('저는 ${this.name}입니다');
  }
}

void main() {
  
  //인스턴스 생성
  Idol blackPink=Idol('블랙핑크');
  //메서드 실행
  blackPink.sayName();

  //name 에 BTS 저장
  Idol bts=Idol('BTS');
  bts.sayName();
  
  
}

 

1.2.1 네임드 생성자

• 클래스를 생성하는 방법을 여러가지 명시하고 싶을때 사용
• {클래스명.네임드 생성자명} 형식
• 나머지 과정은 기본 생성자와 같음

import 'dart:io';
//네임드 생성자

class Idol {
  final String name;
  final int membersCount;

  Idol(String name, int membersCount)
      //1개 이상의 변수를 저장하고 싶을때는 기호로 연결해주면 됨.
      : this.name = name,
        this.membersCount = membersCount;

  //네임드 생성자
//{클래스명.네임드 생성자명} 형식
//나머지 과정은 기본 생성자와 같음
  Idol.fromMap(Map<String, dynamic> map)
      : this.name = map['name'],
        this.membersCount = map['membersCount'];
  void sayName(){
    print('저는 ${this.name}입니다. ${this.name} 멤버는'
        '${this.membersCount}명 입니다 ');

  }
}

void main() {

  //기본 생성자 사용
  Idol blackPink=Idol('블랙핑크', 4);
  blackPink.sayName();

  //formMap이라는 네임드 생성자사용
  Idol bts=Idol.fromMap({'name':'BTS','membersCount':7,} );
  bts.sayName();
}

1.2.2 프라이빗 변수

• 같은 파일에서만 접근 가능한 변수
•  _  기호로 시작해 선언가능

import 'dart:io';
//프라이빗변수
//같은 파일에서만 접근 가능한 변수

class Idol {
  // '_'로 변수명을 시작하면
  // 프라이빗 변수를 선언할수 있음
  String _name;
  Idol(this._name);
}

void main() {
  Idol blackPink=Idol('블랙핑크');

  //같은 파일에서는  _name 변수에 접근할수 있지만
  // 다른 파일에서는 접근 불가
  print(blackPink._name);

}

 

1.2.3 게터/세터

• 게터: 값을 가져올때 사용, 프라이빗 변수를 외부에서 접근할수 있게 만듬.
• 세터:값을 지정할때 사용
• 사용시 모두 변수처럼 사용한다. 즉 사용할때 메서드명뒤에 ()를 붙이지 않음.
• 세터는 거의 사용하지 않지만 , 게터는 종종 사용함.

import 'dart:io';

class Idol {

  String _name = '블랙핑크';

  //get 키워드를 사용해서 게터임을 명시
  //게터는 메서드와 다르게 매개변수를 전혀 받지 않는다.
  String get name {
    return this._name;
  }

//세터는 set이라는 키워드를 사용해서 선언
//세터는 매개변수로 딱하나의 변수를 받을수 있음
  set name(String name){
    this._name=name;
  }
}

void main() {
  Idol blackPink = Idol();
  blackPink.name='에이핑크';
  print(blackPink.name);
}

2. 상속

• extends 키워드 사용 {class 자식 클래스 extends 부모 클래스}
• 어떤 클래스 기능을 다른 클래스가 사용할수 있게하는 기법
• 부모 클래스 :기능을 물려주는 클래스
  자식 클래스: 기능을 물려받는 클래스
• super 키워드 : 상속한 부모 클래스를 지칭함.

import 'dart:io';


class Idol {
  final String name;
  final int membersCount;
  Idol(this.name,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,membersCount,); //super은 부모 클래스 지칭
  //상속받지 않은 기능

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

void main() {
  BoyGroup bts=BoyGroup('BTS', 7);
  bts.sayName();
  bts.sayMembersCount();//부모한테 물려 받은 메서드
  bts.sayMale();// 자식이 새로 추가한 메서드
}

3. 오버라이드

• 부모 클래스 또는 인터페이스에 정의된 메서드를 재정의 할때 사용됨.
• @override 키워드를 사용함.

import 'dart:io';

class Idol {
  final String name;
  final int membersCount;
  Idol(this.name,this.membersCount);

  void sayName(){
    print('저는 ${this.name}입니다');
  }
  void sayMembersCount(){
    print('${this.name} 멤버는 ${this.membersCount} 명 입니다.');
  }
}


class GirlGroup extends Idol{
  GirlGroup(super.name,super.membersCount);

  @override //override 키워드를 사용!
  void sayName(){
    print('저는 여자아이돌 ${this.name}입니다');
  }
}

void main() {

  GirlGroup blackPink=GirlGroup('블랙핑크', 4);
  blackPink.sayName(); //자식클래스로 오버라이딩된 메서드

  //sayNameCount는 오버라이드 하지 않았기때문에
  // 그대로 Idol 클래스의 메서드가 실행됩니다.
  blackPink.sayMembersCount();
}

 

4. 인터페이스

• 공통으로 필요한 기능을 정의만 해두는 역할
• 상속은 단하나의 클래스만 가능하지만 인터페이스는 적용 개수에 제한이 없다.
• implements 키워드 사용
• 반드시 모든 기능을 재정의 해야함!

import 'dart:io';

class Idol {
  final String name;
  final int membersCount;

  Idol(this.name, this.membersCount);

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

  void sayMembersCount() {
    print('${this.name} 멤버는 ${this.membersCount} 명 입니다.');
  }
}

// implements 키워드를 사용하면 원하는 클래스를 인터페이스로 사용가능
class GirlGroup implements Idol {
  final String name;
  final int membersCount;

  GirlGroup(this.name, this.membersCount);
  //인터페이스는 반드시 모든 기능을 다시 정의해 줘야함!
  void sayName() {
    print('저는 여자아이돌 ${this.name}입니다');
  }

  void sayMembersCount() {
    print('${this.name}멤버는 ${this.membersCount} 명 입니다!');
  }
}

void main() {
  GirlGroup blackPink = GirlGroup('블랙핑크', 4);
  blackPink.sayName();
  blackPink.sayMembersCount();
}

 

5. 믹스인

• 특정 클래스에 원하는 기능만 골라 넣을 수 있는 기능
• 한개의 클래스에 여러개이 믹스인 적용가능

 

import 'dart:io';
 class Idol {
  final String name;
  final int membersCount;

  Idol(this.name, this.membersCount);

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

  void sayMembersCount() {
    print('${this.name} 멤버는 ${this.membersCount} 명 입니다.');
  }
}

mixin IdolSingleMixin on Idol{ //믹스인 정의
   void sing(){
     print('${this.name}이 노래를 부릅니다.');
   }
}

//믹스인을 적용할때는 with 키워드 사용
class BoyGroup extends Idol with IdolSingleMixin{
   BoyGroup(super.name,super.membersCount);

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


void main() {

   BoyGroup bts=BoyGroup('BTS', 7);
   //믹스인에 정의된 sing()함수 사용가능
  bts.sing();

}

 

6. 추상

• abstract 키워드 사용
• 상속이나 인터페이스로 사용하는데 필요한 속성만 정의하고 인스턴스화 할수도 없도록하는 기능
• 추상 클래스는 추상메서드를 선언할수 있으며 추상메서드는 함수의 반환타입, 이름 매개변수만을 정의하고
  함수의 바디의 선언을 자식클래스에서 필수로 정의하도록 강제함.

import 'dart:io';

abstract class Idol {//추상 클래스 지정
  final String name;
  final int membersCount;

  Idol(this.name, this.membersCount);//생성자 선언

  void sayName() ;//추상메서드 선언
  void sayMembersCount() ;
}

class GirlGroup implements Idol{
  final String name;
  final int membersCount;

  GirlGroup(this.name,this.membersCount);


  @override
  void sayMembersCount() {
    // TODO: implement sayMembersCount
    print('${this.name}의 멤버는 ${this.membersCount}명 입니다');
  }

  @override
  void sayName() {
    // TODO: implement sayName
    print('저는 여자아이돌 ${this.name}입니다');
  }

}


void main() {

  GirlGroup blackPink=GirlGroup('블랙핑크', 4);
  blackPink.sayName();
  blackPink.sayMembersCount();

}

 

7. 제네릭 ☆

• 특정변수의 타입을 하나의 타입으로 제한하고 싶지 않을때 자주 사용함.
• 인스턴스화 할때 입력받을 타입을 T로 지정함.
• 제네릭문자: <> 사이에 입력되는 값

import 'dart:io';

//인스턴스화 할때 입력받을 타입을 T로 지정함.
class Cache<T> {
  //data의 타입을 추후 입력될 T타입으로 지정함.
  final T data;

  Cache({required this.data});

}

void main() {
  //T의 타입을 List<int>로 입력
  final cache=Cache<List<int>>(data: [1,2,3]);

  //제네릭에 입력된 값을 통해 data 변수의 타입이 자동으로 유추됨
  print(cache.data.reduce((v,e)=>v+e));
}

8. 스태틱

• static 키워드로 선언되며 클래스 자체에 귀속됨.
• (기존의 변수와 메서드는 각 클래스의 인스턴스에 귀속되었음.)

import 'dart:io';


class Counter{
  // static 키워드를 사용해 변수선언
  static int i=0;

  Counter(){
    i++;
    print(i);
  }
}

void main() {
  Counter count1=Counter();
  Counter count2=Counter();
  Counter count3=Counter();
}

9. 캐스케이드 연산자

• 해당 인스턴스의 속성이나 멤버함수를 연속해서 사용하는 기능
• cascade operator(..)을 사용하면 선언한 변수의 메서드를 연속으로 실행할수 있음

import 'dart:io';


class Idol {
  final String name;
  final int membersCount;
  Idol(this.name,this.membersCount);

  void sayName(){
    print('저는 ${this.name}입니다');
  }
  void sayMembersCount(){
    print('${this.name} 멤버는 ${this.membersCount} 명 입니다.');
  }
}


void main() {
  //cascade operator(..)을 사용하면
  // 선언한 변수의 메서드를 연속으로 실행할수 있음

  Idol blackPink=Idol('블랙핑크', 4)
      ..sayName()
      ..sayMembersCount();
}