Di materi ini kita masuk ke Const Constructor di Dart. Konsep ini memang terlihat sederhana, tetapi ada beberapa aturan penting yang perlu benar-benar dipahami, terutama hubungan antara const, final, dan object.

Catatan kecil: caption beberapa kali menulis “DOT programming language”. Maksudnya adalah Dart programming language.

1. Apa itu Const Constructor?

Const Constructor adalah constructor yang digunakan untuk membuat constant object, yaitu object yang nilainya tidak dapat diubah setelah dibuat.

Bentuk sederhananya:

class Person {
  final String name;
  final int age;

  const Person(this.name, this.age);
}

Perhatikan ada dua hal penting:

final String name;
final int age;

dan:

const Person(this.name, this.age);

Jadi:

• final → field/property tidak boleh diberi nilai baru setelah diinisialisasi.
• const pada constructor → memungkinkan object dibuat sebagai compile-time constant menggunakan const.

2. Sebelum memahami Const Constructor, pahami final

Misalnya kita punya:

class Person {
  final String name;
  final int age;

  Person(this.name, this.age);
}

Kita bisa membuat object:

Person person = Person("Budi", 20);

Tetapi setelah dibuat:

person.name = "Andi";

akan error.

Kenapa?

Karena:

final String name;

berarti name hanya boleh diisi sekali.

Gambaran sederhananya:

name
 ↓
"Budi"
 ↓
SELESAI

Tidak boleh:

"Budi"
  ↓
"Andi" ❌

Namun ada hal penting:

Constructor-nya sendiri belum menjadi const.

Jadi final dan const bukan hal yang sama.

3. Perbedaan final dan const

Ini salah satu bagian yang paling penting.

final

final berarti:

Variabel hanya bisa diisi satu kali.

Contoh:

final String name = "Budi";

Setelah itu:

name = "Andi";

❌ Error.

Tetapi nilai final bisa ditentukan ketika program sedang berjalan.

Contoh:

final name = getNameFromDatabase();

Nilainya baru diketahui saat program berjalan.

const

const berarti:

Nilainya harus merupakan nilai konstan yang bisa diketahui saat compile time.

Contoh:

const int age = 20;

atau:

const String name = "Budi";

Jadi secara sederhana:

4. Kenapa Field Const Constructor Harus final?

Sekarang masuk ke aturan Const Constructor.

Misalnya kita mencoba:

class Person {
  String name;
  int age;

  const Person(this.name, this.age);
}

Ini akan error.

Dart akan mengatakan bahwa kita tidak bisa membuat constant constructor untuk class yang memiliki non-final fields.

Kenapa?

Bayangkan kita membuat:

const Person("Budi", 20);

Kita mengatakan:

“Saya ingin object ini menjadi constant.”

Tetapi field-nya:

String name;
int age;

masih boleh diubah.

Misalnya:

person.name = "Andi";

Ini bertentangan dengan konsep object constant.

Maka Dart mengharuskan field yang digunakan oleh const constructor bersifat final.

Jadi:

class Person {
  final String name;
  final int age;

  const Person(this.name, this.age);
}

✅ Benar.

5. Membuat Const Constructor

Bentuk lengkapnya:

class Person {
  final String name;
  final int age;

  const Person(this.name, this.age);
}

Mari kita bedah:

class Person

Membuat class bernama Person.

final String name

Membuat field name yang hanya bisa diinisialisasi sekali.

final int age

Membuat field age yang hanya bisa diinisialisasi sekali.

const Person(...)

Membuat constructor yang bisa digunakan untuk membuat constant object.

this.name

Parameter constructor langsung digunakan untuk mengisi field name.

this.age

Parameter constructor langsung digunakan untuk mengisi field age.

6. Membuat Object dari Const Constructor

Setelah class dibuat:

class Person {
  final String name;
  final int age;

  const Person(this.name, this.age);
}

Kita bisa membuat object:

const Person person = Person("Budi", 20);

