1. History

2. Design

3. Syntax
     Functional programming style   Main entry point  Extension methods  Unpack arguments with spread operator  Deconstructor methods  Nested functions  Classes are final by default  Abstract classes are open by default   Classes are public by default   Primary constructor vs. secondary constructors    Data Class    Anko library  Kotlin interactive shell  Kotlin as a scripting language 

4. Tools

5. Applications

6. Adoption

7. See also

8. References

9. External links

Kotlin is a cross-platform, statically typed, general-purpose programming language with type inference. Kotlin is designed to interoperate fully with Java, and the JVM version of its standard library depends on the Java Class Library,^[2] but type inference allows its syntax to be more concise. Kotlin mainly targets the JVM, but also compiles to JavaScript or native code (via LLVM). Kotlin is sponsored by JetBrains and Google through the Kotlin Foundation.

Kotlin is officially supported by Google for mobile development on Android.^[3] Since the release of Android Studio 3.0 in October 2017, Kotlin is included as an alternative to the standard Java compiler. The Android Kotlin compiler lets the user choose between targeting Java 6 or Java 8 compatible bytecode.^[4]

History

In July 2011, JetBrains unveiled Project Kotlin, a new language for the JVM, which had been under development for a year.^[5] JetBrains lead Dmitry Jemerov said that most languages did not have the features they were looking for, with the exception of Scala. However, he cited the slow compilation time of Scala as a deficiency.^[5] One of the stated goals of Kotlin is to compile as quickly as Java. In February 2012, JetBrains open sourced the project under the Apache 2 license.^[6]

The name comes from Kotlin Island, near St. Petersburg. Andrey Breslav mentioned that the team decided to name it after an island just like Java was named after the Indonesian island of Java^[7] (though the programming language Java was perhaps named after the coffee^[8]).

JetBrains hopes that the new language will drive IntelliJ IDEA sales.^[9]

Kotlin v1.0 was released on February 15, 2016.^[10] This is considered to be the first officially stable release and JetBrains has committed to long-term backwards compatibility starting with this version.

At Google I/O 2017, Google announced first-class support for Kotlin on Android.^[3]

Kotlin v1.2 was released on November 28, 2017.^[11] Sharing code between JVM and Javascript platforms feature was newly added to this release.

Kotlin v1.3 was released on October 29, 2018, bringing coroutines for asynchronous programming.

Design

Development lead Andrey Breslav has said that Kotlin is designed to be an industrial-strength object-oriented language, and a "better language" than Java, but still be fully interoperable with Java code, allowing companies to make a gradual migration from Java to Kotlin.^[12]

Kotlin variable declarations and parameter lists have the data type come after the variable name (and with a colon separator), similar to Pascal.

Variables in Kotlin can be immutable, declared with the {{mono|val}} keyword, or mutable, declared with the {{mono|var}} keyword.^[14]

Class members are public by default, and classes themselves are final by default, meaning that creating a derived class is disabled unless the base class is declared with the {{mono|open}} keyword.

In addition to the classes and methods (called member functions in Kotlin) of object-oriented programming, Kotlin also supports procedural programming with the use of functions.^[15]

Kotlin functions (and constructors) support default arguments, variable-length argument lists, named arguments and overloading by unique signature. Class member functions are virtual, i.e. dispatched based on the runtime type of the object they are called on.

Syntax

Functional programming style

Kotlin relaxes Java's restriction of allowing static methods and variables to exist only within a class body. Static objects and functions can be defined at the top level of the package without needing a redundant class level. For compatibility with Java, Kotlin provides a JvmName annotation which specifies a class name used when the package is viewed from a Java project. For example, @file:JvmName("JavaClassName").

Main entry point

As in C and C++, the entry point to a Kotlin program is a function named "main", which is passed an array containing any command line arguments. Perl and Unix shell style string interpolation is supported. Type inference is also supported.

  val scope = "World"  println("Hello, $scope!")

Extension methods

