In Dart, static, const, and final

Difference Between static, const, and final in Dart

Introduction

Dart provides three keywords—static, const, and final—to define variables with specific behaviors. Understanding their differences helps in writing efficient and maintainable code. Let’s explore their characteristics and usage.

1. static

Definition: Declares a class-level variable or method shared across all instances of the class.

Key Characteristics:

• Belongs to the class, not an instance.
• Can be accessed using the class name.
• Memory is allocated only once.

class Counter {
  static int count = 0; // Shared across all instances

  void increment() {
    count++;
  }
}

void main() {
  Counter c1 = Counter();
  Counter c2 = Counter();

  c1.increment();
  c2.increment();

  print(Counter.count); // Output: 2 (shared value)
}

        

2. const

Definition: Defines a compile-time constant. The value must be known at compile time and cannot be changed.

Key Characteristics:

• Immutable value known at compile time.
• Memory is allocated once and canonicalized.

void main() {
  const int age = 30;
  const pi = 3.14; // Type inference

  // age = 31; // Error: Cannot assign a new value to const

  const List numbers = [1, 2, 3];
  // numbers.add(4); // Error: Cannot modify a const list

  print(age); // Output: 30
  print(pi);  // Output: 3.14
}

        

3. final

Definition: Defines a runtime constant. The value is initialized once and cannot be reassigned, but it can be determined at runtime.

Key Characteristics:

• Immutable value initialized at runtime.
• Useful for properties whose values are only known at runtime.

void main() {
  final DateTime currentTime = DateTime.now(); // Value assigned at runtime
  print(currentTime);

  // currentTime = DateTime.now(); // Error: Cannot reassign a final variable
}

        

Comparison: static, const, and final

Feature	static	const	final
Scope	Class-level (shared)	Local or global	Local or global
Initialization	At runtime	At compile time	At runtime
Immutability	Can be mutable	Immutable	Immutable
Memory Allocation	Shared	One-time	One-time
Access	Class name	Directly	Directly

Combined Example

class Example {
  static int staticVar = 100; // Shared variable
  final int finalVar; // Instance-specific runtime constant
  static const int staticConst = 200; // Compile-time constant

  Example(this.finalVar);
}

void main() {
  // Accessing static variable
  print(Example.staticVar); // Output: 100

  // Creating an instance
  Example obj = Example(300);
  print(obj.finalVar); // Output: 300

  // Accessing static const
  print(Example.staticConst); // Output: 200
}

        

© 2024 Dart Tutorials Blog. All rights reserved.