Namun biasanya lebih jelas dan idiomatis ditulis:

const Person person = const Person("Budi", 20);

Tetapi Dart modern mengizinkan const di sebelah kiri mengalir ke constructor, sehingga:

const Person person = Person("Budi", 20);

juga valid.

Yang paling umum:

const person = Person("Budi", 20);

Jika constructor Person adalah const dan konteksnya constant.

Atau secara eksplisit:

const person = const Person("Budi", 20);

7. Contoh Lengkap

Mari kita buat contoh sederhana:

class Person {
  final String name;
  final int age;

  const Person(this.name, this.age);

  void display() {
    print("Name: $name");
    print("Age: $age");
  }
}

void main() {
  const Person person = Person("Budi", 20);

  person.display();
}

Output:

Name: Budi
Age: 20

Perhatikan bahwa kita masih bisa memanggil method:

person.display();

const object bukan berarti object tersebut tidak bisa melakukan apa-apa.

Yang tidak bisa dilakukan adalah mengubah nilai field-nya.

8. Tidak Bisa Mengubah Field

Misalnya:

const Person person = Person("Budi", 20);

Kemudian:

person.name = "Andi";

❌ Error.

Karena:

final String name;

sudah memiliki nilai:

name = "Budi"

dan tidak boleh diganti.

Begitu juga:

person.age = 25;

❌ Error.

Karena age juga final.

9. Kenapa Harus final?

Coba kita bayangkan seperti formulir identitas.

Ketika object dibuat:

Person("Budi", 20)

hasilnya:

Person
├── name = Budi
└── age  = 20

Karena object dibuat sebagai constant:

┌─────────────────┐
│ Person          │
├─────────────────┤
│ name = Budi     │ 🔒
│ age  = 20       │ 🔒
└─────────────────┘

Nilainya dikunci.

Tidak boleh:

name = Andi ❌
age  = 25   ❌

10. Const Object Tidak Bisa Diubah

Misalnya:

const person = Person("Budi", 20);

Kita tidak boleh:

person.name = "Andi";

atau:

person.age = 30;

Karena field-nya final.

Ini sesuai dengan prinsip:

CONST OBJECT
     ↓
NILAI TIDAK BERUBAH

11. Bagaimana dengan Membuat Object Baru?

Ini bagian yang sering membingungkan.

Misalnya:

const person = Person("Budi", 20);

Kemudian kita ingin:

person = Person("Andi", 25);

Ini juga ❌ error.

Tapi bukan semata-mata karena constructor const.

Masalahnya adalah variabel:

const person

juga merupakan constant variable.

Jadi person tidak boleh diarahkan ke object lain.

Analogi:

const person
     ↓
Person("Budi", 20)

Tidak boleh kemudian:

const person
     ↓
Person("Andi", 25) ❌

12. Bedakan Object dengan Variable yang Menyimpan Object

Ini penting sekali.

Misalnya:

const Person person = Person("Budi", 20);

Ada dua konsep:

Object

Object-nya adalah:

Person("Budi", 20)

Variable

Variabelnya adalah:

person

Jadi:

person
  │
  ▼
┌─────────────────┐
│ Person object   │
│ name = Budi     │
│ age = 20        │
└─────────────────┘

Dengan const, kita membuat object tersebut sebagai constant dan variabelnya juga tidak bisa diarahkan ulang.

13. Apakah Const Constructor Berarti Semua Object Harus Const?

Tidak.

Ini juga penting.

Kalau class memiliki:

const Person(this.name, this.age);

kita bisa membuat object biasa:

Person person = Person("Budi", 20);

dan juga constant object:

const Person person = Person("Budi", 20);

Jadi adanya const constructor berarti:

Constructor tersebut memungkinkan pembuatan constant object.

Bukan berarti setiap object yang dibuat dari constructor tersebut otomatis menjadi constant.

14. Contoh Perbandingan

Object biasa

class Person {
  final String name;
  final int age;

