Video ini sebenarnya adalah peta perjalanan belajar Dart sebelum masuk lebih dalam ke Flutter. Jadi, video tersebut belum mengajarkan kode secara detail, tetapi menjelaskan materi apa saja yang akan dipelajari dan urutannya.

Saya jelaskan satu per satu dengan bahasa sederhana.

🗺️ Gambaran Besar Materi Dart

Secara umum, seri Dart tersebut terdiri dari beberapa tahap:

DART
 │
 ├── 1. Fundamental Bahasa
 │      ├── Variable
 │      ├── Data Type
 │      ├── If / Else
 │      ├── Loop
 │      └── Function
 │
 ├── 2. Object-Oriented Programming
 │      ├── Class
 │      ├── Object
 │      ├── Method
 │      ├── Constructor
 │      └── Encapsulation
 │
 ├── 3. Inheritance & Fitur OOP Lanjutan
 │      ├── Superclass
 │      ├── Subclass
 │      ├── Interface
 │      ├── Abstract Class
 │      ├── Mixin
 │      └── Implement
 │
 ├── 4. Exception Handling
 │      ├── try
 │      ├── catch
 │      └── finally
 │
 ├── 5. Generics & Collections
 │      ├── List
 │      ├── Set
 │      └── Map
 │
 └── 6. Asynchronous Programming
        ├── Future
        ├── async
        └── await

Mari kita bahas.

1. Language Fundamental

Bagian pertama adalah dasar-dasar bahasa Dart.

Ini adalah bagian yang paling penting untuk pemula karena sebelum belajar Flutter, kita harus memahami bagaimana cara menulis program menggunakan Dart.

A. Variable

Variable adalah tempat untuk menyimpan data.

Misalnya:

String nama = "Budi";
int umur = 20;
double tinggi = 170.5;
bool sudahLogin = true;

Kita bisa membayangkan variable seperti kotak yang mempunyai nama.

nama       → "Budi"
umur       → 20
tinggi     → 170.5
sudahLogin → true

Jadi ketika kita menulis:

print(nama);

program akan mengambil isi dari variable nama.

Hasil:

Budi

2. Data Types

Data type adalah jenis data yang disimpan oleh variable.

Beberapa tipe data dasar Dart:

String

Untuk teks.

String nama = "Andi";

int

Untuk bilangan bulat.

int umur = 25;

double

Untuk bilangan desimal.

double berat = 65.5;

bool

Untuk nilai benar atau salah.

bool aktif = true;

Ada juga tipe seperti:

List
Set
Map
Object

yang akan dipelajari lebih lanjut.

3. Decision Making

Decision making berarti membuat keputusan berdasarkan kondisi.

Dalam kehidupan sehari-hari:

Kalau hujan → bawa payung. Kalau tidak hujan → tidak perlu membawa payung.

Dalam Dart:

int umur = 20;

if (umur >= 18) {
  print("Sudah dewasa");
} else {
  print("Belum dewasa");
}

Program akan mengecek:

Apakah umur >= 18?
       │
   ┌───┴───┐
  YA      TIDAK
   │         │
Dewasa   Belum dewasa

Selain if-else, Dart juga memiliki switch untuk pengambilan keputusan pada kasus tertentu.

4. Loops

Loop digunakan ketika kita ingin mengulang suatu pekerjaan.

Misalnya kita ingin mencetak angka 1 sampai 5.

Tanpa loop:

print(1);
print(2);
print(3);
print(4);
print(5);

Tentunya merepotkan.

Dengan loop:

for (int i = 1; i <= 5; i++) {
  print(i);
}

Hasil:

1
2
3
4
5

Jenis loop yang akan sering kamu temui antara lain:

for
while
do-while
for-in

Loop sangat sering digunakan dalam Flutter, misalnya ketika kita ingin menampilkan banyak data.

5. Function

Function adalah sekumpulan kode yang dibuat untuk melakukan tugas tertentu.

Contohnya:

void salam() {
  print("Halo!");
}

Kemudian kita bisa memanggilnya:

salam();

Hasil:

Halo!

Kenapa function penting?

Karena kita tidak perlu menulis kode yang sama berkali-kali.

Misalnya:

void tambah() {
  print(10 + 20);
}

Kita bisa memanggil:

