[Dart 언어강좌] 011. Dart에서 사용되는 콜렉션, List, Set, Map의 사용법

Dart 언어는 강력한 타입 시스템과 함께 매우 뛰어난 콜렉션 라이브러리를 제공합니다.
Dart에서의 콜렉션이란 데이터를 저장하고 조작할 수 있는 객체를 의미합니다.
본 글에서는 List, Set, Map이라는 세 가지 주요 콜렉션에 대해 자세히 알아보고, 다양한 사용법과 예제를 통해 각 콜렉션의 특징을 설명하겠습니다.

1. List

List는 순서가 있는 데이터를 저장하는 콜렉션입니다.
Dart의 List는 배열(array)와 유사하게 동작하지만, 크기가 동적으로 변경될 수 있습니다.
List는 같은 데이터 타입의 객체 뿐만 아니라 다양한 데이터 타입의 객체도 저장할 수 있습니다.

1.1. List 생성

void main() {
    // 빈 리스트 생성
    List<int> numbers = [];
    
    // 초기 값으로 리스트 생성
    List<String> fruits = ['Apple', 'Banana', 'Cherry'];
    
    // 리스트의 크기 지정
    List<double> temperatures = List.filled(5, 0.0);
    
    print(numbers); // []
    print(fruits); // [Apple, Banana, Cherry]
    print(temperatures); // [0.0, 0.0, 0.0, 0.0, 0.0]
}

1.2. List의 주요 메서드

List 객체에는 데이터 조작을 위한 여러 가지 메서드가 있습니다.
몇 가지 주요 메서드와 그 사용 예제를 소개합니다.

void main() {
    List<String> fruits = ['Apple', 'Banana', 'Cherry'];

    // 추가
    fruits.add('Dragonfruit');
    print(fruits); // [Apple, Banana, Cherry, Dragonfruit]

    // 여러 개 추가
    fruits.addAll(['Elderberry', 'Fig']);
    print(fruits); // [Apple, Banana, Cherry, Dragonfruit, Elderberry, Fig]

    // 삭제
    fruits.remove('Banana');
    print(fruits); // [Apple, Cherry, Dragonfruit, Elderberry, Fig]

    // 인덱스 사용
    String firstFruit = fruits[0];
    print(firstFruit); // Apple

    // 길이
    int length = fruits.length;
    print(length); // 5
}

1.3. List의 반복 처리

List에 저장된 데이터에 대한 반복 처리는 for 루프, forEach 메서드를 통해 수행할 수 있습니다.

void main() {
    List<String> fruits = ['Apple', 'Banana', 'Cherry'];

    // for 루프 사용
    for (var fruit in fruits) {
        print(fruit);
    }

    // forEach 메서드 사용
    fruits.forEach((fruit) {
        print(fruit);
    });
}

2. Set

Set은 중복되지 않는 유일한 객체의 모음입니다.
Set 콜렉션은 요소의 순서에 의존하지 않으며, 값의 존재 유무만으로 데이터를 관리합니다.
Dart에서 Set은 추가, 삭제, 포함 여부 확인 등을 빠르게 수행할 수 있습니다.

2.1. Set 생성

void main() {
    // 빈 세트 생성
    Set<int> uniqueNumbers = {};
    
    // 초기 값으로 세트 생성
    Set<String> uniqueFruits = {'Apple', 'Banana', 'Cherry'};
    
    print(uniqueNumbers); // {}
    print(uniqueFruits); // {Apple, Banana, Cherry}
}

2.2. Set의 주요 메서드

Set 객체에도 다양한 메서드가 존재합니다.

void main() {
    Set<String> uniqueFruits = {'Apple', 'Banana', 'Cherry'};

    // 추가
    uniqueFruits.add('Dragonfruit');
    print(uniqueFruits); // {Apple, Banana, Cherry, Dragonfruit}

    // 중복 추가는 무시됨
    uniqueFruits.add('Apple');
    print(uniqueFruits); // {Apple, Banana, Cherry, Dragonfruit}

    // 삭제
    uniqueFruits.remove('Banana');
    print(uniqueFruits); // {Apple, Cherry, Dragonfruit}
    
    // 길이
    int length = uniqueFruits.length;
    print(length); // 3
}

