We use the class keyword to define a class. A class can optionally have multiple data members (aka data fields or properties or state) & member functions (aka behaviors) :

 class /* className */(
		/* data members (optional) */
) {
		/* member functions (optional) */
}
 

Examples :

 // Simple class with no data members or member functions
class Planet

// Class with single data member
class Person(val name: String)

// Class with 2 data members
class Student(
		val rollNo: Int,
		val name: String
)

// Class with 2 data members & 1 member function
class Cart(
		val items: List<Item>,
		var discount: Int
) {
		fun total() = items.sumOf { it.amount } - discount
}

fun main() {}
 

Note that we can use both val and var to define data members of a class.

A class is just a blueprint and doesn’t hold any data. We cannot access Class members directly. Following code doesn’t compile :

 class Person(val name: String)

fun main() {
		println(Person.name) // ERROR, Doesn't store anything!
}
 

To actually create an instance / object of the class, we invoke the constructor of class.

Instance / Object of a class is a variable of type class.

Constructor is a special function of a class used to conctruct (create) an instance (object) of that class. → It’s name is the class name. → It is also used to initialize the fields of class.

In the Planet class defined below, notice how the data members are enclosed in parenthesis (). Using this syntax, we define the constructor for this class which takes just one argument - name :

 class Planet(val name: String)
 

To create an object of Planet class, we invoke this constructor function using the class name :

 val earth = Planet("Earth")
 

Here Person is just a class & earth is an instance (object) of that class. Notice that we used the constructor to initialize the name field of Person class.

If we don’t define a constructor, one constructor is provided by default :

 class Star

val sun = Star()
 

We use the dot . notation to access members (data members & member functions) of a class :

 class Rectangle(val l: Int, val b: Int) {
		fun area() = l * b
		fun perimeter() = 2 * (l + b)
}

fun main() {
		val r1 = Rectangle(2, 6)
		println("l = ${r1.l}, b = ${r1.b}")
		println("area = ${r1.area()}, perimeter = ${r1.perimeter()}")
}
 

Lets understand the difference between Class and Object with the help of some examples :

• You might have come across digital forms created using TypeForm, GoogleForms etc. The form that one creates using such tools can be thought of as a class. It doesn’t store any form data but only provides the structure and design of the form. The actual response that a user fills in a form can be thought of as an object. So, Form is a class wheras the responses are its objects.
• Before a car is manufactured, its design is first created and finalized on a computer, describing all its components, colors, textures etc. Then, lots of cars are manufactured based on that design. That design - which doesn’t exist physically can be thought of as a class but the actual cars that are manufactured can be thought of as objects.

If we want to execute a piece of code when the object is constructed, we can use the init (initializer) block :

 class /* className */(
		/* dataMembers */
) {
		init {
				/* code */
		}

		/* memberFunctions */
}
 

Example :

 class Planet(val name: String) {
    init {
        println("constructing Planet $name...")
    }
}

fun main() {
    val earth = Planet("Earth") // Prints "constructing Planet Earth..."
}
 

• You can think of init block as the body of constructor function.
• You can define multiple init blocks in a class and they will be executed in the order they are defined.

One thing that might seem odd in constructor function is that we can define its arguments using val & var keywords (Special function remember?). But function arguments are implicitly val only and can’t be explicitly defined as var or val :

 fun square(val x: Int) = x * x    // val not allowed, won't work!
fun cube(var x: Int) = x * x * x  // var not allowed, won't work!

// But this works, how?
class Planet(var name: String)
 

val & var in constructor are used to define the data member of the class and not just a function argument. Further it indicates whether the data member is mutable or not.

 class Student(
		val rollNo: Int,
		var name: String
) 

fun main() {
		val s1 = Student(1, "A")
		s1.rollNo = 5  // val cannot be reassigned!
		s1.name = "A1" // Works!
}
 

If we remove the val or var keyword, the parameter acts as an argument to the constructor and not data member of the class.