tambah();
tambah();
tambah();

6. Function Parameters

Function juga dapat menerima data dari luar.

Contoh:

void salam(String nama) {
  print("Halo $nama");
}

Kemudian:

salam("Budi");
salam("Andi");

Hasil:

Halo Budi
Halo Andi

nama disebut parameter.

Kita juga bisa memiliki beberapa parameter:

void biodata(String nama, int umur) {
  print("$nama berumur $umur tahun");
}

Pemanggilannya:

biodata("Budi", 20);

7. Object-Oriented Programming (OOP)

Setelah memahami dasar Dart, materi naik ke Object-Oriented Programming atau OOP.

Ini sangat penting untuk Flutter.

Flutter sendiri banyak menggunakan konsep OOP.

Konsep utamanya:

Class
Object
Method
Constructor
Encapsulation
Inheritance
Abstraction
Polymorphism
Interface
Mixin

8. Class

Class dapat kita anggap sebagai cetakan/template.

Misalnya kita ingin membuat objek Mobil.

class Mobil {
  String warna = "Merah";

  void jalan() {
    print("Mobil berjalan");
  }
}

Mobil adalah class.

Bayangkan:

Class Mobil
     │
     ├── warna
     └── jalan()

Class sendiri belum menjadi mobil tertentu.

Dia hanya merupakan template.

9. Object

Object adalah hasil nyata yang dibuat berdasarkan class.

Contoh:

Mobil mobilSaya = Mobil();

Sekarang kita memiliki object mobilSaya.

Kita bisa menggunakannya:

print(mobilSaya.warna);
mobilSaya.jalan();

Jadi:

Class
  ↓
Mobil

Object
  ↓
mobilSaya

Analogi sederhananya:

Class = cetakan kue Object = kue yang dibuat menggunakan cetakan tersebut

Satu class dapat menghasilkan banyak object.

Mobil mobil1 = Mobil();
Mobil mobil2 = Mobil();
Mobil mobil3 = Mobil();

10. Method

Method adalah function yang berada di dalam class.

Contoh:

class Mobil {
  void jalan() {
    print("Mobil sedang berjalan");
  }
}

jalan() adalah method.

Kita menjalankannya:

Mobil mobil = Mobil();

mobil.jalan();

Dalam Flutter, kamu akan sangat sering menemukan method.

Contohnya:

build()

adalah salah satu method yang sangat penting dalam Flutter.

11. Constructor

Constructor adalah method khusus yang digunakan ketika object dibuat.

Contoh:

class User {
  String nama;

  User(this.nama);
}

Kemudian:

User user = User("Budi");

print(user.nama);

Output:

Budi

Jadi ketika kita menulis:

User("Budi")

constructor digunakan untuk membuat object User sekaligus memberikan data awal.

12. Encapsulation

Encapsulation berarti mengatur dan melindungi data di dalam class.

Misalnya kita memiliki saldo:

class BankAccount {
  double _saldo = 0;

  void deposit(double jumlah) {
    _saldo += jumlah;
  }

  double getSaldo() {
    return _saldo;
  }
}

Pengguna class tidak perlu mengubah _saldo secara sembarangan.

Mereka cukup menggunakan:

account.deposit(100000);

atau:

account.getSaldo();

Tujuannya agar data lebih aman dan struktur program lebih teratur.

13. Inheritance

Setelah OOP dasar, kita masuk ke inheritance atau pewarisan.

Inheritance berarti sebuah class dapat mewarisi kemampuan dari class lain.

Contoh:

class Hewan {
  void makan() {
    print("Hewan makan");
  }
}

class Kucing extends Hewan {
  void mengeong() {
    print("Meong");
  }
}

Sekarang Kucing mewarisi makan() dari Hewan.

Kucing kucing = Kucing();

kucing.makan();
kucing.mengeong();

Jadi:

Hewan
  │
  │ extends
  ↓
Kucing

Hewan disebut superclass/base class, sedangkan Kucing disebut subclass.

14. Superclass dan Subclass

Istilah ini akan sering muncul.

Contohnya:

class Hewan {
}

class Kucing extends Hewan {
}

Maka:

Hewan = Superclass
Kucing = Subclass

Subclass mendapatkan kemampuan dari superclass.

15. Interface