2.3. Set의 반복 처리

Set도 List와 마찬가지로 반복 처리를 지원합니다.

void main() {
    Set<String> uniqueFruits = {'Apple', 'Banana', 'Cherry'};

    // for 루프 사용
    for (var fruit in uniqueFruits) {
        print(fruit);
    }

    // forEach 메서드 사용
    uniqueFruits.forEach((fruit) {
        print(fruit);
    });
}

3. Map

Map은 키와 값의 쌍으로 데이터에 접근하는 유용한 콜렉션입니다.
키는 고유해야 하며, 각각의 키는 하나의 값에만 연결될 수 있습니다.
Map을 사용하면 데이터의 빠른 검색 및 관리를 할 수 있습니다.

3.1. Map 생성

void main() {
    // 빈 맵 생성
    Map<String, int> fruitPrices = {};
    
    // 초기 값으로 맵 생성
    Map<String, String> countryCapitals = {
        'USA': 'Washington D.C.',
        'France': 'Paris',
        'Japan': 'Tokyo',
    };
    
    print(fruitPrices); // {}
    print(countryCapitals); // {USA: Washington D.C., France: Paris, Japan: Tokyo}
}

3.2. Map의 주요 메서드

Map에서도 다양한 메서드를 통해 데이터 조작이 가능합니다.

void main() {
    Map<String, int> fruitPrices = {
        'Apple': 3,
        'Banana': 1,
        'Cherry': 5,
    };

    // 추가
    fruitPrices['Dragonfruit'] = 4;
    print(fruitPrices); // {Apple: 3, Banana: 1, Cherry: 5, Dragonfruit: 4}

    // 수정
    fruitPrices['Banana'] = 2;
    print(fruitPrices); // {Apple: 3, Banana: 2, Cherry: 5, Dragonfruit: 4}

    // 삭제
    fruitPrices.remove('Cherry');
    print(fruitPrices); // {Apple: 3, Banana: 2, Dragonfruit: 4}

    // 키 존재 여부 확인
    bool hasBanana = fruitPrices.containsKey('Banana');
    print(hasBanana); // true

    // 길이
    int length = fruitPrices.length;
    print(length); // 3
}

3.3. Map의 반복 처리

Map의 모든 키와 값에 대한 반복 처리는 다음과 같이 수행할 수 있습니다.

void main() {
    Map<String, int> fruitPrices = {
        'Apple': 3,
        'Banana': 1,
        'Cherry': 5,
    };

    // keys() 메서드로 반복
    for (var key in fruitPrices.keys) {
        print('Fruit: $key, Price: ${fruitPrices[key]}');
    }

    // entries() 메서드로 반복
    fruitPrices.forEach((key, value) {
        print('Fruit: $key, Price: $value');
    });
}

결론

Dart의 List, Set, Map은 각각의 특성과 장점을 가지고 있어 다양한 상황에서 효과적으로 데이터를 관리할 수 있습니다.
List는 순서가 있는 데이터 컬렉션, Set은 고유성을 보장하는 컬렉션, Map은 키-값 쌍으로 데이터를 관리하는 데 적합하다는 점을 이해하는 것이 중요합니다.
이를 통해 다양한 프로그래밍 문제를 해결하고, 깔끔하고 효율적인 코드를 작성할 수 있습니다.

[Dart 언어강좌] 008. 객체지향 프로그래밍 (OOP) 소개, 클래스와 객체

작성자: 조광형

작성일: 2024년 11월 28일

1. 객체지향 프로그래밍 (OOP)란?

