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(){ }
?
Using Class ConstructorThe standard way to initialize an object in Kotlin is with the class constructor. It can accept a set of parameters to initialize its fields, or it can be parameterless. Kotlin has a concise syntax for declaring properties and initializing them: 1.
In Kotlin, there are two constructors: Primary constructor - concise way to initialize a class. Secondary constructor - allows you to put additional initialization logic.
Constructors. A class in Kotlin can have a primary constructor and one or more secondary constructors. The primary constructor is a part of the class header, and it goes after the class name and optional type parameters. The primary constructor cannot contain any code.
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".
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(); } }
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With