Kelas #

Kelas (Class) dalam Dart adalah blueprint atau template untuk membuat objek. Kelas mendefinisikan properti (atribut/data) dan metode (fungsi) yang dimiliki oleh objek. Dart adalah bahasa berorientasi objek, yang berarti hampir semua hal adalah objek, termasuk fungsi, angka, dan nilai boolean. Memahami konsep kelas adalah dasar dari pemrograman berorientasi objek (OOP) dalam Dart.

Definisi Kelas #

Kelas dalam Dart didefinisikan menggunakan kata kunci class diikuti dengan nama kelas. Di dalam kelas, Anda dapat mendeklarasikan properti dan metode yang akan dimiliki oleh objek yang dibuat dari kelas tersebut.

Sintaks:

class NamaKelas {
  // Properti atau atribut
  tipeData namaProperti;

  // Konstruktor
  NamaKelas() {
    // Inisialisasi properti
  }

  // Metode atau fungsi
  void namaMetode() {
    // Blok kode
  }
}

Contoh:

class Kendaraan {
  String nama;
  int kecepatan;

  Kendaraan(this.nama, this.kecepatan);

  void maju() {
    print('$nama bergerak dengan kecepatan $kecepatan km/jam');
  }
}

void main() {
  Kendaraan mobil = Kendaraan('Mobil', 80);
  mobil.maju(); // Output: Mobil bergerak dengan kecepatan 80 km/jam
}

Pada contoh di atas:

Kendaraan adalah kelas yang memiliki dua properti (nama dan kecepatan) dan satu metode (maju).
Konstruktor digunakan untuk menginisialisasi properti ketika objek baru dibuat.

Properti dan Metode Kelas #

Properti Kelas #

Properti adalah variabel yang ada dalam kelas. Properti ini menyimpan data atau state dari objek yang dibuat dari kelas tersebut.

Contoh Properti:

class Buku {
  String judul;
  String penulis;
  int jumlahHalaman;

  Buku(this.judul, this.penulis, this.jumlahHalaman);
}

Pada contoh di atas, judul, penulis, dan jumlahHalaman adalah properti dari kelas Buku.

Metode Kelas #

Metode adalah fungsi yang didefinisikan di dalam kelas. Metode ini mendefinisikan perilaku objek.

Contoh Metode:

class Buku {
  String judul;
  String penulis;
  int jumlahHalaman;

  Buku(this.judul, this.penulis, this.jumlahHalaman);

  void deskripsi() {
    print('Buku "$judul" ditulis oleh $penulis dan memiliki $jumlahHalaman halaman.');
  }
}

Pada contoh di atas, deskripsi adalah metode yang mencetak informasi tentang buku.

Konstruktor #

Konstruktor adalah metode khusus dalam kelas yang dipanggil ketika sebuah objek baru dibuat. Dart menyediakan beberapa jenis konstruktor: konstruktor default, named constructor, dan factory constructor.

Konstruktor Default #

Konstruktor default adalah konstruktor yang otomatis dibuat oleh Dart jika Anda tidak mendefinisikan konstruktor dalam kelas. Namun, Anda juga bisa mendefinisikan konstruktor default sendiri.

Contoh:

class Kendaraan {
  String nama;
  int kecepatan;

  Kendaraan(this.nama, this.kecepatan); // Konstruktor default
}

Named Constructor #

Named constructor memungkinkan Anda untuk membuat beberapa konstruktor dalam satu kelas dengan nama yang berbeda.

Contoh:

class Kendaraan {
  String nama;
  int kecepatan;

  Kendaraan(this.nama, this.kecepatan);

  Kendaraan.bike() {
    nama = 'Sepeda';
    kecepatan = 20;
  }

  Kendaraan.car() {
    nama = 'Mobil';
    kecepatan = 100;
  }
}

void main() {
  Kendaraan sepeda = Kendaraan.bike();
  Kendaraan mobil = Kendaraan.car();

  print('${sepeda.nama} memiliki kecepatan ${sepeda.kecepatan} km/jam'); // Output: Sepeda memiliki kecepatan 20 km/jam
  print('${mobil.nama} memiliki kecepatan ${mobil.kecepatan} km/jam'); // Output: Mobil memiliki kecepatan 100 km/jam
}

Factory Constructor #

Factory constructor digunakan untuk mengembalikan instance yang sudah ada atau membuat instance baru berdasarkan kondisi tertentu.

Contoh:

class Kendaraan {
  String nama;
  int kecepatan;

  Kendaraan._(this.nama, this.kecepatan);