객체지향 프로그래밍(Object-Oriented Programming, OOP)은 프로그램을 객체를 중심으로 구성하는 프로그래밍 패러다임입니다. 객체는 데이터와 이 데이터를 다루는 함수를 캡슐화하여 소프트웨어의 복잡성을 줄이고 코드의 재사용성을 높이는 데 기여합니다. OOP의核心 개념은 다음과 같습니다:

  • 캡슐화(Encapsulation): 데이터와 메서드를 하나의 단위로 묶어 외부로부터 보호합니다. 이를 통해 객체의 내부 상태를 제어할 수 있으며, 인터페이스를 통해서만 상호작용할 수 있습니다.
  • 상속(Inheritance): 기존의 클래스를 바탕으로 새로운 클래스를 생성할 수 있는 기능입니다. 이를 통해 코드의 재사용성을 높이고, 계층 구조를 생성할 수 있습니다.
  • 다형성(Polymorphism): 동일한 인터페이스를 통해 여러 다른 형태의 객체를 사용할 수 있는 능력입니다. 이는 코드를 더 유연하게 만들어 주며, 유지보수를 용이하게 합니다.
  • 추상화(Abstraction): 불필요한 세부 사항을 숨기고 중요한 정보만을 드러내는 프로세스입니다. 이로 인해 더 나은 설계와 구현이 가능합니다.

Dart 언어는 OOP의 이러한 개념을 잘 지원하며, 개발자가 이들을 쉽게 활용할 수 있도록 다양한 기능을 제공합니다.

2. 클래스(Class)와 객체(Object)

클래스와 객체는 OOP에서 가장 기본적인 개념입니다. 이들에 대한 이해는 객체지향 프로그래밍을 잘 활용하는 데 필수적입니다.

2.1 클래스(Class)

클래스는 객체를 생성하기 위한 템플릿 또는 청사진입니다. 클래스 안에는 객체가 가질 수 있는 속성과 메서드가 정의됩니다. Dart에서는 클래스를 다음과 같이 정의할 수 있습니다:

class Animal {
    String name;
    int age;
    
    Animal(this.name, this.age);
    
    void speak() {
        print('$name says hello!');
    }
}

위의 코드에서 Animal이라는 클래스는 nameage라는 두 속성을 가집니다. 생성자 Animal(this.name, this.age);를 통해 객체가 생성될 때 이 속성을 초기화합니다. speak()라는 메서드를 포함하여 객체가 ‘말하는’ 기능을 제공합니다.

2.2 객체(Object)

객체는 클래스의 인스턴스입니다. 즉, 클래스를 기반으로 만들어진 구체적인 데이터 구조입니다. 객체는 클래스에서 정의된 속성과 메서드를 모두 가집니다. 클래스를 사용하여 객체를 생성하는 방법은 다음과 같습니다:

void main() {
    Animal dog = Animal('Buddy', 3);
    dog.speak(); // Output: Buddy says hello!
}

위의 예제에서 Animal 클래스의 인스턴스인 dog를 생성하고, 이 객체가 speak() 메서드를 호출하여 ‘Buddy says hello!’를 출력합니다.

2.3 클래스와 객체의 관계

대부분의 프로그램은 클래스와 객체 간의 관계로 구축됩니다. 클래스는 객체를 만들기 위한 템플릿으로 기능하며, 객체는 그 클래스를 통해 정의된 모든 속성과 기능을 실체화한 것입니다. 이러한 구조는 소프트웨어 설계를 더욱 쉽게 하고, 코드를 더 조직적으로 유지할 수 있게 해 줍니다.

3. 예제: 자동차 클래스 만들기

이제 자동차를 나타내는 클래스를 만들어 보겠습니다. 이 자동차 클래스는 여러 속성과 메서드를 가질 것입니다. 다음과 같은 구조를 가질 것입니다:

class Car {
    String make;
    String model;
    int year;
    
    Car(this.make, this.model, this.year);
    
    void displayInfo() {
        print('Car: $make $model ($year)');
    }
    
    void start() {
        print('$make $model is starting.');
    }
}

위의 Car 클래스는 자동차의 제조사, 모델, 연도를 속성으로 가지고 있습니다. 또한 자동차 정보를 출력하는 displayInfo() 메서드와 자동차를 시작하는 start() 메서드를 포함합니다.

