Kotlin (programming language)

 1 // Hello, World! example
 2 fun main() {
 3     val scope = "World"
 4     println("Hello, $scope!")
 5 }
 6 
 7 fun main(args: Array<String>) {
 8     for (arg in args) {
 9         println(arg)
10     }
11 }

1 package MyStringExtensions
2 
3 fun String.lastChar(): Char = get(length - 1)
4 
5 >>> println("Kotlin".lastChar())

1 // Overloading '+' operator using an extension method
2 operator fun Point.plus(other: Point): Point {
3     return Point(x + other.x, y + other.y)
4 }
5 
6 >>> val p1 = Point(10, 20)
7 >>> val p2 = Point(30, 40)
8 >>> println(p1 + p2)
9 Point(x=40, y=60)

1 fun main(args: Array<String>) { 
2     val list = listOf("args: ", *args)
3     println(list)
4 }

1 for ((index, element) in collection.withIndex()) { 
2      println("$index: $element")
3 }

 1 class User(val id: Int, val name: String, val address: String)
 2     
 3 fun saveUserToDb(user: User) {
 4     fun validate(user: User, value: String, fieldName: String) {
 5         if (value.isEmpty()) {
 6             throw IllegalArgumentException("Can't save user ${user.id}: empty $fieldName")
 7         }
 8     }
 9     
10     validate(user, user.name, "Name") 
11     validate(user, user.address, "Address")
12     // Save user to the database 
13     ...
14 }

 1 // open on the class means this class will allow derived classes
 2 open class MegaButton  {
 3 
 4     // no-open on a function means that 
 5     //    polymorphic behavior disabled if function overridden in derived class
 6     fun disable() { ... }
 7 
 8     // open on a function means that
 9     //    polymorphic behavior allowed if function is overridden in derived class
10     open fun animate() { ... }
11 }
12 
13 class GigaButton: MegaButton {
14 
15     // Explicit use of override keyword required to override a function in derived class
16     override fun animate() { println("Giga Click!") } 
17 }

 1 // No need for the open keyword here, it’s already open by default
 2 abstract class Animated {
 3 
 4     // This virtual function is already open by default as well
 5     abstract fun animate()
 6   
 7     open fun stopAnimating() { }
 8 
 9     fun animateTwice() { }
10 }

1 // Class is visible only to current module
2 internal open class TalkativeButton : Focusable {
3     // method is only visible to current class 
4     private   fun yell() = println("Hey!")
5 
6     // method is visible to current class and derived classes
7     protected fun whisper() = println("Let's talk!")
8 }

1 // Example of class using primary constructor syntax
2 // (Only one constructor required for this class)
3 open class PowerUser : User (
4     protected val nickname: String, 
5     final override var isSubscribed: Boolean = true) 
6     {
7          ...
8     }

 1 // Example of class using secondary constructor syntax
 2 // (more than one constructor required for this class)
 3 class MyButton : View {
 4 
 5     // Constructor #1 
 6     constructor(ctx: Context) : super(ctx) { 
 7         // ... 
 8     } 
 9   
10     // Constructor #2
11     constructor(ctx: Context, attr: AttributeSet) : super(ctx, attr) { 
12         // ... 
13     }
14 }

1 fun main(args: Array) {
2     // create a data class object like any other class object
3     var book1 = Book("Kotlin Programming", 250)
4     println(book1)
5     // output: Book(name=Kotlin Programming, price=250)
6 }
7      
8 // data class with parameters and their optional default values
9 data class Book(val name: String = "", val price: Int = 0)

1     fun Activity.showAreYouSureAlert(process: () -> Unit) {
2         alert(
3             title   = "Are you sure?",
4             message = "Are you really sure?") 
5             {
6                 positiveButton("Yes") { process() }
7                 negativeButton("No") { cancel() }
8             }
9     }

1 // list_folders.kts
2 import java.io.File
3 val folders = File(args[0]).listFiles { file -> file.isDirectory() }
4 folders?.forEach { folder -> println(folder) }

 1 fun main(args: Array<String>) {
 2     greet {
 3         to.place
 4     }.print()
 5 }
 6 
 7 // Inline higher-order functions
 8 inline fun greet(s: () -> String) : String = greeting andAnother s()
 9 
10 // Infix functions, extensions, type inference, nullable types, 
11 // lambda expressions, labeled this, Elvis operator (?:)
12 infix fun String.andAnother(other : Any?) = buildString() 
13 { 
14     append(this@andAnother); append(" "); append(other ?: "") 
15 }
16 
17 // Immutable types, delegated properties, lazy initialization, string templates
18 val greeting by lazy { val doubleEl: String = "ll"; "he${doubleEl}o" }
19 
20 // Sealed classes, companion objects
21 sealed class to { companion object { val place = "world"} }
22 
23 // Extensions, Unit
24 fun String.print() = println(this)

1 fun sayHello(maybe: String?, neverNull: Int) {
2     // use of elvis operator
3     val name: String = maybe ?: "stranger"
4     println("Hello $name")
5 }

1 // returns null if...
2 // - foo() returns null,
3 // - or if foo() is non-null, but bar() returns null,
4 // - or if foo() and bar() are non-null, but baz() returns null.
5 // vice versa, return value is non-null if and only if foo(), bar() and baz() are non-null
6 foo()?.bar()?.baz()

1 // the following function takes a lambda, f, and executes f passing it the string, "lambda"
2 // note that (s: String) -> Unit indicates a lambda with a String parameter and Unit return type
3 fun executeLambda(f: (s: String) -> Unit) {
4     f("lambda")
5 }

1 // the following statement defines a lambda that takes a single parameter and passes it to the println function
2 val l = { c : Any? -> println(c) }
3 // lambdas with no parameters may simply be defined using { }
4 val l2 = { print("no parameters") }