Interface digunakan untuk menentukan kontrak/perilaku yang harus dimiliki sebuah class.

Dalam Dart, sebuah class secara konsep dapat digunakan sebagai interface.

Contoh:

class Hewan {
  void suara() {}
}

class Kucing implements Hewan {
  @override
  void suara() {
    print("Meong");
  }
}

Dengan implements, Kucing harus menyediakan implementasi untuk anggota yang diwajibkan oleh interface tersebut.

Gampangnya:

Interface = “Kalau kamu ingin menggunakan kontrak ini, kamu harus menyediakan kemampuan yang ditentukan.”

16. Abstract Class

Abstract class adalah class yang biasanya digunakan sebagai dasar/kerangka untuk class lain dan tidak dibuat menjadi object secara langsung.

Contoh:

abstract class Hewan {
  void suara();
}

Kemudian:

class Kucing extends Hewan {
  @override
  void suara() {
    print("Meong");
  }
}

Hewan hanya menentukan:

Hewan harus mempunyai suara().

Sedangkan bagaimana suaranya ditentukan oleh subclass.

17. Mixin

Mixin adalah fitur Dart untuk menggunakan kembali sekumpulan kemampuan pada beberapa class tanpa harus menggunakan inheritance biasa.

Contoh:

mixin BisaTerbang {
  void terbang() {
    print("Sedang terbang");
  }
}

Kemudian:

class Burung with BisaTerbang {
}

Sekarang:

Burung burung = Burung();

burung.terbang();

Mixin sangat berguna untuk berbagi perilaku.

18. Exception Handling

Program tidak selalu berjalan sesuai harapan.

Misalnya:

User memasukkan data
       ↓
Program memproses
       ↓
Terjadi error

Contohnya kita melakukan operasi yang tidak valid.

Dart menyediakan exception handling.

Struktur yang paling umum:

try {
  // kode yang mungkin menghasilkan error
} catch (e) {
  // menangani error
} finally {
  // dijalankan setelah proses selesai
}

Contoh:

void main() {
  try {
    int hasil = 10 ~/ 0;
    print(hasil);
  } catch (e) {
    print("Terjadi error");
  } finally {
    print("Selesai");
  }
}

Konsepnya:

try
 ↓
Coba jalankan kode
 ↓
Error?
 ├── Tidak → lanjut
 └── Ya → catch
              ↓
         tangani error
              ↓
           finally

19. Generics

Generics digunakan agar kode dapat bekerja dengan berbagai tipe data dengan tetap mempertahankan type safety.

Contoh sederhana:

List<String> nama = [
  "Budi",
  "Andi",
  "Citra"
];

List<String> berarti:

List ini dirancang untuk menyimpan String.

Contoh lain:

List<int> angka = [10, 20, 30];

Berarti list tersebut berisi int.

Generics akan sangat sering kamu temui ketika belajar Flutter dan package Dart.

20. Collections

Collection adalah struktur yang digunakan untuk menyimpan banyak data.

Tiga yang sangat penting:

List
Set
Map

A. List

List digunakan untuk menyimpan data secara berurutan.

List<String> buah = [
  "Apel",
  "Mangga",
  "Jeruk"
];

Kita dapat mengambil data berdasarkan index:

print(buah[0]);

Hasil:

Apel

Index dimulai dari 0.

Index     Data

  0       Apel
  1       Mangga
  2       Jeruk

List sangat sering digunakan di Flutter untuk menampilkan kumpulan data.

21. Set

Set digunakan untuk menyimpan data yang unik, sehingga nilai duplikat tidak dipertahankan sebagai elemen terpisah.

Set<String> buah = {
  "Apel",
  "Mangga",
  "Apel"
};

Secara konsep hasilnya:

Apel
Mangga

Apel yang kedua tidak menjadi elemen tambahan.

22. Map

Map menyimpan data dalam bentuk:

key → value

Contoh:

Map<String, dynamic> user = {
  "nama": "Budi",
  "umur": 20,
};

Strukturnya:

nama → Budi
umur → 20

Kita bisa mengambil data:

print(user["nama"]);

Hasil:

Budi

Map sangat penting dalam Flutter, terutama ketika berurusan dengan data JSON dari API.

Misalnya server mengirim:

{
  "nama": "Budi",
  "umur": 20
}