3.1 객체 생성 및 메서드 사용

void main() {
    Car myCar = Car('Toyota', 'Corolla', 2020);
    myCar.displayInfo(); // Output: Car: Toyota Corolla (2020)
    myCar.start(); // Output: Toyota Corolla is starting.
}

이렇게 Car 클래스의 객체를 생성하고, 두 개의 메서드를 호출하여 자동차 정보를 출력하고 자동차를 시작했습니다.

4. OOP의 장점

OOP는 여러 가지 장점을 제공하여 소프트웨어 개발에 긍정적인 영향을 미칩니다. 여기에서는 OOP의 주요 이점에 대해 설명합니다:

  • 코드 재사용성: 상속과 다형성을 활용하여 기존 코드를 재사용할 수 있어 개발 효율성을 높입니다.
  • 유지보수 용이성: 캡슐화를 통해 내부 구현을 숨길 수 있어 코드 수정 시 위험이 줄어듭니다.
  • 코드 조직화: 클래스를 통해 코드의 구조를 명확히 하고, 각 기능을 분리하여 관리할 수 있습니다.
  • 모델링: 현실 세계의 객체를 반영할 수 있어 소프트웨어 설계를 더 직관적으로 만들 수 있습니다.

5. 결론

객체지향 프로그래밍은 현대 소프트웨어 개발의 중요한 패러다임이며, Dart 언어는 이 OOP 개념을 잘 구현할 수 있게 도와줍니다. 클래스와 객체를 이해하고 활용함으로써 더 나은 설계와 유지보수가 쉬운 코드를 작성할 수 있습니다. 객체지향 프로그래밍을 배우고 활용하는 것은 모든 개발자에게 유용한 기술입니다. 따라서 OOP를 지속적으로 연습하고 이해를 깊이 있는 접근 방식을 추천합니다.

[Dart 언어강좌] 009. 객체지향 프로그래밍 (OOP) 소개, 상속과 다형성

저자: 당신의 이름

작성일: YYYY-MM-DD

1. 객체지향 프로그래밍 (OOP)란?

객체지향 프로그래밍(Object-Oriented Programming, OOP)은 프로그램을 ‘객체’로 구성하여 소프트웨어를 설계하고 개발하는 프로그래밍 패러다임입니다. 이 객체는 데이터와 데이터에 대한 처리를 포함한 메서드로 구성됩니다. OOP의 주요 원칙으로는 캡슐화(Encapsulation), 상속(Inheritance), 다형성(Polymorphism) 및 추상화(Abstraction)가 있습니다.

OOP의 장점은 코드의 재사용성, 가독성 및 유지보수성을 높여줍니다. Dart 언어는 OOP를 잘 지원하며, 이러한 개념을 손쉽게 적용할 수 있는 강력한 기능을 제공합니다.

2. Dart의 OOP 기본 개념

Dart에서 클래스(class)는 객체를 생성하기 위한 청-print로, 클래스 내부에 변수(속성)와 메서드(함수)를 정의할 수 있습니다. 객체는 클래스의 인스턴스(instance)로, 클래스의 구조에 따라 다양한 속성과 행동을 가집니다.

아래는 간단한 Dart 클래스의 예제입니다:

class Animal {
    String name;
    int age;

    Animal(this.name, this.age);

    void describe() {
        print('이름: $name, 나이: $age');
    }
}

void main() {
    Animal dog = Animal('강아지', 3);
    dog.describe();  // 출력: 이름: 강아지, 나이: 3
}

위 코드는 Animal이라는 클래스를 정의하고, 해당 클래스의 인스턴스를 생성하여 describe 메서드를 호출하는 예시입니다.

3. 상속 (Inheritance)

상속은 기존 클래스(부모 클래스 또는 슈퍼 클래스)의 속성과 메서드를 새로운 클래스(자식 클래스 또는 서브 클래스)에 물려주는 과정입니다. 이를 통해 코드 재사용성을 높이고, 계층 구조를 형성할 수 있습니다.

