Classes

Constructors

A class in Kotlin can have a primary constructor and one or more secondary constructors. The primary constructor is a part of the class header, and it goes after the class name and optional type parameters.

class Person constructor(firstName: String) { /*...*/ } 

If the primary constructor does not have any annotations or visibility modifiers, the constructor keyword can be omitted:

class Person(firstName: String) { /*...*/ } 

The primary constructor cannot contain any code. Initialization code can be placed in initializer blocks prefixed with the init keyword.

During the initialization of an instance, the initializer blocks are executed in the same order as they appear in the class body, interleaved with the property initializers:

//sampleStart class InitOrderDemo(name: String) { val firstProperty = "First property: $name".also(::println) init { println("First initializer block that prints ${name}") } val secondProperty = "Second property: ${name.length}".also(::println) init { println("Second initializer block that prints ${name.length}") } } //sampleEnd fun main() { InitOrderDemo("hello") } 

Primary constructor parameters can be used in the initializer blocks. They can also be used in property initializers declared in the class body:

class Customer(name: String) { val customerKey = name.uppercase() } 

Kotlin has a concise syntax for declaring properties and initializing them from the primary constructor:

class Person(val firstName: String, val lastName: String, var age: Int) 

Such declarations can also include default values of the class properties:

class Person(val firstName: String, val lastName: String, var isEmployed: Boolean = true) 

You can use a trailing comma when you declare class properties:

class Person( val firstName: String, val lastName: String, var age: Int, // trailing comma ) { /*...*/ } 

Much like regular properties, properties declared in the primary constructor can be mutable (var) or read-only (val).

If the constructor has annotations or visibility modifiers, the constructor keyword is required and the modifiers go before it:

class Customer public @Inject constructor(name: String) { /*...*/ } 

Learn more about visibility modifiers.

class Person(val pets: MutableList<Pet> = mutableListOf()) class Pet { constructor(owner: Person) { owner.pets.add(this) // adds this pet to the list of its owner's pets } } 

class Person(val name: String) { val children: MutableList<Person> = mutableListOf() constructor(name: String, parent: Person) : this(name) { parent.children.add(this) } } 

//sampleStart class Constructors { init { println("Init block") } constructor(i: Int) { println("Constructor $i") } } //sampleEnd fun main() { Constructors(1) } 

class DontCreateMe private constructor () { /*...*/ } 

Creating instances of classes

To create an instance of a class, call the constructor as if it were a regular function:

val invoice = Invoice() val customer = Customer("Joe Smith") 

The process of creating instances of nested, inner, and anonymous inner classes is described in Nested classes.

Class members

Classes can contain:

• Constructors and initializer blocks

• Functions

• Properties

• Nested and inner classes

• Object declarations

Inheritance

Classes can be derived from each other and form inheritance hierarchies. Learn more about inheritance in Kotlin.

Abstract classes

A class may be declared abstract, along with some or all of its members. An abstract member does not have an implementation in its class. You don't need to annotate abstract classes or functions with open.

abstract class Polygon { abstract fun draw() } class Rectangle : Polygon() { override fun draw() { // draw the rectangle } } 

You can override a non-abstract open member with an abstract one.

open class Polygon { open fun draw() { // some default polygon drawing method } } abstract class WildShape : Polygon() { // Classes that inherit WildShape need to provide their own // draw method instead of using the default on Polygon abstract override fun draw() } 

Companion objects

If you need to write a function that can be called without having a class instance but that needs access to the internals of a class (such as a factory method), you can write it as a member of an object declaration inside that class.

Even more specifically, if you declare a companion object inside your class, you can access its members using only the class name as a qualifier.