Data seperti ini sering diproses menggunakan struktur Map sebelum diubah menjadi object/model.

23. Asynchronous Programming

Bagian terakhir adalah asynchronous programming.

Ini sangat penting dalam aplikasi Flutter.

Kenapa?

Karena aplikasi sering melakukan pekerjaan yang membutuhkan waktu, seperti:

Mengambil data API
Mengakses database
Membaca file
Upload file
Download file
Login
Mengambil data internet

Kita tidak ingin UI aplikasi berhenti hanya karena sedang menunggu server.

24. Future

Future adalah representasi dari hasil yang akan tersedia nanti.

Misalnya:

Future<String> getData() async {
  return "Data berhasil";
}

Artinya function tersebut akan memberikan hasil String secara asynchronous.

Kita dapat mengambil hasilnya menggunakan await.

25. async

async digunakan untuk menandai function yang menjalankan operasi asynchronous.

Contoh:

Future<void> proses() async {
  print("Mulai");

  // proses asynchronous

  print("Selesai");
}

26. await

await digunakan untuk menunggu hasil dari sebuah operasi asynchronous.

Contoh:

Future<String> getNama() async {
  return "Budi";
}

void main() async {
  String nama = await getNama();

  print(nama);
}

Secara sederhana:

getNama()
   ↓
Future
   ↓
await
   ↓
hasil tersedia
   ↓
"Budi"

Ini akan sangat sering kamu gunakan ketika mengambil data dari API dalam Flutter.

🎯 Urutan Belajar yang Disarankan

Kalau kamu benar-benar baru belajar Dart, jangan langsung mencoba menghafal semuanya.

Ikuti urutan ini:

Tahap 1 — Dasar

Pelajari:

Variable
↓
Data Type
↓
Operator
↓
If / Else
↓
Switch
↓
Loop
↓
Function
↓
Parameter

Pastikan kamu bisa membuat program sederhana menggunakan semuanya.

Tahap 2 — OOP

Kemudian:

Class
↓
Object
↓
Property
↓
Method
↓
Constructor
↓
Encapsulation

Setelah itu lanjut:

Inheritance
↓
Interface
↓
Abstract Class
↓
Mixin
↓
Polymorphism

Tahap 3 — Data

Kemudian pelajari:

Generics
↓
List
↓
Set
↓
Map

Bagian ini sangat penting karena aplikasi nyata hampir selalu berurusan dengan kumpulan data.

Tahap 4 — Error

Pelajari:

Exception
↓
try
↓
catch
↓
finally
↓
throw

Tahap 5 — Asynchronous

Terakhir:

Future
↓
async
↓
await
↓
Stream

Setelah memahami ini, kamu akan jauh lebih siap untuk mengambil data dari API dan membuat aplikasi Flutter yang berinteraksi dengan internet.

🧠 Inti dari Video Ini

Kalau seluruh video diringkas menjadi satu kalimat:

Seri ini mengajarkan Dart dari dasar sampai konsep yang diperlukan untuk membuat aplikasi Flutter.

Urutannya kira-kira:

                    DART
                      │
                      ▼
              ┌──────────────┐
              │   FUNDAMENTAL │
              └──────┬───────┘
                     ▼
               ┌──────────┐
               │   OOP    │
               └────┬─────┘
                    ▼
          ┌───────────────────┐
          │ Inheritance &     │
          │ OOP Lanjutan      │
          └─────────┬─────────┘
                    ▼
          ┌───────────────────┐
          │ Exception         │
          │ Handling          │
          └─────────┬─────────┘
                    ▼
          ┌───────────────────┐
          │ Generics &        │
          │ Collections       │
          └─────────┬─────────┘
                    ▼
          ┌───────────────────┐
          │ Asynchronous      │
          │ Programming       │
          └─────────┬─────────┘
                    ▼
                 FLUTTER
                    │
          ┌─────────┼─────────┐
          ▼         ▼         ▼
       Android     iOS       Web
                              │
                           Desktop

Jadi jangan buru-buru masuk ke Flutter sebelum memahami fondasi Dart. Kalau kamu memahami variable → function → class/object → inheritance → collection → async/await, kode Flutter nantinya akan terasa jauh lebih masuk akal, bukan sekadar menghafal kode.