Dart Classes and Objects: A Complete Guide

Are you looking to learn about Dart classes and objects? Look no further! In this complete guide, we'll cover everything you need to know about classes and objects in Dart.

What are Classes and Objects?

Classes and objects are fundamental concepts in object-oriented programming. A class is a blueprint for creating objects, while an object is an instance of a class. In other words, a class defines the properties and behaviors of a type of object, while an object is a specific instance of that type.

In Dart, classes are defined using the class keyword, followed by the class name and a set of curly braces that contain the class members. Here's an example:

class Person {
  String name;
  int age;

  void sayHello() {
    print('Hello, my name is $name and I am $age years old.');
  }
}

In this example, we've defined a Person class with two properties (name and age) and a method (sayHello). We can create objects of this class using the new keyword:

var person = new Person();
person.name = 'Alice';
person.age = 30;
person.sayHello(); // prints "Hello, my name is Alice and I am 30 years old."

Constructors

Constructors are special methods that are used to create objects of a class. In Dart, constructors are defined using the same name as the class. Here's an example:

class Person {
  String name;
  int age;

  Person(String name, int age) {
    this.name = name;
    this.age = age;
  }

  void sayHello() {
    print('Hello, my name is $name and I am $age years old.');
  }
}

In this example, we've defined a constructor that takes two parameters (name and age) and sets the corresponding properties. We can create objects of this class using the constructor:

var person = new Person('Alice', 30);
person.sayHello(); // prints "Hello, my name is Alice and I am 30 years old."

Dart also supports named constructors, which allow you to define multiple constructors with different parameter lists. Here's an example:

class Person {
  String name;
  int age;

  Person(String name, int age) {
    this.name = name;
    this.age = age;
  }

  Person.fromMap(Map<String, dynamic> map) {
    this.name = map['name'];
    this.age = map['age'];
  }

  void sayHello() {
    print('Hello, my name is $name and I am $age years old.');
  }
}

In this example, we've defined two constructors: the first takes name and age parameters, while the second takes a Map with name and age keys. We can create objects of this class using either constructor:

var person1 = new Person('Alice', 30);
var person2 = new Person.fromMap({'name': 'Bob', 'age': 40});
person1.sayHello(); // prints "Hello, my name is Alice and I am 30 years old."
person2.sayHello(); // prints "Hello, my name is Bob and I am 40 years old."

Inheritance

Inheritance is a mechanism that allows you to define a new class based on an existing class. The new class (called the subclass) inherits the properties and behaviors of the existing class (called the superclass), and can also add its own properties and behaviors.

In Dart, inheritance is defined using the extends keyword. Here's an example:

class Animal {
  String name;

  Animal(String name) {
    this.name = name;
  }

  void sayHello() {
    print('Hello, my name is $name.');
  }
}

class Dog extends Animal {
  Dog(String name) : super(name);

  void bark() {
    print('Woof!');
  }
}

In this example, we've defined an Animal class with a name property and a sayHello method, and a Dog class that extends Animal and adds a bark method. We can create objects of the Dog class and call its methods:

var dog = new Dog('Fido');
dog.sayHello(); // prints "Hello, my name is Fido."
dog.bark(); // prints "Woof!"

Getters and Setters

Getters and setters are special methods that allow you to control access to an object's properties. Getters are used to retrieve the value of a property, while setters are used to set the value of a property.

In Dart, getters and setters are defined using the get and set keywords, respectively. Here's an example:

class Person {
  String _name;

  String get name => _name;

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

In this example, we've defined a Person class with a private _name property and a public name property that uses a getter and a setter. The getter simply returns the value of _name, while the setter sets the value of _name to the uppercase version of the input value.

We can create objects of this class and use the getter and setter:

var person = new Person();
person.name = 'Alice';
print(person.name); // prints "ALICE"

Static Members

Static members are properties and methods that belong to a class rather than to an instance of the class. In other words, they are shared by all instances of the class.

In Dart, static members are defined using the static keyword. Here's an example:

class Person {
  static int count = 0;

  Person() {
    count++;
  }
}

In this example, we've defined a Person class with a static count property that keeps track of the number of Person objects that have been created. We can create objects of this class and access the static property:

var person1 = new Person();
var person2 = new Person();
print(Person.count); // prints "2"

Conclusion

In this complete guide, we've covered everything you need to know about classes and objects in Dart. We've learned how to define classes and objects, how to use constructors, how to use inheritance, how to use getters and setters, and how to use static members.

Now that you have a solid understanding of these concepts, you're ready to start building your own Dart applications using classes and objects. Happy coding!

Additional Resources