Similar to C#, Kotlin allows a user to add methods to any class without the formalities of creating a derived class with new methods. Instead, Kotlin adds the concept of an extension method which allows a function to be "glued" onto the public method list of any class without being formally placed inside of the class. In other words, an extension method is a helper method that has access to all the public interface of a class which it can use to create a new method interface to a target class and this method will appear exactly like a method of the class, appearing as part of code completion inspection of class methods. For example:

By placing the preceding code in the top-level of a package, the String class is extended to include a {{code|lastChar}} method that was not included in the original definition of the String class.

Unpack arguments with spread operator

Similar to Python, the spread operator asterisk (*) unpacks an array's contents as comma-separated arguments to a function:

    val list = listOf("args: ", *args)    println(list)

Deconstructor methods

A deconstructor's job is to decompose a class object into a tuple of elemental objects. For example a 2D coordinate class might be deconstructed into a tuple of integer x and integer y.

For example, the collection object contains a deconstructor method that splits each collection item into an index and an element variable:

Nested functions

Kotlin allows local functions to be declared inside of other functions or methods.

    fun validate(user: User, value: String, fieldName: String) {        if (value.isEmpty()) {            throw IllegalArgumentException("Can't save user ${user.id}: empty $fieldName")        }    }        validate(user, user.name, "Name")     validate(user, user.address, "Address")    // Save user to the database     ...

Classes are final by default

In Kotlin if you want to derive a new class from a base class type, then this base class needs to be explicitly marked as "open" in order to allow this to happen. This is in contrast to most object oriented languages such as Java where classes are open by default.

Example of a base class that is open to deriving a new subclass from it.

    // no-open on a function means that     //    polymorphic behavior disabled if function overridden in derived class    fun disable() { ... }

    // open on a function means that    //    polymorphic behavior allowed if function is overridden in derived class    open fun animate() { ... }

    // Explicit use of override keyword required to override a function in derived class    override fun animate() { println("Giga Click!") } 

Abstract classes are open by default

Abstract classes define abstract or "Pure Virtual" placeholder function that will be defined in a derived class. Abstract classes are open by default.

    // This virtual function is already open by default as well    abstract fun animate()      open fun stopAnimating() { }

Classes are public by default

Kotlin provides the following keywords to restrict visibility for top-level declaration, such as classes, and for class members:

When applied to a class member:

    public (default): Visible everywhere     internal:         Visible in a module     protected:        Visible in subclasses     private:          Visible in a class

When applied to a top-level declaration

    public (default):  Visible everywhere    internal:          Visible in a module    private:           Visible in a file

Example:

    // method is only visible to current class     private   fun yell() = println("Hey!")

    // method is visible to current class and derived classes    protected fun whisper() = println("Let's talk!")

Primary constructor vs. secondary constructors

Kotlin supports the specification of a "primary constructor" as part of the class definition itself, consisting of an argument list following the class name. This argument list supports an expanded syntax on Kotlin's standard function argument lists, that enables declaration of class properties in the primary constructor, including visibility, extensibility and mutability attributes. Additionally, when defining a subclass, properties in super-interfaces and super-classes can be overridden in the primary constructor.

    protected val nickname: String,     final override var isSubscribed: Boolean = true)     {         ...    }

However, in cases where more than one constructor is needed for a class, a more general constructor can be used called secondary constructor syntax which closely resembles the constructor syntax used in most object-oriented languages like C++, C#, and Java.

    // Constructor #1     constructor(ctx: Context) : super(ctx) {         // ...     }       // Constructor #2    constructor(ctx: Context, attr: AttributeSet) : super(ctx, attr) {         // ...     }

Data Class