  factory Kendaraan(String tipe) {
    if (tipe == 'Sepeda') {
      return Kendaraan._('Sepeda', 20);
    } else if (tipe == 'Mobil') {
      return Kendaraan._('Mobil', 100);
    } else {
      return Kendaraan._('Tidak diketahui', 0);
    }
  }
}

void main() {
  Kendaraan sepeda = Kendaraan('Sepeda');
  Kendaraan mobil = Kendaraan('Mobil');
  Kendaraan pesawat = Kendaraan('Pesawat');

  print('${sepeda.nama} memiliki kecepatan ${sepeda.kecepatan} km/jam'); // Output: Sepeda memiliki kecepatan 20 km/jam
  print('${mobil.nama} memiliki kecepatan ${mobil.kecepatan} km/jam'); // Output: Mobil memiliki kecepatan 100 km/jam
  print('${pesawat.nama} memiliki kecepatan ${pesawat.kecepatan} km/jam'); // Output: Tidak diketahui memiliki kecepatan 0 km/jam
}

Inheritance (Pewarisan) #

Inheritance adalah salah satu konsep utama dalam OOP yang memungkinkan Anda membuat kelas baru berdasarkan kelas yang sudah ada. Kelas baru ini (subkelas) akan mewarisi properti dan metode dari kelas yang lebih tinggi (superclass), tetapi juga dapat menambahkan properti atau metode baru atau mengubah perilaku yang sudah ada.

Membuat Subkelas #

Untuk membuat subkelas, gunakan kata kunci extends.

Contoh:

class Kendaraan {
  String nama;

  Kendaraan(this.nama);

  void bergerak() {
    print('$nama bergerak');
  }
}

class Mobil extends Kendaraan {
  int jumlahRoda;

  Mobil(String nama, this.jumlahRoda) : super(nama);

  @override
  void bergerak() {
    print('$nama bergerak dengan kecepatan tinggi');
  }
}

void main() {
  Mobil avanza = Mobil('Avanza', 4);
  avanza.bergerak(); // Output: Avanza bergerak dengan kecepatan tinggi
}

Pada contoh di atas:

Mobil adalah subkelas yang mewarisi properti dan metode dari kelas Kendaraan.
Mobil juga menambahkan properti baru (jumlahRoda) dan mengubah metode (bergerak).

`super` Keyword #

super digunakan untuk merujuk ke properti atau metode dari superclass yang di-overridden oleh subclass.

Contoh:

class Kendaraan {
  String nama;

  Kendaraan(this.nama);

  void bergerak() {
    print('$nama bergerak');
  }
}

class Mobil extends Kendaraan {
  Mobil(String nama) : super(nama);

  @override
  void bergerak() {
    super.bergerak(); // Memanggil metode bergerak() dari superclass
    print('$nama bergerak lebih cepat');
  }
}

void main() {
  Mobil avanza = Mobil('Avanza');
  avanza.bergerak(); 
  // Output:
  // Avanza bergerak
  // Avanza bergerak lebih cepat
}

Abstraksi dengan Abstract Class #

Kelas abstrak (abstract class) adalah kelas yang tidak dapat diinstansiasi secara langsung. Kelas ini biasanya digunakan untuk mendefinisikan kontrak untuk kelas turunannya, dan sering kali berisi metode-metode abstrak yang harus diimplementasikan oleh subkelas.

Membuat Kelas Abstrak #

Gunakan kata kunci abstract untuk mendefinisikan kelas abstrak.

Contoh:

abstract class Bentuk {
  void gambar(); // Metode abstrak

  void deskripsi() {
    print('Ini adalah bentuk');
  }
}

class Lingkaran extends Bentuk {
  @override
  void gambar() {
    print('Menggambar lingkaran');
  }
}

void main() {
  Lingkaran lingkaran = Lingkaran();
  lingkaran.gambar(); // Output: Menggambar lingkaran
  lingkaran.deskripsi(); // Output: Ini adalah bentuk
}

Pada contoh di atas:

Bentuk adalah kelas abstrak dengan metode abstrak gambar.
Lingkaran adalah kelas yang mengimplementasikan metode gambar.

Interfaces dan Implementasi #

Dalam Dart, semua kelas dapat digunakan sebagai interface. Dart tidak memiliki kata kunci interface secara eksplisit, tetapi Anda bisa mengimplementasikan sebuah kelas (atau beberapa kelas) sebagai interface dengan kata kunci implements.

Mengimplementasikan Interface #

Contoh:

class Penerbangan {
 

 void terbang() {
    print('Terbang di udara');
  }
}

