Setters In Dart

Setters in Dart are special methods used to set the value of an object's private instance variables. They provide a way to control the assignment of values to class members and encapsulate the class's internal state. This tutorial will explore the concept of setters in Dart, their syntax, usage, common mistakes to avoid, and best practices.

What are Setters in Dart?

In Dart, setters are special methods that are used to set the values of private instance variables within a class. By using setters, you can control how values are assigned to class members, enforce constraints, and maintain the encapsulation of your class. Setters are often used in conjunction with getters to create a clean and intuitive interface for accessing and modifying object properties.

Syntax

In Dart, the syntax for defining a setter is similar to that of a method, but with the void keyword omitted and the set keyword preceding the setter name. Here's the general syntax for creating a setter in Dart:

class ClassName {
  var _propertyName;

  set setterName(value) {
    // setter logic to set the property value
    _propertyName = value;
  }
}

• ✅ set: Keyword used to define a setter method.
• ✅ setterName: Name of the setter method.
• ✅ value: Parameter representing the value to be assigned to the property.

Key Features

• ✅ Setters provide controlled access to private instance variables.
• ✅ They allow for validation and logic implementation during assignment.
• ✅ Setters help maintain encapsulation and data integrity within a class.

Example 1: Basic Setter Usage

Let's create a simple class Person with a private instance variable name and a setter method setName to update the name.

class Person {
  var _name;

  set setName(String name) {
    _name = name;
  }
}

void main() {
  var person = Person();
  person.setName = 'Alice';
  print(person._name);
}

Output:

Alice

In this example, the setter setName is used to set the private variable _name of the Person class to 'Alice'.

Example 2: Setter with Validation

We can enhance the previous example by adding validation to the setter method to ensure the name is not empty.

class Person {
  var _name;

  set setName(String name) {
    if (name.isNotEmpty) {
      _name = name;
    } else {
      print('Name cannot be empty!');
    }
  }
}

void main() {
  var person = Person();
  person.setName = ''; // Empty name
  print(person._name); // Output will be null
}

Output:

Name cannot be empty!
null

In this case, the setter checks if the provided name is empty before assigning it to the _name variable.

Common Mistakes to Avoid

1. Ignoring Setter Visibility

Problem: Beginners often forget to set the visibility of their setters, making them unintentionally public or private when they may want to control access.

// BAD - Don't do this
class Person {
  String name;

  // Setter is public, but it should be private
  set setName(String value) {
    name = value;
  }
}

Solution:

// GOOD - Do this instead
class Person {
  String _name; // Private variable

  set name(String value) { // Public setter
    _name = value;
  }
}

Why: Making setters public when they should be private can expose internal state management, allowing unintended modifications. Control access to your class's properties to maintain encapsulation.

2. Not Validating Setter Input

Problem: Many beginners forget to add validation logic in their setters, which can lead to invalid states in their objects.

// BAD - Don't do this
class Age {
  int _age;

  set age(int value) {
    _age = value; // No validation
  }
}

Solution:

// GOOD - Do this instead
class Age {
  int _age;

  set age(int value) {
    if (value < 0) {
      throw ArgumentError('Age cannot be negative');
    }
    _age = value;
  }
}

Why: Failing to validate inputs can lead to unexpected behavior in your application. Always validate data before assigning it to internal variables to ensure the integrity of your object's state.

3. Overwriting Existing Data Without Warning

Problem: Beginners might overwrite existing data in their setters without notifying the user or handling the change appropriately.

// BAD - Don't do this
class User {
  String _username;

  set username(String value) {
    _username = value; // Overwrites without any notice
  }
}

Solution:

// GOOD - Do this instead
class User {
  String _username;

  set username(String value) {
    if (_username != value) {
      print('Username changed from $_username to $value');
    }
    _username = value;
  }
}

Why: Not notifying users of data changes can lead to confusion, especially in complex applications. Implementing a notification mechanism helps maintain transparency and can assist in debugging.

4. Not Using Getter-Setter Pairs

Problem: Beginners often create setters without corresponding getters, limiting access to the variable and breaking encapsulation principles.

// BAD - Don't do this
class Temperature {
  double _celsius;

  set celsius(double value) {
    _celsius = value;
  }
  // Missing getter
}

Solution:

// GOOD - Do this instead
class Temperature {
  double _celsius;

  set celsius(double value) {
    _celsius = value;
  }

  double get celsius => _celsius; // Proper getter
}

Why: Providing both getters and setters is essential for encapsulation. It allows external code to read the internal state while controlling how it is modified, thus adhering to OOP principles.

5. Using Setters for Complex Logic

Problem: Some beginners try to implement complex business logic in their setters, which can lead to unexpected side effects.

// BAD - Don't do this
class Product {
  double _price;

  set price(double value) {
    if (value < 0) {
      _price = 0; // Complex logic should not be here
    } else {
      _price = value;
    }
    // Other complex business logic
  }
}

Solution:

// GOOD - Do this instead
class Product {
  double _price;

  set price(double value) {
    _price = value < 0 ? 0 : value; // Simple logic
  }

  void applyDiscount(double percentage) {
    if (percentage < 0 || percentage > 100) {
      throw ArgumentError('Invalid discount percentage');
    }
    _price -= _price * (percentage / 100);
  }
}

Why: Setters should focus on modifying property values, not executing complex logic. Keeping business logic separate makes your code cleaner, easier to read, and maintainable.

Best Practices

1. Always Validate Input

Validating input in your setters helps ensure that your objects remain in a valid state. This is crucial for maintaining the integrity of your application.

class BankAccount {
  double _balance;

  set balance(double amount) {
    if (amount < 0) {
      throw ArgumentError('Balance cannot be negative');
    }
    _balance = amount;
  }
}

2. Use Private Variables

Make your instance variables private and provide public setter methods. This enhances encapsulation and maintains control over how your data is accessed and modified.

class Employee {
  String _name;

  set name(String value) {
    _name = value;
  }
}

3. Implement Getters and Setters Together

Always create a getter when you define a setter. This ensures that users of your class can both retrieve and modify the property in a controlled manner.

class Circle {
  double _radius;

  set radius(double value) {
    if (value < 0) throw ArgumentError('Radius cannot be negative');
    _radius = value;
  }

  double get radius => _radius;
}

4. Keep Setters Simple

Setters should primarily focus on assigning values. Avoid placing complex logic within them to keep your code clean and understandable.

class Car {
  double _fuel;

  set fuel(double amount) {
    _fuel = amount >= 0 ? amount : 0; // Only a simple check
  }
}

5. Notify Changes on Setters

If your class is part of a larger system (like a UI), consider notifying other parts of your application when a property changes.

class ObservableValue {
  int _value;
  Function onChanged;

  set value(int newValue) {
    _value = newValue;
    if (onChanged != null) onChanged(); // Notify observers
  }
}

6. Document Your Setters

Provide clear documentation on what your setters do, especially if they include validation or side effects. This helps others understand how to use your class correctly.

class Person {
  String _name;

  /// Sets the name of the person. Must not be empty.
  set name(String value) {
    if (value.isEmpty) throw ArgumentError('Name cannot be empty');
    _name = value;
  }
}

Key Points