Kotlin provides [https://www.tutorialkart.com/kotlin/data-class-in-kotlin/ Data Classes] to define classes that store only properties. In Java Programming, classes that store only properties are usual, but regular classes are used for this purpose. Kotlin has given provision to exclusively define classes that store properties alone. These data classes do not have any methods but only properties. A data class, does not contain a body, unlike a regular class. data keyword is used before class keyword to define a data class.

    // create a data class object like any other class object    var book1 = Book("Kotlin Programming",250)    println(book)    // output: Book(name=Kotlin Programming, price=250)

Anko library

Anko is a library specifically created for Kotlin to help build Android UI applications.^[16]

    fun Activity.showAreYouSureAlert(process: () -> Unit) {        alert(            title   = "Are you sure?",            message = "Are you really sure?")             {              positiveButton("Yes") { process() }              negativeButton("No") { cancel() }            }    }

Kotlin interactive shell

Kotlin as a scripting language

Kotlin can also be used as a scripting language. A script is a Kotlin source file (.kts) with top level executable code.

To run a script, you pass the -script option to the compiler with the corresponding script file:

        greet {        to.place    }.print()

Variables in Kotlin can be immutable, declared with the {{mono|val}} keyword or mutable, declared with the {{mono|var}} keyword.^[14]

Kotlin makes a distinction between nullable and non-nullable data types. All nullable objects must be declared with a "?" postfix after the type name. Operations on nullable objects need special care from developers: null-check must be performed before using the value. Kotlin provides null-safe operators to help developers:

• {{mono|?.}} (safe navigation operator) can be used to safely access a method or property of a possibly null object. If the object is null, the method will not be called and the expression evaluates to null.
• {{mono|?:}} (null coalescing operator) often referred to as the Elvis operator:

   // use of elvis operator   val name: String = maybe ?: "stranger"   println("Hello $name")

An example of the use of the safe navigation operator:

Kotlin provides support for higher order functions and anonymous functions or lambdas.^[17]

Lambdas are declared using braces, {{mono|{ } }}. If a lambda takes parameters, they are declared within the braces and followed by the {{mono|->}} operator.

Tools

• IntelliJ IDEA has plug-in support for Kotlin.^[18] IntelliJ IDEA 15 is the first version to bundle the Kotlin plugin in the IntelliJ Installer, and provide Kotlin support out of the box.^[19]
• JetBrains also provides a plugin for Eclipse.^[20][21]
• Integration with common Java build tools is supported including Apache Maven,^[22] Apache Ant,^[23] and Gradle.^[24]
• Android Studio (based on IntelliJ IDEA) has official support for Kotlin, starting from Android Studio 3.^[25]
• Emacs has a Kotlin Mode in its Melpa package repository.

Applications

One of the obvious applications of Kotlin is Android development. The platform was stuck on Java 7 for a while (with some contemporary language features made accessible through the use of Retrolambda^[26] or the Jack toolchain^[27]) and Kotlin introduces many improvements for programmers such as null-pointer safety, extension functions and infix notation. Accompanied by full Java compatibility and good IDE support (Android Studio^[28]) it is intended to improve code readability, give an easier way to extend Android SDK classes and speed up development.^[29]

Kotlin was announced as an official Android development language at Google I/O 2017. It became the third language fully supported for Android, in addition to Java and C++.^[30]

Adoption

According to the Kotlin website, Prezi is using Kotlin in the backend.^[31] DripStat has done a writeup of their experience with Kotlin.^[32]

According to Jetbrains blog, Kotlin is used by Amazon Web Services, Pinterest, Coursera, Netflix, Uber, Square, Trello, Basecamp,^[33] and others. Corda, a distributed ledger developed by a consortium of well-known banks (such as Goldman Sachs, Wells Fargo, J.P. Morgan, Deutsche Bank, UBS, HSBC, BNP Paribas, Société Générale), has over 90% Kotlin in its codebase.

According to Google, Kotlin has already been adopted by several major developers — Expedia, Flipboard, Pinterest, Square, and others — for their Android production apps.^[35]

See also

• Comparison of programming languages

References

• This article contains quotations from Kotlin tutorials which are released under a Apache 2.0 license.

External links

• {{Official website}}

• Teredo (disambiguation)
• Teredolites
• Teredo portoricensis
• Ter Eem
• Tereen Airport
• Teree Sang
• Terefah
• Terefundus
• Terefundus crispulatus
• Terefundus cuvierensis
• Terefundus quadricinctus
• Terefundus quadricinctus unicarinatus
• Teregali
• Te Regalo Amores
• Tere Garcia de Madero
• Tereggi medal
• Tere Glassie
• Terego
• Teregova
• Teregova mine
• Teregova River
• Teregovita River
• Teregovița River
• Tere-Holski
• Tere-Hol'ski