Object oriented programming is a programming paradigm that mainly focused on real life entities like human, car and abstract entity like course that taken by student. Object oriented programming usually involves an entity that represented as a class with attributes like name, age and behavior in entity like walk.

Create Class and Object

In object oriented programming, class is a blueprint that used to create an object. In Kotlin, a class can be created using this syntax.

class class_name(
    attributes,...
) {
    // behaviors...
}

This is the example of class creation. The class called Student is created to represents a student entity. This class is created in separated file Student.kt.

// create Student class with name and course as attribute
class Student(
    val name: String,
    val course: String
) {
    // create learn method
    fun learn() {
        println("learning $course")
    }
}

The Student class is used inside main() method.

fun main() {
    // create an object from Student class
    val student = Student("john doe","Algorithm")

    // call learn() method from the object
    student.learn()
}

Output

learning Algorithm

Based on the code above, a class called Student is created inside Student.kt file then the object from Student class is created by using constructor from Student class with the specified values for attributes. The learn() method can be called from the created object.

The best practice for class usage is to create a class in a separated file so the refactoring or maintenance for certain class can be done easily.

If the object is created from the class then the attribute value can be changed after the object is created. Use var keyword for certain attribute in a class.

// create Student class with name and course as attribute
class Student(
    var name: String,
    var course: String
) {
    // create learn method
    fun learn() {
        println("learning $course")
    }
}

The attribute value for course is changed.

fun main() {
    // create an object from Student class
    val student = Student("john doe","Algorithm")

    // the course value is changed
    student.course = "Algorithm with C++"

    // call learn() method from the object
    student.learn()
}

Output

learning Algorithm with C++

Create Data Class

In Kotlin, there is a specific class to create a particular object class or also known as POJO (Plain Old Java Object) by using data class. The POJO class is a class that contains particular methods including setter and getter.

This is the basic syntax to create data class.

data class class_name(
    attributes,...
)

This is the example of data class usage for course entity. This class is created in Course.kt file.

// create a data class called Course
data class Course(
    val code: String,
    val name: String
)

The object from Course class is created in main() method.

fun main() {
    // create an object from Course class
    val course = Course("C001","Data Structure")

    // print out the course data
    println("Course data")
    println("Course code: ${course.code}")
    println("Course name: ${course.name}")
}

Output

Course data
Course code: C001
Course name: Data Structure

Based on the code above, the object from Course class is created by using constructor from Course class that filled with specified values for the attributes.

If the object is created using data class, the attribute value from certain object can be retrieved with destructuring mechanism.

This is the example of destructuring mechanism.

fun main() {
    // create an object from Course class
    val course = Course("C001", "Kotlin Basics")

    // perform destructuring
    // retrieve value from attributes (code and name)
    val (code, name) = course

    // print out the value from code and name attribute
    println("Course data")
    println("Code: $code")
    println("Name: $name")
}

Output

Course data
Code: C001
Name: Kotlin Basics

toString() Method

The toString() method can be used to give the information of created object from certain class. This is the example of toString() method usage in Course class.

// create a data class called Course
data class Course(
    val code: String,
    val name: String
) {
    // using toString() method
    override fun toString(): String {
        return "Course(code='$code', name='$name')"
    }
}

The object from Course class is created in main() method.

fun main() {
    // create an object from Course class
    val course = Course("C001", "Kotlin Basics")

    // print out the object information
    println("Course data: $course")
}

Output

Course data: Course(code='C001', name='Kotlin Basics')

Based on the code above, the toString() method is called automatically if the course object is printed out.

Special Class in Kotlin (object)

In Kotlin there is a specific class for one time use called object. An object can be created directly in a variable or in a separated file.

This is the example of creating object directly in a variable.

fun main() {
    // create an "object" class in person variable
    val person = object {
        val name = "joe"
        val address = "palm city"

        fun greet() {
            println("Hi, my name is $name")
            println("I lived in $address")
        }
    }

    // object can be used directly
    // without creation or instantiation
    person.greet()
}

Output

Hi, my name is joe
I lived in palm city

Based on the code above, an object is created directly inside person variable. The object can be used directly without creation or instantiation of an object class.

In this example, the object class is created in separated file called Person.kt.

object Person {
    val name = "nathan mckane"
    val address = "rockford"

    fun greet() {
        println("Hi, my name is $name")
        println("I lived in $address")
    }

    fun say(message: String) {
        println("$name says $message")
    }
}

The object that already created is used in main() method.

fun main() {
    // using Person "object" in variable
    val person = Person
    person.greet()

    // the Person "object" can be used directly
    Person.say("hello!")
}

Output

Hi, my name is nathan mckane
I lived in rockford
nathan mckane says hello!

Based on the code above, an object called Person can be used inside variable or use the object directly.

The companion object can be used in a class if the method or attribute can be accessed directly without creating an object from certain class. In this example, the companion object is used in Calculator class.

class Calculator {
    // create companion object
    companion object {
        // these methods can be accessed directly
        // without creating an object from Calculator class
        fun sum(x: Int, y: Int): Int {
            return x + y
        }

        fun multiply(x: Int, y: Int): Int {
            return x * y
        }
    }
}

The Calculator class is used in main() method.

fun main() {
    // the sum and multiply method called directly
    // from Calculator class
    val sumResult: Int = Calculator.sum(4,5)
    val multiplyResult: Int = Calculator.multiply(5,6)

    println("Result from sum operation: $sumResult")
    println("Result from multiply operation: $multiplyResult")
}

Output

Result from sum operation: 9
Result from multiply operation: 30

Based on the code above, the sum() and multiply() method can be accessed directly from Calculator class because these methods are created inside companion object.

Generic

The generic concept is also available in Kotlin. Generic is a mechanism when a data type acts as parameter in a class. Generic can be used to define which data type is used in certain class rather than make some classes for many data types.

This is the example of generic usage in Kotlin.

class Box<T>(val content: T)

Create an object from Box class that use generic.

fun main() {
    val stringBox: Box<String> = Box("cool!")
    val intBox: Box<Int> = Box(24)

    println("Content from stringBox: ${stringBox.content}")
    println("Content from intBox: ${intBox.content}")
}

Output

Content from stringBox: cool!
Content from intBox: 24

Based on the code above, the generic is used inside angle brackets <> with T notation for generic type.

Enum

Enum is a class that contains many constants. This is the basic syntax to create an enum.

enum class enum_name {
    VALUE1, VALUE2, ...
}

In this example, an enum is created called Role.

enum class Role {
    STUDENT, LECTURER, ADMIN
}

The value from Role enum is used inside Student class.

// create Student class
class Student(
    val name: String,
    val course: String,
    // using value from Role enum
    val role: Role = Role.STUDENT,
) {
    fun learn() {
        println("Learning $course")
    }

}

Based on the code above, the value from Role enum is used inside an attribute with Role data type.

Notes

• Class is a blueprint for an object.

• Data class is suitable to create a particular object that contains setter and getter method.

• The object class can be used only once.

• Enum is suitable to store many constants

Sources

• Learn more about class in this link.

• Learn more about data class in this link.

• Learn more about object in this link.

• Learn more about generic in Kotlin in this link.

• Learn more about enum in this link.

I hope this article is helpful for learning the Kotlin programming language. If you have any thoughts or comments you can write in the discussion section below.