🏭 Factory keyword in dart
Tags: flutter, dart, mobile
Published: 2023-02-03 16:20:01


The factory keyword in Dart is used to define a factory constructor. A factory constructor is a special kind of constructor that doesn't create a new instance of the class when called, but instead returns an existing instance or a new instance based on some logic.

Here is an example of a class MySingleton that uses a factory constructor to ensure that only one instance of the class is ever created:

    class MySingleton {
      static final MySingleton _instance = MySingleton._internal();
      factory MySingleton() {
        return _instance;
      }
      MySingleton._internal();
    }

In this example, the MySingleton class has a private constructor and a public factory constructor. The private constructor is used to create a single instance of the class, which is stored in the _instance static variable. The factory constructor simply returns the existing _instance variable.

Every time you call MySingleton() factory constructor, it will return the same instance of MySingleton class.

This pattern is commonly used to implement singletons, but you can use factory constructors for other purposes as well, such as creating different instances of a class based on some input.

In summary, the factory keyword in Dart is used to define a factory constructor, which is a constructor that doesn't create a new instance of a class, but returns an existing instance or a new instance based on some logic.

Why it’s named like that?

The name “factory” constructor comes from the idea that the constructor is acting like a factory, which is a place where objects are created. In a traditional factory, raw materials are brought in and transformed into finished products through a series of processes. Similarly, a factory constructor takes some input (or no input) and returns a new or an existing instance of a class.

The term “factory” is often used in object-oriented programming to describe a method or function that creates and returns objects. In this context, a factory constructor is a special kind of constructor that creates and returns objects, but does not necessarily create new instances of the class each time it is called. Instead, it may return existing instances or create new instances based on some logic.

Also, the name is chosen to convey the idea that the constructor is not creating a new instance of an object every time it is called, but it is returning an existing instance or creating a new instance based on some logic, in a way that is similar to how a factory produces goods.

**Why i can’t use the constructor?**

You can use the constructor to write logic, but the purpose of a constructor is to initialize the object’s state, not to determine which instance of the class should be created.

A constructor is called when a new instance of a class is created, and it’s main responsibility is to set the initial state of the object. The constructor does not have access to the **state of other instances of the class**, and it can’t make decisions about which instance should be created.

That’s why a factory constructor is used when you want to create an instance of a class based on some logic, or when you want to ensure that only a single instance of a class is created. The factory constructor can take some input as a parameter and based on that it can make decisions about which instance should be created or returned.

For example, you might have a factory constructor that creates an instance of a class based on the value of a configuration file or an environment variable. In this case, you can’t use the constructor to make this decision, because the constructor doesn’t have access to the state of the system. Instead, you can use a factory constructor to implement this logic.

In summary, while you can use a constructor to write logic, it’s main purpose is to initialize the object’s state. When you need to create an instance of a class based on some logic or want to ensure that only a single instance is created, you should use a factory constructor.

**What does state of other instances mean here?**

When we say “state of other instances,” we are referring to the values of the properties or variables that define the current state of an object.

For example, if you have a class called “Car” that has properties such as “color”, “speed”, and “make”, the state of an instance of the Car class would be defined by the values of those properties. If you have two instances of the Car class, each instance will have its own unique state, defined by the values of the properties.

When a constructor creates a new instance of a class, it can only initialize the state of the new instance based on the input that is passed to the constructor. It does not have access to the state of other instances of the class.

A factory constructor, on the other hand, can make decisions about which instance to create or return based on the state of other instances because it can have access to some external data or other instances.

For example, imagine you want to implement a singleton pattern, a design pattern that ensures that only one instance of a class exists throughout the lifetime of an application. In this case, the factory constructor can check if an instance of the class already exists, and if so, it can return the existing instance rather than creating a new one.

So, when we say “state of other instances” we are referring to the state of an object, which is defined by the properties of the object and the values of these properties, and how the factory constructor can make decisions about the instance it should return based on the state of other instances.

**Explain this more simply**

Imagine you want to play with a toy car, and you have a toy factory that makes those toy cars. The factory has different machines that can make different types of cars, like sports cars, trucks, and buses. When you want to play with a toy car, you go to the factory and tell them what kind of car you want. They look at what they have available and give you the car you asked for. The factory is like a constructor, it makes the toy cars.

A constructor is like the toy factory, it creates the object you want to use, but it is not always the best way to make sure you have the right object. A factory constructor is like the toy factory’s worker that checks what kind of car you want before giving it to you. It can give you a new car or the same car if you already have one and don’t need a new one. So, the factory constructor is like a helper for the constructor to make sure you get the right object based on some rules or conditions.