What about this? Describe the desired shape of MyClass and its constructor: interface MyClass { val: number; } interface MyClassConstructor { new(val: number): MyClass; // newable (val: number): MyClass; // callable } Notice that MyClassConstructor is defined as both callable as a function and newable as a constructor. Then implement it: const MyClass: MyClassConstructor = … Read more
By the way of example, suppose you want to define a type to represent even numbers: julia> struct Even e::Int end julia> Even(2) Even(2) So far so good, but you also want the constructor to reject odd numbers and so far Even(x) does not: julia> Even(3) Even(3) So you attempt to write your own constructor … Read more
It’s not prohibited, you are just applying @JvmOverloads to the wrong target. The proper way to annotate primary constructor is to explicitly specify constructor keyword with @JvmOverloads before: class Video @JvmOverloads constructor( private val id: Long, val ownerId: Long, var title: String? = null, var imgLink: String? = null, var videoLink: String? = null, var … Read more
Because your constructor implementation is called by all your overload constructors. (Technically, at runtime there’s only one constructor function that gets called with the various overload argument signatures.) Imagine it like this: overload_constructor(id:string) { implementation_constructor(id); } implementation_constructor(id:string, name?:string, age?:number) { // … } Thinking of it this way, overload_constructor could not call implementation_constructor unless name … Read more
A Kotlin data class must have a primary constructor that defines at least one member. Other than that, you can add secondary constructors as explained in Classes and Inheritance – Secondary Constructors. For your class, and example secondary constructor: data class User(val name: String, val age: Int) { constructor(name: String): this(name, -1) { … } … Read more
The part after : is called “initializer list”. It is a ,-separated list of expressions that can access constructor parameters and can assign to instance fields, even final instance fields. This is handy to initialize final fields with calculated values. The initializer list is also used to call other constructors like : …, super(‘foo’). Since … Read more
Was just struggling with a similar problem myself, and this seems to work for me: type Constructor<T> = Function & { prototype: T }
There are two possible ways to do this: class Chipmunk { String name; int fame; Chipmunk.named(this.name, [this.fame]); Chipmunk.famous1() : this.named(‘Chip’, 1000); factory Chipmunk.famous2() { var result = new Chipmunk.named(‘Chip’); result.fame = 1000; return result; } } Chipmunk.famous1() is a redirective constructor. You can’t assign properties in this one, so the constructor you are calling has … Read more
No, when you use a constructor you know you are dealing with the subtype. This allows you to have preconditions not required for the parent constructor such as other parameters. This is why in most languages the constructor name is that of the class being created. A good example of how this is that a … Read more
Update: Since M11 (0.11.*), you can use secondary constructors to solve this problem: class PhotoLibException : RuntimeException { constructor(message: String, ex: Exception?): super(message, ex) {} constructor(message: String): super(message) {} constructor(ex: Exception): super(ex) {} } Currently, there’s no way to call different super-constructors in different context from the same class. It will be supported in the … Read more