[Dart] 객체 지향 프로그래밍

✍ 객체 지향 프로그래밍이란?

프로그래밍에서 필요한 데이터를 추상화시켜상태와 행위를 가진 객체로 만들고, 객체들 간의 상호작용을 통해 로직을 구성하는 프로그래밍 방법이다. 

객체지향 프로그래밍 제대로 이해하기

 

 

✍ Class 사용 방법

void main() {
    // new 키워드를 사용해도 좋고 사용하지 않아도 된다.
    // Idol blackPink = new Idol("블랙 핑크", ["지수", "제니", "리사", "로제"]);
    Idol blackPink = Idol("블랙 핑크", ["지수", "제니", "리사", "로제"]);
  
    print(blackPink.name);
    blackPink.introduce();
}

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

    // 생성자 (constructor)
    Idol(String name, List<String> members)
        : this.name = name,
        this.members = members;
  
    void hello(){
        print("안녕하세요. ${this.name} 입니다.");
    }
   
    void introduce(){
        print("저희 맴버는 ${this.members} 가 있습니다.");
    }
}

method : 클래스 내부에 있는 함수

 

+ 생성자(construct) 사용 방법

void main() {
    Idol blackPink = Idol("블랙 핑크", ["지수", "제니", "리사", "로제"]);
    
    // fromList 를 활용한 선언
    Idol blackPinkFromList = Idol.fromList(
        [
            ["지수", "제니", "리사", "로제"],
            "블랙 핑크"
        ]
    );
}

class Idol {
    String name;
    List<String> members;
  
    Idol(this.name, this.members);
  
    Idol.fromList(List values)
        : this.members = values[0],
          this.name = values[1];
}

 

+ immutable 프로그래밍

한 번 선언하면 변경할 수 없도록 지향하는 프로그래밍 방법이다. 변수 앞에 final 키워드를 사용해 한 번 선언하면 변경 불가능하도록 한다.

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

    Idol(this.name, this.members);
}

 

+ const 적용

const로 선언한 객체(idol, idol2)는 서로 같은 객체이다.

void main() {
    Idol idol = const Idol("지수");
    Idol idol2 = const Idol("지수");
    
    // const 는 빌드 타임시 정의될 수 있어야 하므로 DateTime.now() 는 허용하지 않는다.
    // Idol idol3 = const Idol(DateTime.now().toString());
    
    print(idol == idol2);		// true
}

class Idol {
    final String name;
    
    const Idol(this.name);
}

 

+ getter와 setter

void main() {
    Idol idol = Idol("블랙핑크", ["지수", "로제", "제니", "리사"]);
    
    // getter 사용
    print(idol.firstMember);
    
    // setter 사용
    blackPink.firstMember = "코코"
}

class Idol {
    String name;
    List<String> members;
    
    Idol(this.name, this.members);
    
    /* getter
     * 형식 : (리턴 형식) get (이름) {}
     */
    String get firstMember{
    	return this.members[0];
    }
    
    /* setter
     * 값은 1개만 가능하다.
     * 형식 : set (이름)(값) {}
     */
    set firstMember(String name){
    	this.members[1] = name;
    }
}

 

+ private 속성 부여

private 속성을 부여한다는 건 같은 파일에서는 사용가능하지만 다른 파일에서는 사용하지 못하게 한다는 것을 의미하다.

사용방법은 " _ "를 부여하고 싶은 부분 앞에 붙이면 된다.

void main() {
 _Idol blackPink = const _Idol("블랙 핑크");
}

// constructor(생성자)
class _Idol {
  final String _name;
  
  const _Idol(this._name);

  
  void _hello(){
    print("안녕하세요. ${this._name} 입니다.");
  }
  
}

 

✍ 상속 (inheritance)

부모의 기능들을 자식들에게 물려줄 때 사용한다.

 

상속을 받으면 부모 클래스의 모든 속성을 자식 클래스가 부여받는다. (상속 키워드 : extends, 부모 키워드 : super)

void main() {
    Idol apink = Idol(name: "에이핑크", membersCount: 5);
    
    apink.HelloName();
    apink.HelloMembersCount();
    
    BoyGroup bts = BoyGroup("BTS", 7);
    
    bts.HelloMembersCount();
    
    GirlGroup redVelvet = GirlGroup("레드벨벳", 5);
    
    redVelvet.sayFemale();
}

class Idol{
    String name;
    int membersCount;
    
    Idol({required this.name, required this.membersCount});
    
    void HelloName() {
    	print("저는 ${this.name} 입니다.");
    }
    
   	void HelloMembersCount() {
    	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 (@override)

부모 클래스의 메서드를 자식 클래스에서 재정의하는 것을 override라고 한다.

void main() {
    TimesTwo two = TimesTwo(2);
    TimesFour four = TimesFour(2);
    
    print(two.calculate());
    print(four.calculate());
}

class TimesTwo{
    final int number;
    
    TimesTwo(this.number);
	
    // method
    int calculate(){
    	return number * 2;
    }
}

class TimesFour extends TimesTwo{
	
    TimesFour(int number): super(number);
    
    @override
    int calculate(){
    	return super.number * 4;
        // return super.calculate() * 2;
    }
}

 

✍ static

static 은 instance(객체)에 귀속되지 않고 class에 귀속된다.

void main() {
    Employee.printBuilding();
    Employee yun = Employee("윤");
    Employee kim = Employee("김");
    
    Employee.building = "대한 그룹";
    // static 변수는 클래스에 귀속되기 때문에 객체로 접근하지 못한다.
    // kim.building = "대한 그룹";
    
    yun.printNameAndBuilding();
    kim.printNameAndBuilding();
}

class Employee {
    static String? building;
    final String name;
    
    Employee(this.name);
    
 	void printNameAndBuilding() {
    	print("제 이름은 $name 입니다. $building 건물에서 일하고 있습니다.");
    }
    
    static void printBuilding(){
    	print("저는 $building 건물에서 근무중입니다.");
    }
}

 

 

✍ interface

어떤 특수한 구조를 강제하기 위해 사용된다. (키워드 : implements)

void main() {}

// interface
// abstract 가 앞에 있으면 인스턴스화를 못하게 막을 수 있다.
abstract class IdolInterface {
    String name;
    
    IdolInterface(this.name);

	void sayName() {}
}

// interface 의 시그니처를 맞춰야지만 오류를 나지 않는다.
class BoyGroup implements IdolInterface {
    String name;
    
    Boygroup(this.name);
    
    void sayName() {
    	print("제 이름은 $name 입니다.");
    }
}

interface의 인스턴스화하지 못하게 하기 위해 interface 클래스 앞에 abstract 키워드를 붙일 수 있다.

 

✍ generic

타입을 외부에서 받을 때 사용한다. (<>)

void main() {
    Lecture<String, String> lecture = Lecture("123", "rkddml1");
	
    lecture.printIdType();
}

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

}

 

+ Object 클래스

모든 클래스의 최상위 클래스는 Object 클래스이다.