In Kotlin classes are:

• Public by default
• Final by default

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

• JVM language
• Functional language
• Object oriented
• Statically typed
• Fully interoperable with Java