Dart factory constructor - how is it different to

In Dart, factory constructors needs more logic from coders, but not so different from const ones except they permit 'Non final' instance variables.

What are their merits over const constructors?

Thank you all.

Edited

Below is about a usage of factory constructor from Seth Ladd's blog ' Dart - Trying to understand the value of 'factory' constructor'.

class Symbol {
  final String name;
  static Map<String, Symbol> _cache = new Map<String, Symbol>();

  factory Symbol(String name) {
    if (_cache.containsKey(name)) {
      return _cache[name];
    } else {
      final symbol = new Symbol._internal(name);
      _cache[name] = symbol;
      return symbol;
    }
  }

  Symbol._internal(this.name);
}


main() {
  var x = new Symbol('X');
  var alsoX = new Symbol('X');

  print(identical(x, alsoX));  // true
}

IMHO, with general constructor, the same effect can be achieved with a subtle difference, but quite simpler.

class Symbol {
  static final Map<String, Symbol> cache = {};
  final String name;

  Symbol(name) {
    cache[name] = new Symbol._internal();
  }

  Symbol._internal();
}

main(){
var a = new Symbol('something');
var b = new Symbol('something');

print(identical(a, b)); // false!
print(Symbol.cache); //{something: Instance of 'Symbol'}
}

As shown above, though the two instances, a & b, are different objects, the effect is all the same as shown in 'print(Symbol.cache); //{something: Instance of 'Symbol'}' as a map object permit only one of same strings as its key.

So, my question was what are peculiar merits of factory constructor(or factory pattern) over general/const constructors? Because the above sample code alone shows no merit of factory constructor.

Could anyone explain what is so called 'Factory Pattern' in Dart language rather than Java/C#?

A factory constructor and a const constructor fulfill entirely different purposes. A const constructor allows to have an instance of a custom class in a compile time constant expression. See https://stackoverflow.com/a/21746692/217408 for more details about the const constructor.

A factory constructor and a constant method that returns a new instance of a class are more similar. The difference is, that a factory constructor is called with new like a normal constructor and has some limitations a constant method doesn't have.

The main difference between a normal constructor and a factory constructor is, that you can influence if actually a new instance is created and of what concrete type it is.

In https://www.dartlang.org/dart-tips/dart-tips-ep-11.html a cache is mentioned as a popular example. A factory constructor can check if it has a prepared reusable instance in an internal cache and return this instance or otherwise create a new one.

Another example is the singleton pattern. See https://stackoverflow.com/a/12649574/217408 for more details.

Another example is the factory pattern. You can for example have an abstract class A (which can't be instantiated) with a factory constructor that returns an instance of a concrete subclass of A depending for example on the arguments passed to the factory constructor.

Here is a similar question Dart - Trying to understand the value of 'factory' constructor