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(){ }
?
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".