what is the benefit of having an object of interface itself declare inside the interface for kotlin
up vote
1
down vote
favorite
for example
An interface of
interface StateInterface {
val variationTypes: List<VariationType>
get() = emptyList()
object EMPTY : StateInterface
}
then its been declared inside an actionbean like this
open val stateInterface: StateInterface = StateInterface.EMPTY
Is it all it does it just create a new interface? Why we need to do it this way?
oop kotlin interface
add a comment |
up vote
1
down vote
favorite
for example
An interface of
interface StateInterface {
val variationTypes: List<VariationType>
get() = emptyList()
object EMPTY : StateInterface
}
then its been declared inside an actionbean like this
open val stateInterface: StateInterface = StateInterface.EMPTY
Is it all it does it just create a new interface? Why we need to do it this way?
oop kotlin interface
add a comment |
up vote
1
down vote
favorite
up vote
1
down vote
favorite
for example
An interface of
interface StateInterface {
val variationTypes: List<VariationType>
get() = emptyList()
object EMPTY : StateInterface
}
then its been declared inside an actionbean like this
open val stateInterface: StateInterface = StateInterface.EMPTY
Is it all it does it just create a new interface? Why we need to do it this way?
oop kotlin interface
for example
An interface of
interface StateInterface {
val variationTypes: List<VariationType>
get() = emptyList()
object EMPTY : StateInterface
}
then its been declared inside an actionbean like this
open val stateInterface: StateInterface = StateInterface.EMPTY
Is it all it does it just create a new interface? Why we need to do it this way?
oop kotlin interface
oop kotlin interface
asked Nov 19 at 19:11
Ezeewei
2,28032659
2,28032659
add a comment |
add a comment |
1 Answer
1
active
oldest
votes
up vote
3
down vote
accepted
You don't need to do it that way.
interface StateInterface {
val variationTypes: List<VariationType>
get() = emptyList()
}
object EMPTY : StateInterface
Would work fine, but the author decided that they wanted the usage to read StateInterface.EMPTY
and not just EMPTY
.
One advantage or reason for choosing this way is that EMPTY
appears in the code completion after typing StateInterface.
making it easier to find.
Another readability advantage is that anyone who references StateInterface.EMPTY
does not need an additional import
line which they would if it wasn't a nested object.
import com.example.StateInterface
val x = StateInterface.EMPTY
This bit open val stateInterface: StateInterface = StateInterface.EMPTY
is a property on an object. It's open
so descendant implementations can override
it. If they do not, StateInterface.EMPTY
will be the value of this property.
1
And perhaps a third advantage is that you can have another interface with its own EMPTY member, without a clash of names.
– gidds
Nov 19 at 23:48
add a comment |
1 Answer
1
active
oldest
votes
1 Answer
1
active
oldest
votes
active
oldest
votes
active
oldest
votes
up vote
3
down vote
accepted
You don't need to do it that way.
interface StateInterface {
val variationTypes: List<VariationType>
get() = emptyList()
}
object EMPTY : StateInterface
Would work fine, but the author decided that they wanted the usage to read StateInterface.EMPTY
and not just EMPTY
.
One advantage or reason for choosing this way is that EMPTY
appears in the code completion after typing StateInterface.
making it easier to find.
Another readability advantage is that anyone who references StateInterface.EMPTY
does not need an additional import
line which they would if it wasn't a nested object.
import com.example.StateInterface
val x = StateInterface.EMPTY
This bit open val stateInterface: StateInterface = StateInterface.EMPTY
is a property on an object. It's open
so descendant implementations can override
it. If they do not, StateInterface.EMPTY
will be the value of this property.
1
And perhaps a third advantage is that you can have another interface with its own EMPTY member, without a clash of names.
– gidds
Nov 19 at 23:48
add a comment |
up vote
3
down vote
accepted
You don't need to do it that way.
interface StateInterface {
val variationTypes: List<VariationType>
get() = emptyList()
}
object EMPTY : StateInterface
Would work fine, but the author decided that they wanted the usage to read StateInterface.EMPTY
and not just EMPTY
.
One advantage or reason for choosing this way is that EMPTY
appears in the code completion after typing StateInterface.
making it easier to find.
Another readability advantage is that anyone who references StateInterface.EMPTY
does not need an additional import
line which they would if it wasn't a nested object.
import com.example.StateInterface
val x = StateInterface.EMPTY
This bit open val stateInterface: StateInterface = StateInterface.EMPTY
is a property on an object. It's open
so descendant implementations can override
it. If they do not, StateInterface.EMPTY
will be the value of this property.
1
And perhaps a third advantage is that you can have another interface with its own EMPTY member, without a clash of names.
– gidds
Nov 19 at 23:48
add a comment |
up vote
3
down vote
accepted
up vote
3
down vote
accepted
You don't need to do it that way.
interface StateInterface {
val variationTypes: List<VariationType>
get() = emptyList()
}
object EMPTY : StateInterface
Would work fine, but the author decided that they wanted the usage to read StateInterface.EMPTY
and not just EMPTY
.
One advantage or reason for choosing this way is that EMPTY
appears in the code completion after typing StateInterface.
making it easier to find.
Another readability advantage is that anyone who references StateInterface.EMPTY
does not need an additional import
line which they would if it wasn't a nested object.
import com.example.StateInterface
val x = StateInterface.EMPTY
This bit open val stateInterface: StateInterface = StateInterface.EMPTY
is a property on an object. It's open
so descendant implementations can override
it. If they do not, StateInterface.EMPTY
will be the value of this property.
You don't need to do it that way.
interface StateInterface {
val variationTypes: List<VariationType>
get() = emptyList()
}
object EMPTY : StateInterface
Would work fine, but the author decided that they wanted the usage to read StateInterface.EMPTY
and not just EMPTY
.
One advantage or reason for choosing this way is that EMPTY
appears in the code completion after typing StateInterface.
making it easier to find.
Another readability advantage is that anyone who references StateInterface.EMPTY
does not need an additional import
line which they would if it wasn't a nested object.
import com.example.StateInterface
val x = StateInterface.EMPTY
This bit open val stateInterface: StateInterface = StateInterface.EMPTY
is a property on an object. It's open
so descendant implementations can override
it. If they do not, StateInterface.EMPTY
will be the value of this property.
edited Nov 19 at 19:22
answered Nov 19 at 19:17
weston
38.8k1695165
38.8k1695165
1
And perhaps a third advantage is that you can have another interface with its own EMPTY member, without a clash of names.
– gidds
Nov 19 at 23:48
add a comment |
1
And perhaps a third advantage is that you can have another interface with its own EMPTY member, without a clash of names.
– gidds
Nov 19 at 23:48
1
1
And perhaps a third advantage is that you can have another interface with its own EMPTY member, without a clash of names.
– gidds
Nov 19 at 23:48
And perhaps a third advantage is that you can have another interface with its own EMPTY member, without a clash of names.
– gidds
Nov 19 at 23:48
add a comment |
Thanks for contributing an answer to Stack Overflow!
- Please be sure to answer the question. Provide details and share your research!
But avoid …
- Asking for help, clarification, or responding to other answers.
- Making statements based on opinion; back them up with references or personal experience.
To learn more, see our tips on writing great answers.
Some of your past answers have not been well-received, and you're in danger of being blocked from answering.
Please pay close attention to the following guidance:
- Please be sure to answer the question. Provide details and share your research!
But avoid …
- Asking for help, clarification, or responding to other answers.
- Making statements based on opinion; back them up with references or personal experience.
To learn more, see our tips on writing great answers.
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
StackExchange.ready(
function () {
StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f53381142%2fwhat-is-the-benefit-of-having-an-object-of-interface-itself-declare-inside-the-i%23new-answer', 'question_page');
}
);
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown