When used in combination with the when expression, sealed classes are like enum for classes:
sealed class Port
val name : String
get() = when (this) { //custom getter
is USB ->"this is USB"
is COM ->"this is COM"
}
class USB : Port()
class COM : Port()
USB u = USB
println (u.name) //this prints "this is USB"
Sealed classes are abstract, can have abstract members and define the classes that can inherit from them (USB and COM can inherit from Port)
In Kotlin classes are:
To let the coder inherit from a class we have to use the keyword open. The same applies to methods:
open class Employee {
open fun doSomething() { // can be overridden
}
}
Construction parameters are provided in the class definition. This is the primary constructor. (Internally, Kotlin provides a getter and/or a setter wheter the parameter is a val or a var)
open class Employee(val name : String) {
}
Secondary constructor:
open class Employee(val name : String) {
constructor(name: String, id : Int) : this(name)
}
Constructors and inheritance :
class Tester(name : String) : Employee(name) {
}
More about classes here
In Kotlin interfaces are very similar to Java interfaces, but we can also provide a default implementation for an interface member:
interface IEmployee{
var name : String //abstract property
fun doWork(){
//some default implementation
}
fun doBreak() //abstract
}
Default implementation allows us to add functionality to interfaces without breaking existing code, because default implementation is not required to be implemented:
class Tester (override var name : String) IEmployee {
override fun doBreak () {... }
}
We can inherit from interfaces that have a member with the same signature:
interface ITester{
fun doWork () {...}
}
class Tester (override var name : String) : ITester, IEmployee{
override fun doBreak() {
}
override fun doWork() {
super<ITester>.doWork()
super<IEmployee>.doWork()
}
}
Kotlin let the coder call a function or a method without using the dot notation:
class Person (age : Int) {
infix isOlderThan(p : Person) : Boolean {
return age > p.age
}
}
Person a = Person (34)
Person b = Person (34)
val ret = a isOlderThan b
The infix functions have only one parameter with no default value
Similarly to C# extension methods, it’s possible to extend a class without modifying the class code by using the extension functions.
fun Int.isGreaterThan(number : Int) : Boolean {
return this > number
}
//now we have added a new "functionality" to the Int
//class
val a =2
val b = 3
val c a.isGreaterThan(3)
Extension functions are resolved statically not at run time.
It’s possible to call kotlin functions from within Java.
The following Kotlin code:
//file name Util.kt
@file:JvmName("Utils")
package test
fun displayName() {... }
Is compiled to:
package test
class Utils() {
public static void displayName( ){...}
}
And it can be called this way from Java:
test.Utils.displayName();
More details here
//typical function declaration
fun sum(a: Int, b: Int) : Int {
return a+b
}
//function expression
fun sum(a: Int, b: Int) = a+b
//default parameters
fun payClerck(pay: Double , tip: Double = 1.0) : Double {
return pay+ tip
}
//calling
payClerck(10.)
payClerck(10., 2.)
//using named parameters it is possible to change their
// order when calling the function
payClerck(tip = 1., pay = 2.0)
In kotlin functions are first class citizens:
A first-class citizen […] is an entity which supports all the operations generally available to other entities. These operations typically include being passed as an argument, returned from a function, modified, and assigned to a variable. (Wikipedia)
Functions do not need to be declared inside a class.
Functions can be declared locally
Try/catch can be used as expressions:
val ret:Int? try {
Integer.ParseInt(some string)
} catch (e: NumberFormatException ) {
null
}
Kotlin supports the Java exception hierarchy but exceptions are unchecked.
If can be used as an expression and its result assigned to a variable:
val a = 1 val b = 2 val msg = if (a > b ) "a greater than b" else "a less than b"
Kotlin doesn’t have a switch but there is something very cool called when:
val a = 1
when(a) {
0 -> print("a is zero")
in (1..10) ->print("a in range")
else ->print("a not in range")
}
//file Main.kt
class Person() {
fun greet() {
println("Hello");
}
}
fun main(args: Array) {
Person().greet()
}
In the example above I have created a file with extension kt and inside it I have added a class and the main function. In Kotlin, each class compiles to a separate .class, which gives me Person.class; plus, the main fun, which is not contained in any class, will generate a Mainkt.class
The Mainkt.class contains a public class named Mainkt with a public static method called main
miniguide 