Objects Dart: Understanding Classes, Instances, and Methods

Object-oriented programming (OOP) is a programming paradigm centered on the concept of "objects," which can contain data in the form of fields, sometimes referred to as attributes or properties, and code in the form of procedures, also called methods. As an object-oriented programming language, Dart embraces this paradigm and provides a rich set of features to implement OOP concepts effectively.

Understanding the Basics of OOP

The core of object-oriented programming involves creating classes, which are blueprints for objects. In Dart, a class can be defined using the class keyword. For example, a class student might represent the data and functionality associated with a student. This class would have instance variables to hold data, such as a student's name and ID, and methods to perform operations on this data.

Copy
1
2
3
4
5
6
7
8
class Student {
  String name;
  int id;

  void study() {
    print('Studying');
  }
}

Name and id are instance variables in the above example, and study is a method. The class student can be instantiated to create many objects, each representing a different student with unique data.

Dart's Place in OOP Languages

Dart strengthens its position as an object-oriented programming language by incorporating all the fundamental OOP principles, such as encapsulation, inheritance, and polymorphism. Dart objects are instances of classes and center interaction within a Dart application.

In Dart, instance variables can have default values and be final or non-final. Non-final instance variables can be changed after an object is created, while final ones cannot. Dart also provides implicit getter and setter methods, for instance, variables, allowing for controlled access and modification of these variables.

Copy
1
2
3
4
5
6
7
class Student {
  String name;
  int _id; // Private to the library due to the underscore

  int get id => _id;
  set id(int value) => _id = value;
}

In the above example, _id is a private instance variable with an implicit getter method and an implicit setter method, allowing other parts of the code to access and modify the ID in a controlled manner.

Classes in Dart: Blueprints for Objects

Defining Classes and Their Properties

In Dart, a class serves as a blueprint for creating objects. It encapsulates data and functions that operate on the data. Instance variables represent the data, and methods represent the functions. We use the class keyword to define a class, followed by the class name and a pair of curly braces .

Copy
1
2
3
4
5
6
7
8
9
class Point {
  int x;
  int y;

  void moveTo(int newX, int newY) {
    x = newX;
    y = newY;
  }
}

In the above example, class Point has two instance variables, x and y, and a method named moveTo. The instance variables hold the data for the class, while the method provides behavior.

Constructors: Creating Instances of Classes

A constructor is a special class function called when a new class instance is created. In Dart, a constructor has the same name as the class. It can have constructor arguments to initialize instance variables with values when an object is created.

Copy
1
2
3
4
5
6
7
8
9
10
11
class Point {
  int x;
  int y;

  Point(this.x, this.y);

  void moveTo(int newX, int newY) {
    x = newX;
    y = newY;
  }
}

In the above example, the class Point has a constructor that takes two parameters, x and y, and sets the instance variables to the values passed in when a new instance of Point is created. The this keyword refers to the current instance.

Dart also supports named constructors, which allow a class to define multiple constructors with different names.

Copy
1
2
3
4
5
6
7
8
9
10
class Point {
  int x;
  int y;

  Point(this.x, this.y);
  Point.origin() {
    x = 0;
    y = 0;
  }
}

In the above example, class Point has a named constructor Point.origin which initializes the instance variables to a default origin point (0,0).

Constructors can also have optional parameters, which allow you to omit arguments when creating a new instance.

Copy
1
2
3
4
5
6
class Point {
  int x;
  int y;

  Point([this.x = 0, this.y = 0]);
}

Here, the constructor for class Point has optional parameters with default values of 0, so you can create a new instance of Point without providing any arguments, and it will default to the origin.

Instances and Objects: Bringing Classes to Life

Working with Instances: Accessing Properties and Methods

Once a class is defined, we can create objects by instantiating the class. Each object created from a class is an instance of that class. In Dart, we use the new keyword to instantiate a class, although it's optional and often omitted.

Copy
1
2
3
4
5
void main() {
  Point p = new Point(2, 3);
  print(p.x); // Accessing the instance variable 'x'
  p.moveTo(5, 6); // Calling the instance method 'moveTo'
}

In the above example, within the void main function, we create a new instance of class Point and assign it to the variable p. We then access the instance variables and call the instance method moveTo to change the object's state.

The Lifecycle of an Instance in Dart

The lifecycle of an instance in Dart begins when it is created using a constructor. The instance remains alive if there is a reference to it in the code. Once no more references exist to the instance, Dart's garbage collector will eventually reclaim the memory, effectively ending the instance's lifecycle.

Copy
1
2
3
4
5
void main() {
  var p1 = Point(2, 3);
  var p2 = p1; // p2 is now a reference to the same instance as p1
  p1 = null; // The original reference to the instance is removed, but p2 still refers to it
}

In the void main function of the above example, p1 is initially a reference to a new instance of class Point. When we assign p1 to p2, both variables refer to the same instance. Setting p1 to null removes one reference, but the instance continues because p2 still refers to it.

Methods: Adding Behavior to Dart Objects

Instance Methods: Interacting with Objects

Instance methods are functions defined within a class and used to perform operations on instances of that class. These methods can access and modify instance variables, providing behavior to dart objects.

Copy
1
2
3
4
5
6
7
8
9
class Student {
  String name;
  int age;

  void celebrateBirthday() {
    age++;
    print('$name is now $age years old.');
  }
}

In the above example, the class student has an instance method called celebrateBirthday, which increments the age instance variable and prints a message. To call this method, you would create an instance of class student and then use the dot notation.

Copy
1
2
3
4
5
6
7
void main() {
  Student student = Student()
    ..name = 'Alice'
    ..age = 20;

  student.celebrateBirthday(); // Alice is now 21 years old.
}

In the void main function, we create a new student and then call the celebrateBirthday method. The cascade operator (..) is used to access multiple instance variables or methods on the same object.

Static Methods: Utility Functions at the Class Level

Static methods belong to the class itself rather than to class instances. They are often used as utility functions relevant to the class.

Copy
1
2
3
4
5
class MathHelper {
  static int add(int a, int b) {
    return a + b;
  }
}

In the above example, add is a static method of the class MathHelper. It can be called without creating an instance of the class.

Copy
1
2
3
4
void main() {
  int sum = MathHelper.add(10, 5);
  print(sum); // 15
}

In the void main function, we call the static method add directly on the class name MathHelper without needing to instantiate it.

Static methods are useful when an approach does not need to access any instance variables or instance methods of a class. They can be called directly using the class name, which can conveniently organize helper functions and other utility codes.

In exploring object-oriented programming in Dart, we've covered the fundamental concepts that make Dart a powerful and flexible language for OOP. From defining classes and their properties to understanding constructors and creating instances, we've seen how dart objects are brought to life and interacted with. We've also delved into the behavior of these objects through instance methods and the utility of static methods at the class level.