  Person(this.name, this.age);
}

Object:

Person person = Person("Budi", 20);

Field tetap tidak bisa diubah karena final:

person.name = "Andi"; // ❌

Tetapi variable person masih bisa diarahkan ke object lain:

person = Person("Andi", 25); // ✅

Const Constructor

class Person {
  final String name;
  final int age;

  const Person(this.name, this.age);
}

Object:

const Person person = Person("Budi", 20);

Field:

person.name = "Andi"; // ❌

Dan variable:

person = Person("Andi", 25); // ❌

Karena person juga const.

15. Ini Perbedaan yang Sangat Penting

Perhatikan tabel berikut:

Contoh:

Field biasa

class Person {
  String name;

  Person(this.name);
}

var person = Person("Budi");

person.name = "Andi"; // ✅
person = Person("Citra"); // ✅

Field final

class Person {
  final String name;

  Person(this.name);
}

var person = Person("Budi");

person.name = "Andi"; // ❌
person = Person("Citra"); // ✅

const

class Person {
  final String name;

  const Person(this.name);
}

const person = Person("Budi");

person.name = "Andi"; // ❌
person = Person("Citra"); // ❌

16. Const Constructor vs Constructor Biasa

Mari kita bandingkan.

Constructor biasa

class Person {
  final String name;
  final int age;

  Person(this.name, this.age);
}

Const Constructor

class Person {
  final String name;
  final int age;

  const Person(this.name, this.age);
}

Perbedaannya hanya terlihat kecil:

Person(...)

vs

const Person(...)

Tetapi secara konsep:

Constructor biasa
       ↓
membuat object biasa


Const Constructor
       ↓
memungkinkan membuat constant object

17. Kapan Const Constructor Berguna?

Const constructor berguna ketika kita memiliki object yang sifatnya tetap dan tidak perlu berubah.

Misalnya data seperti:

• konfigurasi tetap
• ukuran tertentu
• koordinat tetap
• warna/konfigurasi UI tertentu
• object kecil yang nilainya tidak berubah
• nilai yang memang konstan

Contoh:

class Point {
  final int x;
  final int y;

  const Point(this.x, this.y);
}

Kita bisa membuat:

const point = Point(10, 20);

Karena koordinatnya memang tidak berubah.

18. Keuntungan Lain: Dart Bisa Menggunakan Kembali Const Object

Ada konsep penting di balik const.

Misalnya:

const person1 = Person("Budi", 20);
const person2 = Person("Budi", 20);

Karena keduanya adalah constant object dengan nilai yang sama, Dart dapat memperlakukan constant object tersebut secara canonicalized/shareable.

Secara sederhana, bayangkan Dart tidak perlu membuat dua object constant yang identik secara terpisah:

Person("Budi", 20)
        ↑
   ┌────┴────┐
   │         │
person1   person2

Keduanya dapat merujuk pada representasi constant yang sama.

Inilah salah satu alasan const berguna untuk object immutable yang sering digunakan.

19. Const Tidak Sama dengan Immutable Secara Universal

Untuk level dasar, kita sering mengatakan:

“Const object tidak bisa diubah.”

Itu benar untuk penggunaan dasar seperti contoh Person.

Tetapi secara konsep Dart, const dan immutable tidak persis sama.

const adalah konsep constant object yang nilainya diketahui pada compile time.

Sedangkan immutable berarti state object tidak dapat berubah setelah object dibuat.

Untuk membuat const object, field yang relevan harus immutable/final.

Jadi cara mudah mengingatnya:

final
↓
field tidak bisa di-assign ulang


const constructor
↓
memungkinkan object menjadi constant


const object
↓
nilai object tidak bisa diubah

20. Kenapa Tidak Menggunakan late?

Sebelumnya kita sering menggunakan:

late String name;
late int age;

Misalnya:

class Person {
  late String name;
  late int age;

  Person(this.name, this.age);
}

