CODEWITHSUNDEEP
inheritancedart
F0X
F0X

Reputation: 380

Dart - Abstract constructors

Say I have the abstract class A

abstract class A {
  A.someConstructor(Foo foo);
}

and all subclasses of A should then implement such constructor:

class B extends A {
  @override
  B.someConstructor(Foo foo) {
    // ...
  }
}

So basically what I want is some kind of abstract constructors.

Is there any way of achieving this (of course the above code does not work) or do I need a normal abstract method which then creates the object and sets its properties?

EDIT: Ok so it looks like the only way to create at least a similar behaviour would be something like this:

abstract class A {
  A.someConstructor(Object foo);
}

class B extends A {
  B.someConstructor(Object foo) : super.someConstructor(foo) {
    // ...
  }
}

This isn't exactly useful, and after some thinking about my problem I realized that in fact my original goal itself is not really neccessary, so this questions is now answered.

Upvotes: 0

Views: 3244

Answers (2)

lrn
lrn

Reputation: 71653

You want to enforce a pattern on the constructors of subclasses. The Dart language has no support for doing that.

Dart has types and interfaces which can be used to restrict values and class instance members.

If a class implements an interface, then its instance members must satisfy the signatures declared by the super-interface. This restricts instance members.

If a variable has a type, for example a function type, then you can only assign values of that type to it. This restricts values. Because a class is a subtype of its interfaces, the subclass restriction means that class typed variables can be used safely (the subtype can be used as its supertype because it has a compatible interface).

There is no way to restrict static members or constructors of classes, or members of libraries, because there is no way to abstract over them. You always have to refer directly to them by their precise name, so there is no need for them to match a particular pattern. (Which may explain why you found the goal not necessary too).

In this situation, your subclasses must call the A.someConstructor constructor, but they are free to choose the signature of their own constructors. They can do:

class B extends A {
  B.someConstructor(Object foo) : super.someConstructor(foo);
}
// or
class C extends A {
  C.differentName(Object foo) : super.someConstructor(foo);
}
// or even
class D extends A {
  D() : super.someConstructor(new Object());
}

Upvotes: 3

janstol
janstol

Reputation: 3157

Constructors aren’t inherited

Subclasses don’t inherit constructors from their superclass. A subclass that declares no constructors has only the default (no argument, no name) constructor.

Source

Upvotes: 0

Related Questions