class Berenang {
  void berenang() {
    print('Berenang di air');
  }
}

class Bebek implements Penerbangan, Berenang {
  @override
  void terbang() {
    print('Bebek terbang');
  }

  @override
  void berenang() {
    print('Bebek berenang');
  }
}

void main() {
  Bebek bebek = Bebek();
  bebek.terbang(); // Output: Bebek terbang
  bebek.berenang(); // Output: Bebek berenang
}

Pada contoh di atas, Bebek mengimplementasikan dua interface, Penerbangan dan Berenang.

Mixin #

Mixin adalah cara untuk berbagi metode dan properti di beberapa kelas yang tidak terkait. Mixin didefinisikan menggunakan kata kunci mixin dan digunakan dalam kelas dengan kata kunci with.

Membuat dan Menggunakan Mixin #

Contoh:

mixin Terbang {
  void terbang() {
    print('Terbang');
  }
}

mixin Berenang {
  void berenang() {
    print('Berenang');
  }
}

class Bebek with Terbang, Berenang {}

void main() {
  Bebek bebek = Bebek();
  bebek.terbang(); // Output: Terbang
  bebek.berenang(); // Output: Berenang
}

Pada contoh di atas:

Terbang dan Berenang adalah mixin yang menyediakan metode terbang dan berenang.
Bebek menggunakan mixin tersebut untuk mendapatkan kemampuan terbang dan berenang.

Enkapsulasi dan Akses Modifier #

Enkapsulasi adalah salah satu prinsip OOP yang bertujuan untuk membatasi akses langsung ke data dalam suatu objek dan melindungi integritas data tersebut. Dart menggunakan _ (underscore) sebagai konvensi untuk menandai properti atau metode yang bersifat privat (hanya bisa diakses dalam file yang sama).

Properti Privat #

Contoh:

class BankAccount {
  double _balance = 0.0; // Privat

  void deposit(double amount) {
    _balance += amount;
  }

  void withdraw(double amount) {
    if (_balance >= amount) {
      _balance -= amount;
    } else {
      print('Saldo tidak cukup');
    }
  }

  double get balance => _balance;
}

void main() {
  BankAccount account = BankAccount();
  account.deposit(100.0);
  print('Saldo: ${account.balance}'); // Output: Saldo: 100.0
  account.withdraw(50.0);
  print('Saldo: ${account.balance}'); // Output: Saldo: 50.0
}

Pada contoh di atas:

_balance adalah properti privat yang hanya bisa diakses di dalam kelas BankAccount.

Static Members #

Kelas dalam Dart juga bisa memiliki properti dan metode statis. Anggota statis (static members) adalah properti atau metode yang terkait dengan kelas itu sendiri, bukan dengan instansi kelas.

Properti dan Metode Statis #

Contoh:

class Kalkulator {
  static const pi = 3.14159;

  static double kelilingLingkaran(double radius) {
    return 2 * pi * radius;
  }
}

void main() {
  print('Pi: ${Kalkulator.pi}'); // Output: Pi: 3.14159
  print('Keliling: ${Kalkulator.kelilingLingkaran(5)}'); // Output: Keliling: 31.4159
}

Pada contoh di atas:

pi dan kelilingLingkaran adalah anggota statis yang diakses melalui nama kelas Kalkulator.

Kesimpulan #

Kelas dalam Dart adalah fondasi dari pemrograman berorientasi objek. Dengan menggunakan kelas, Anda dapat membuat struktur yang kuat dan dapat digunakan kembali untuk mengelola data dan perilaku dalam aplikasi. Kelas mendukung konsep dasar OOP seperti enkapsulasi, pewarisan, dan polimorfisme, serta fitur lanjutan seperti abstraksi, interfaces, mixin, dan anggota statis. Memahami bagaimana kelas bekerja dan bagaimana menggunakannya secara efektif adalah langkah penting untuk menjadi pengembang Dart yang mahir.

« Fungsi

Interface »

Kelas #

Definisi Kelas #

Properti dan Metode Kelas #

Properti Kelas #

Metode Kelas #

Konstruktor #

Konstruktor Default #

Named Constructor #

Factory Constructor #

Inheritance (Pewarisan) #

Membuat Subkelas #

super Keyword #

Abstraksi dengan Abstract Class #

Membuat Kelas Abstrak #

Interfaces dan Implementasi #

Mengimplementasikan Interface #

Mixin #

Membuat dan Menggunakan Mixin #

Enkapsulasi dan Akses Modifier #

Properti Privat #

Static Members #

Properti dan Metode Statis #

Kesimpulan #

`super` Keyword #