Disambiguation refers to the removal of ambiguity by making something clear. Importing a library or a class in code is a daily routine of a programmer. It’s pretty easy to import files into the code in every language, thanks to the great code editors nowadays.
However, what happens if you try to import two classes into a file? Though you should always try to have different names for different classes, sometimes it’s unavoidable. For example, in the case of different libraries having the same name for their classes. In Java, there is a workaround; you have to use the full qualifier, which looks something like this:
class X {
com.very.very.long.prefix.bar.Foo a;
org.other.very.very.long.prefix.baz.Foo b;
...
}Dirty, isn’t it? Now, let’s see how Kotlin addresses it gracefully.
Ensure that you have a code editor on which you can write and run the code. To test things out, you can create two classes with the same name but under different packages. Refer to the example here:
In the following steps and examples, we will see how we can disambiguate classes of the similar name using Kotlin's keyword.
- In Kotlin, you can disambiguate using the
askeyword to locally rename the clashing entity. So in Kotlin, it will look as shown:
import foo.Bar // Bar is accessible import bar.Bar as bBar // bBar stands for 'bar.Bar'
- Then, access their methods like this:
Bar.methodOfFooBar() bBar.methodOfBarBar()
For example, let's see the use of the as keyword to disambiguate two classes having the same name (SomeClass.kt), but in different packages:
SameClass.kt (packageA)
package packageA
class SameClass {
companion object {
fun methodA(){
println("Method a")
}
}
}SameClass.kt (packageB)
package packageB
class SameClass {
companion object {
fun methodB(){
println("Method b")
}
}
}HelloWorld.kt is the class that uses classes with similar names:
import packageA.SameClass as anotherSameClass
import packageB.SameClass
fun main(args: Array<String>) {
anotherSameClass.methodA()
SameClass.methodB()
}