Consider the following example - Lets define a User class with one data member name but this name should be created from given firstName, middleName and lastName. We can do it like this :

 class User(
    firstName: String,
    middleName: String,
    lastName: String
) {
    val name: String

    init {
        name = listOf(firstName, middleName, lastName)
            .filter { it.isNotBlank() }
            .joinToString(" ")
    }
}

fun main() {
    val users = listOf(
        User("A", "", "C"),
        User("B", "P", "Q"),
        User("C", "R", "")
    )
    users.forEach {
        // println(it.firstName) -> Won't work!
        println(it.name) // Works!
    }
}
 

Note :

• firstName, middleName and lastName are defined as constructor arguments and not class data members. They are accessible only in the init block and cleared after that. So, accessing them from object is not possible.
• name is not defined in the constructor but as a separate data member in the class. It must be assigned a value either directly or in the init block.

The constructor defined with class name is called the Primary constructor. Apart from that, we can define multiple Secondary constructor also.

• For defining secondary constructors, we use the constructor keyword.
• Each secondary constructor must invoke the primary constructor using the this keyword.

 class /* className */(
		/* dataMembers */
) {
		constructor(/* params */): this(/* initialize data members */) {
				/* code */
		}

		/* memberFunctions */
}
 

 class Planet(val name: String) {
    constructor(): this("Unknown") {
        println("Identified Unknown planet...")
    }
}

fun main() {
    val earth = Planet("Earth")
    val unknown = Planet() // Prints "Identified Unknown planet..."
}
 

Recall that a function can be defined with default values for its arguments. Because constructor is also a function, we can define default values for constructor parameters & data members also :

 class /* className */(
		/* arg / dataMember */ = /* default value */
) {

		/* memberFunctions */
}
 

 class Sqaure(
    val size: Int = 100,
    val color: String = "Black",
    val strokeWidth: Int = 1
)

fun main() {
    val s1 = Sqaure() // All default values assigned
    val s2 = Sqaure(color = "Red") // Default color & strokeWidth
    val s3 = Sqaure(color = "Red", strokeWidth = 2) // Default size
    val s4 = Sqaure(size = 200, color = "Red", strokeWidth = 2) // All custom values 
}
 

Visibility modifiers are keywords that help us control the accessibility of class & class members. Ex. - public, private, protected, internal

All classes and their members are public by default i.e. we can access them anywhere in our project. We can control the accessibility using certain visibility modifiers. But when do we need to do so? We need to control accessibility in order to achieve abstraction (hide implementation details) & enhance data security (prevent accidental modification of data).

We have the following visibility modifiers :

• public - accessible everywhere in the module. Also accessible in the modules which import the module where it is defined.
• private -
  • For class, class is visible only in the file it is defined in
  • For class members, visible only inside the class they are defined
• protected - only applicable on class members. Similar to private except that it is accessible in sub-classes also. (Will be discussed in Inheritance)
• internal - accessible everywhere in the current module but not in the modules which import the module where it is defined.

Lets see the power of these visibility modifiers with the help of an example :

 // File BankAccount.kt -----------------------------

// Private class - accessible only in current file
private class BankAccount(
    val acHolderName: String,
    balance: Int,
    private var pin: String
) {
    var balance: Int 
    private set  // Private setter, value can be re-assigned only inside the class

    init {
        this.balance = balance
    }
    
    fun close() { TODO() }
    
    private fun depositInterest() { TODO() }
}

fun main() {
    val ac1 = BankAccount("A", 500, "7654")
    
    println(ac1.acHolderName)   // Accessible because its public
    
    println(ac1.pin)    // ERROR! pin is private
    ac1.balance = 5     // ERROR! setter is private
    
    ac1.close()     // Accessible because its public
    ac1.depositInterest()   // ERROR! function is private
}

// File BankAccountUtils.kt --------------------------

fun printStatement(
    account: BankAccount // ERROR! BankAccount is a private class
) {
    // Code...    
}