Dart에서 상속을 구현하는 방법은 다음과 같습니다:

class Animal {
    String name;

    Animal(this.name);

    void makeSound() {
        print('$name이 소리를 낸다.');
    }
}

class Dog extends Animal {
    Dog(String name) : super(name);

    void makeSound() {
        print('$name이 멍멍거리다.');
    }
}

void main() {
    Dog dog = Dog('바둑이');
    dog.makeSound();  // 출력: 바둑이가 멍멍거리다.
}

위 예제에서 Dog 클래스는 Animal 클래스를 상속받아 기존의 makeSound 메서드를 오버라이드(재정의)합니다. 이를 통해 개는 고유의 소리를 낼 수 있습니다.

4. 다형성 (Polymorphism)

다형성은 동일한 메서드 이름이 다른 클래스에서 서로 다르게 동작하도록 하는 OOP의 특성입니다. 상속과 함께 사용되는 경우, 부모 클래스의 메서드를 자식 클래스에서 재정의하여 다형성을 구현할 수 있습니다.

아래 예제는 다형성을 설명합니다:

class Animal {
    void makeSound() {
        print('동물이 소리를 낸다.');
    }
}

class Cat extends Animal {
    @override
    void makeSound() {
        print('고양이가 야옹거린다.');
    }
}

class Dog extends Animal {
    @override
    void makeSound() {
        print('개가 멍멍거린다.');
    }
}

void main() {
    List<Animal> animals = [Cat(), Dog()];

    for (var animal in animals) {
        animal.makeSound();
    }
    // 출력:
    // 고양이가 야옹거린다.
    // 개가 멍멍거린다.
}

이 예제에서 동물의 목록을 만들어 각 동물의 makeSound 메서드를 호출합니다. 각 동물 클래스는 부모 클래스의 메서드를 재정의하여 고유의 소리를 내게 됩니다. 다형성을 통해 코드의 유연성과 확장성을 높일 수 있습니다.

5. 결론

객체지향 프로그래밍(OOP)은 프로그램 구조를 보다 효율적으로 만들고, 코드의 재사용성 및 유지보수성을 높이는 데 기여합니다. Dart 언어는 OOP 패러다임을 지원하여 개발자가 객체, 상속 및 다형성과 같은 개념을 쉽게 구현할 수 있도록 돕습니다.

이번 글에서는 OOP의 기본 개념과 Dart에서의 구현 방법을 설명하였습니다. 이러한 OOP 원칙을 적용하면 보다 효율적이고 깔끔한 소프트웨어 설계가 가능해집니다. 향후 Dart를 활용하여 다양한 프로젝트를 진행하면서 OOP의 힘을 느껴보시기 바랍니다.

[Dart 언어강좌] 010. 객체지향 프로그래밍 (OOP) 소개, 추상 클래스와 인터페이스

프로그램을 구조적이고 효율적으로 작성하는 데 중요한 개념 중 하나는 객체지향 프로그래밍(Object-Oriented Programming, OOP)입니다. Dart 언어는 이러한 OOP 개념을 바탕으로 설계된 언어로, 코드를 재사용하고 유지보수하기 쉽게 만들어 줍니다. OOP의 중요한 구성 요소인 추상 클래스와 인터페이스를 살펴보겠습니다.

1. 객체지향 프로그래밍(OOP) 개념

객체지향 프로그래밍은 프로그램을 ‘객체’라는 독립적인 단위로 구성하여 문제를 해결하는 방식입니다. 객체는 상태(속성)와 동작(메서드)을 포함하여 프로그램의 로직을 모듈화할 수 있게 합니다. 주요 OOP 개념은 다음과 같습니다:

  • 캡슐화(Encapsulation): 객체의 내부 상태를 보호하고, 외부에서 접근할 수 없도록 하는 방법입니다. 이를 통해 코드의 재사용성과 유지보수성을 높입니다.
  • 상속(Inheritance): 기존 클래스를 기반으로 새로운 클래스를 생성하여, 코드의 재사용성과 기능 확장을 용이하게 합니다.
  • 다형성(Polymorphism): 동일한 이름의 메서드가 다양한 동작을 수행하도록 하는 기능입니다. 이는 프로그램의 유연성을 증가시킵니다.