Untuk const constructor, pendekatan yang umum adalah:

class Person {
  final String name;
  final int age;

  const Person(this.name, this.age);
}

Kenapa?

Karena field harus dapat diinisialisasi ketika object constant dibuat.

Dengan final, constructor langsung memberikan nilai:

Person("Budi", 20)
       ↓      ↓
     name    age

21. Contoh dengan Method

Const object tetap bisa memiliki method.

class Person {
  final String name;
  final int age;

  const Person(this.name, this.age);

  void display() {
    print("Name: $name");
    print("Age: $age");
  }
}

void main() {
  const person = Person("Budi", 20);

  person.display();
}

Output:

Name: Budi
Age: 20

Jadi jangan berpikir:

“Const berarti object tidak boleh melakukan apa-apa.”

Bukan begitu.

Yang tidak boleh berubah adalah state/value-nya.

22. Contoh yang Akan Error

Kode:

class Person {
  String name;
  int age;

  const Person(this.name, this.age);
}

❌ Salah.

Karena:

String name;
int age;

bukan final.

Harus:

class Person {
  final String name;
  final int age;

  const Person(this.name, this.age);
}

✅ Benar.

23. Contoh Program Lengkap

Berikut versi yang bagus untuk latihan:

class Person {
  final String name;
  final int age;

  const Person(this.name, this.age);

  void display() {
    print("Name: $name");
    print("Age: $age");
  }
}

void main() {
  const person = Person("Budi", 20);

  person.display();

  // Tidak boleh:
  // person.name = "Andi";
  // person.age = 25;
  // person = Person("Andi", 25);
}

Hasil:

Name: Budi
Age: 20

24. Analogi Sederhana

Bayangkan kamu membuat KTP yang sudah dicetak.

Class:

class Person

adalah seperti template KTP.

Constructor:

Person(this.name, this.age)

adalah proses mengisi data.

Sedangkan:

const Person("Budi", 20)

seperti:

“KTP ini sudah dicetak sebagai dokumen tetap.”

Setelah selesai:

Name: Budi
Age: 20

kita tidak bisa tiba-tiba menghapus tulisan Budi lalu menggantinya menjadi Andi.

25. Hubungannya dengan Materi Sebelumnya

Kita sudah belajar beberapa jenis constructor:

Constructor biasa

Person(this.name, this.age);

Named constructor

Person.guest()
    : name = "Guest",
      age = 0;

Const constructor

const Person(this.name, this.age);

Ketiganya sama-sama digunakan untuk membuat object, tetapi tujuannya berbeda.

                    Person
                      │
          ┌───────────┼────────────┐
          ↓           ↓            ↓
      Person()    Person.guest()  const Person()
          │           │            │
          ↓           ↓            ↓
     object biasa  cara alternatif  constant object
                             

26. Ringkasan Paling Penting

Kalau ingin mengingat materi ini dengan cepat, ingat 4 poin:

1. Const Constructor

const Person(this.name, this.age);

Digunakan agar class bisa membuat constant object.

2. Field harus final

final String name;
final int age;

Karena nilai field tidak boleh berubah.

3. Membuat constant object

const person = Person("Budi", 20);

4. Nilainya tidak boleh diubah

person.name = "Andi"; // ❌
person.age = 25;     // ❌

🧠 Cara paling gampang mengingat

Bayangkan urutannya seperti ini:

             CLASS
               │
               ▼
        final fields
               │
               ▼
       const constructor
               │
               ▼
        const object
               │
               ▼
       nilai tidak berubah

Dan bedakan:

final
  ↓
"boleh diisi sekali"

const
  ↓
"konstan sejak compile time"

Jadi kalimat sederhananya:

Const Constructor adalah constructor yang memungkinkan kita membuat object constant. Agar bisa menjadi constant, field yang dimiliki object harus tidak dapat diubah (final). Ketika object dibuat dengan const, nilai object tersebut tidak dapat diubah setelah dibuat.