[플러터] 4. 다트 언어 배우기(객체지향 프로그래밍)

다트 언어는 객체지향 프로그래밍을 지원한다.

 

클래스

// class 정의.
class Person {

	// class 종속 변수
	String name = '이름';
    
    // class 종속 함수 = 메소드
    // 내부 속성을 사용할 때 this 키워드 사용.
    void sayName() {
    	print('My name is ${this.name}');
    }
    
}

 

인스턴스 생성

void main() {
	// 인스턴스 생성
	Person person = Person();
    
    // 메소드 실행.
    person.sayName();
}

 

생성자

class Person {
	// 생성자에서 입력 받는 변수들은 일반적으로 final 키워드 사용.
	final String name;
    
    // 생성자 선언. class 와 같은 이름.
    // 매개변수 지정
    Person(String name) : this.name = name;
    
    // this 를 사용할 경우.
    // 해당되는 변수에 자동을 매개변수가 저장.
    Person(this.name);
    
    void sayName() {
    	print('My name is ${this.name}');
    }
    
}

void main() {
	Persion person = Person('홍길동');
}

 

네임드 생성자

class Person {
	final String name;
    final int age;
    
    // 1개 이상의 변수를 저장할때는 , 기호로 연결.
    Person(String name, int age)
    	: this.name = name,
          this.age = age;
    
    // 네임드 생성자
    Person.fromMap(Map<String, dynamic> map)
    	: this.name = map['name'],
          this.age = map['age'];
    
    void sayName() {
    	print('My name is ${this.name}');
    }
    
}

void main() {
	Persion person = Person('홍길동', 20);
    Persion hong = Person.fromMap({
    	'name' : '홍길동',
        'age' : 20,
    });
}

 

private 변수

class Person {
	// '_' 로 시작하면 private 변수 선언.
	String _name;
    
    Person(this._name);
    
    void sayName() {
    	print('My name is ${this._name}');
    }
    
}

void main() {
	Persion person = Person('홍길동');
    print(person._name); // 같은 파일에서는 에러가 발생하지 않지만 다른 파일에서 사용시 에러 발생.
}

 

Getter / Setter

class Person {
	String _name = 'hong';
    
    // get 키워드를 사용하여 getter 명시
    // 매개변수를 받지 않음.
    String get name {
    	return this._name;
    }
    
    // set 키워드를 사용하여 setter 명시
    // 매개변수로 하나의 변수를 받음.
    set name(String name) {
    	this._name = name;
    }
    
}

void main() {
	Persion person = Person();
    person.name = '홍길동'; // setter
    print(person.name); // getter
}

 

상속

class Person {
	final String name;
    
    Person(this.name);
    
    void sayName() {
    	print('My name is ${name}.');
    }
}

// 상속
class Man extends Person {
	// 상속 받은 생성자
    // super 는 부모 클래스를 의미한다.
	Man(String name) : super(name);
    
    void sayMan() {
    	print('I am a man');
    }
}

void main() {
	Man man = Man('홍길동');
	print(man.sayName()); // 부모한테 물려받은 메소드
    print(man.sayMan()); // 자식이 추가한 메소드
}

 

오버라이드

class Person {
	final String name;
    
    Person(this.name);
    
    void sayName() {
    	print('My name is ${name}.');
    }
}

class Girl extends Person {
    // super 키워드를 직접 사용할 수 있음.
	Girl(super.name);
    
    @override
    void sayName() {
    	print('My name is ${name} and I am a girl');
    }
}

void main() {
	Girl girl = Girl('영희');
	print(girl.sayName()); // override 된 메소드
}

 

인터페이스

// implements 키워드를 사용하면 클래스를 인터페이스로 사용할 수 있다.
class Girl implements Person {
    final String name;
    
	Girl(super.name);
    
    // 인터페이스로 사용할 때는 모든 메소드를 재정의 해야한다.
    void sayName() {
    	print('My name is ${name}');
    }
}

void main() {
	Girl girl = Girl('영희');
	print(girl.sayName());
}

 

믹스인???

 - 이건 잘 모르겠다... --;;;

 

추상 클래스

 - 인스턴스화 할 필요가 없을 경우에 사용

// abstract 키워드를 사용하여 추상 클래스 정의.
abstract class Person {
	final String name;
    
    // 생성자 선언
    Person(this.name);
    
    // 추상 메소드 선언.
    void sayName();
}

// implements 키워드를 사용하여 추상 클래스를 구현.
// 생성자를 비롯하여 모든 메소드를 정의해야 한다.
class Girl implements Person {
	final String name;

    // super 키워드를 직접 사용할 수 있음.
	Girl(this.name);
    
    void sayName() {
    	print('My name is ${name} and I am a girl');
    }
}

void main() {
	Girl girl = Girl('영희');
    print(girl.sayName());
}

 

제너릭

// 제너릭
// 특정 변수의 타입을 제한하고 싶지 않을 때 사용.
// 인스턴스화 할 때 입력받을 타입을 T 로 지정.
class Generate<T> {
	// 데이터 타입을 인스턴스화 할 때 지정한 타입으로 사용.
	final T data;
    
    Generate({
    	required this.data,
    });
}

void main() {
	// 제너릭에 입력된 값을 통해 data 변수의 타입이 자동으로 유추.
	final gen = Generate<List<int>> (data : [1, 2, 3]);
    print(gen.data.reduce((v,e) => v + e); // 6
}

 

static

class Count {
	// static 은 클래스 자체에 귀속
	static int i = 0;
    
    // 생성자가 호출될때 마다 i 증가.
    Count() {
    	i++;
        print(i);
    }
}

void main() {
	Count c1 = Count(); // 1
    Count c2 = Count(); // 2
    Count c3 = Count(); // 3
}

 

Cascade

class Person {
	final String name;
    final int age;
    
    Person(this.name, this.age);
    
    void sayName() {
    	print('My name is ${this.name}');
    }
    
    void sayAge() {
    	print('My age is ${this.age}');
    }
}

void main() {
	// cascade 연산자 ..
    // 인스턴스의 속성이나 메소드를 연속해서 사용하는 것.
	Person person = Person('홍길동', 20)
    	..sayName()
        ..sayAge();
}

 

오늘은 다트의 객체지향 프로그래밍에 대해서 공부했다!!