2. 추상 클래스(Abstract Class)

추상 클래스는 완전한 구현이 아닌 메서드의 정의를 포함하는 클래스입니다. 추상 클래스는 다른 클래스에 상속받아 사용되며, 직접 인스턴스화할 수 없습니다. 이는 프로그래머에게 강력한 설계 계약을 제공하는 역할을 합니다.

단순한 추상 클래스 예제

아래는 Dart에서 추상 클래스를 정의하고 사용하는 예제입니다.

abstract class Animal {
    void sound(); // 추상 메서드
}

class Dog extends Animal {
    @override
    void sound() {
        print("멍멍!");
    }
}

class Cat extends Animal {
    @override
    void sound() {
        print("야옹!");
    }
}

void main() {
    Animal dog = Dog();
    Animal cat = Cat();
    
    dog.sound(); // 멍멍!
    cat.sound(); // 야옹!
}

위 예제에서 <code>Animal</code> 클래스는 추상 클래스이며, <code>sound()</code>이라는 추상 메서드를 정의하고 있습니다. <code>Dog</code>와 <code>Cat</code> 클래스는 <code>Animal</code> 클래스를 상속받아 이 메서드를 구현합니다.

추상 클래스의 활용

추상 클래스는 특정 클래스의 공통 기능을 정의하여 코드의 중복을 줄이고, 유지보수를 용이하게 합니다. 이러한 특성 덕분에 확장성과 유연성을 높일 수 있습니다. 예를 들어, 다양한 동물 클래스를 정의할 때, 각 클래스의 공통된 특징을 추상 클래스에서 정의할 수 있습니다.

3. 인터페이스(Interfaces)

인터페이스는 클래스가 구현해야 하는 메서드의 집합을 정의합니다. Dart에서는 인터페이스를 클래스로 정의하고, 이를 다른 클래스에서 구현함으로써 다양한 객체가 동일한 메서드를 지원하도록 강제할 수 있습니다. Dart는 만약 클래스가 다른 클래스의 기능을 상속받지 않는 경우, 그 클래스를 인터페이스처럼 사용할 수 있습니다.

인터페이스 예제

아래는 간단한 인터페이스를 사용하는 예제입니다.

class Drawable {
    void draw();
}

class Circle implements Drawable {
    @override
    void draw() {
        print("Circle을 그립니다.");
    }
}

class Square implements Drawable {
    @override
    void draw() {
        print("Square을 그립니다.");
    }
}

void main() {
    Drawable circle = Circle();
    Drawable square = Square();
    
    circle.draw(); // Circle을 그립니다.
    square.draw(); // Square을 그립니다.
}

위 예제에서 <code>Drawable</code> 인터페이스는 <code>draw()</code> 메서드를 정의합니다. <code>Circle</code>와 <code>Square</code> 클래스는 이 인터페이스를 구현하여 자신의 방식으로 그리기 기능을 제공합니다. 이를 통해 다양한 형태의 도형을 처리할 수 있는 유연성을 확보할 수 있습니다.

4. 추상 클래스와 인터페이스의 차이

추상 클래스와 인터페이스는 유사한 목적을 가지고 있지만, 다음과 같은 차이점이 있습니다:

  • 추상 클래스는 상태를 가질 수 있지만, 인터페이스는 상태를 가질 수 없습니다.
  • 추상 클래스는 메서드의 기본 구현을 가질 수 있지만, 인터페이스는 메서드에 대한 구현을 제공할 수 없습니다.
  • 하나의 클래스는 여러 인터페이스를 구현할 수 있지만, 하나의 클래스는 단지 하나의 추상 클래스만 상속할 수 있습니다.

