This type has a constructor and must be initialized here - Kotlin

Question

I just get started experimenting Android app using Kotlin. I just wanted to inherit Application class like this:

class SomeApp : Application {  } 

But the compiler raises the warning:

and suggestion changes it to:

class SomeApp : Application() {     override fun onCreate() {         super.onCreate()     } } 

I read about primary and secondary constructors in the docs. So if super class has a primary constructor, then is it necessary to write here? like Application class has its own constructor

public Application() {     super(null); } 

then it would be necessary to have primary constructor for derived? or Can't I do something like Java way:

class SomeApp : Application {    constructor SomeApp(){       super();     } } 

or this error suggests something else? Can anyone explain me in detail? I'm very new to the language and this looks weird to me.

Edit: In java I can do the following: class SomeApp extends Application{ }

It has implicit constructor, so I do not have to write: class SomeApp extends Application{ public Application(){ super(); } } But in kotlin do I have to define empty constructor like the following: class SomeApp:Application(){ } ?

Answer 1

This is not about primary/secondary constructors.

On JVM (and pretty much anywhere else) a constructor of the base class Application is called when you create an instance of SomeApp

In Java the syntax is like you said:

class SomeApp : Application {     constructor SomeApp(){       super();     } } 

Here you must declare a constructor, and then you must call a constructor of the super class.

In Kotlin the concept is exactly the same, but the syntax is nicer:

class SomeApp() : Application() {     ... } 

Here you declare a constructor SomeApp() without parameters, and say that it calls Application(), without parameters in that case. Here Application() has exact the same effect as super() in the java snippet.

And in some cases some brackets may be omitted:

class SomeApp : Application() 

The text of the error says: This type has a constructor, and thus must be initialized here. That means that type Application is a class, not an interface. Interfaces don't have constructors, so the syntax for them does not include a constructor invocation (brackets): class A : CharSequence {...}. But Application is a class, so you invoke a constructor (any, if there are several), or "initialize it here".

Answer 2

You don't need

class SomeApp : Application() {    constructor SomeApp(){       super();     } } 

because this is equivalent. And if the class has a primary constructor, the base type can (and must) be initialized right there, using the parameters of the primary constructor.

class SomeApp : Application() { } 

which is also equivalent in java to

class SomeApp extends Application {      public SomeApp(){        super();      } }