5. 결론

객체지향 프로그래밍은 현대 소프트웨어 개발에서 필수적인 부분이며, Dart 언어는 이를 명확하게 실현하도록 설계되었습니다. 추상 클래스인터페이스는 이러한 OOP 개념을 더욱 효과적으로 활용할 수 있는 도구입니다. 이를 통해 코드의 유연성과 재사용성을 높이고, 프로젝트의 복잡성을 관리할 수 있습니다. Dart를 사용하는 개발자라면 이러한 개념을 잘 이해하고 활용함으로써 더 나은 소프트웨어 개발을 할 수 있을 것입니다.

[Dart 언어강좌] 006. 기본 문법 배우기, 조건문과 반복문

1. Dart의 기본 문법

Dart는 Google에서 개발한 객체 지향 프로그래밍 언어로, 주로 웹 및 모바일 애플리케이션 개발에 사용됩니다. Dart의 기본 문법을 이해하는 것은 효과적인 프로그래밍을 위해 필수적입니다. 기본 문법에는 변수 선언, 데이터 타입, 함수 정의, 주석 등이 포함됩니다.

1.1 변수와 데이터 타입

Dart에서는 변수를 선언할 때 var, final, const 키워드를 사용합니다. 데이터 타입은 기본적으로 다음과 같습니다:

  • int: 정수 타입
  • double: 실수 타입
  • String: 문자열 타입
  • bool: 불리언 타입
  • List: 배열 타입
  • Map: 키-값 쌍

1.2 변수 선언 예제

void main() {
        var name = 'Dart';
        final pi = 3.14;
        const gravity = 9.81;

        print('이름: $name');
        print('π: $pi');
        print('중력: $gravity');
    }

2. 조건문(Conditional Statements)

조건문은 주어진 조건에 따라서 프로그램의 흐름을 제어하는 데 사용됩니다. Dart에서는 주로 if, else if, else, switch 문을 사용합니다.

2.1 if 문

if 문은 조건이 참일 때만 실행되는 블록을 정의합니다. 사용 예제는 다음과 같습니다:

void main() {
        int score = 85;
        
        if (score >= 90) {
            print('A');
        } else if (score >= 80) {
            print('B');
        } else {
            print('C');
        }
    }

2.2 switch 문

switch 문은 여러 가지 조건을 비교하여 실행할 블록을 선택합니다. 다음은 예제입니다:

void main() {
        String grade = 'B';
        
        switch (grade) {
            case 'A':
                print('우수');
                break;
            case 'B':
                print('양호');
                break;
            case 'C':
                print('보통');
                break;
            default:
                print('제출되지 않음');
        }
    }

3. 반복문(Loops)

반복문은 특정 블록의 코드를 여러 번 실행할 때 사용됩니다. Dart에서는 for, while, do while 반복문을 제공합니다.

3.1 for 문

for 문은 초기화, 조건 확인, 반복 후 실행처럼 세 가지 단계로 구성됩니다. 예제는 다음과 같습니다:

void main() {
        for (int i = 1; i <= 5; i++) {
            print('숫자: $i');
        }
    }

3.2 while 문

while 문은 조건이 참인 동안 코드를 반복 실행합니다. 다음 예제를 확인하세요:

void main() {
        int i = 1;
        while (i <= 5) {
            print('숫자: $i');
            i++;
        }
    }

3.3 do while 문

do while 문은 최소한 한 번은 실행되고, 조건이 참인 경우 반복합니다. 예제는 다음과 같습니다:

void main() {
        int i = 1;
        do {
            print('숫자: $i');
            i++;
        } while (i <= 5);
    }

4. 결론

Dart의 기본 문법과 조건문, 반복문은 프로그래밍의 기초를 형성합니다. 이러한 요소들을 이해하고 활용하는 것은 더욱 복잡한 로직을 구현하는 데 중요한 첫걸음이 됩니다. 앞으로 더 많은 예제를 통해 Dart의 기능을 심화해 나가길 바랍니다.