In this article, you will learn about operator overloading (define how operator works for user defined types like objects) with the help of examples.
When you use operator in Kotlin, it’s corresponding member function is called. For example, expression a+b transforms to a.plus(b) under the hood.
fun main(args: Array<String>) {
val a = 5
val b = 10
print(a.plus(b)) // print(a+b)
}
When you run the program, the output will be:
15
In fact, plus() function is overloaded to work with various Kotlin basic types and String.
// + operator for basic types
operator fun plus(other: Byte): Int
operator fun plus(other: Short): Int
operator fun plus(other: Int): Int
operator fun plus(other: Long): Long
operator fun plus(other: Float): Float
operator fun plus(other: Double): Double
// for string concatenation
operator fun String?.plus(other: Any?): String
You can also define how operator works for objects by overloading its corresponding function. For example, you need define how + operator works for objects by overloading plus() function.
Example: Overloading + Operator
fun main(args: Array<String>) {
val p1 = Point(3, -8)
val p2 = Point(2, 9)
var sum = Point()
sum = p1 + p2
println("sum = (${sum.x}, ${sum.y})")
}
class Point(val x: Int = 0, val y: Int = 10) {
// overloading plus function
operator fun plus(p: Point) : Point {
return Point(x + p.x, y + p.y)
}
}
When you run the program, the output will be:
sum = (5, 1)
Here, the plus() function is marked with operator keyword to tell compiler that + operator is being overloaded.
The expression p1 + p2 is transformed to p1.plus(p2) under the hood.
Example: — Operator Overloading
In this example, you will learn to overload -- operator. The expression --a is transformed to a.dec() under the hood.
The dec() member function doesn’t take any arguments.
fun main(args: Array<String>) {
var point = Point(3, -8)
--point
println("point = (${point.x}, ${point.y})")
}
class Point(var x: Int = 0, var y: Int = 10) {
operator fun dec() = Point(--x, --y)
}
When you run the program, the ouput will be:
point = (2, -9)
Remember that,
operator fun dec() = Point(--x, --y)
is equivalent to
operator fun dec(): Point {
return Point(--x, --y)
}
Few Important Points
1. When you overload operators, you should try to maintain the original spirit of the operator. For example,
fun main(args: Array<String>) {
val p1 = Point(3, -8)
val p2 = Point(2, 9)
var sum = Point()
sum = p1 + p2
println("sum = (${sum.x}, ${sum.y})")
}
class Point(val x: Int = 0, val y: Int = 10) {
// overloading plus function
operator fun plus(p: Point) = Point(x - p.x, y - p.y)
}
Although the program above is technically correct, we have used + operator to subtract corresponding properties of two objects which made the program confusing.
2. Unlike languages like Scala, only a specific set of operators can be overloaded in Kotlin. Visit the page to learn about operators that can be overloaded in Kotlin and their corresponding member functions.
In this article, you will learn to extend a class with new functionality using extension functions.
Suppose, you need to extend a class with new functionality. In most programming languages, you either derive a new class or use some kind of design pattern to do this.
However, in Koltin, you can also use extension function to extend a class with new functionality. Basically, an extension function is a member function of a class that is defined outside the class.
For example, you need to use a method to the String class that returns a new string with first and last character removed; this method is not already available in String class. You can use extension function to accomplish this task.
Example: Remove First and Last Character of String
fun String.removeFirstLastChar(): String = this.substring(1, this.length - 1)
fun main(args: Array<String>) {
val myString= "Hello Everyone"
val result = myString.removeFirstLastChar()
println("First character is: $result")
}
When you run the program, the output will be:
First character is: ello Everyon
Here, an extension function removeFirstLastChar() is added to the String class.
The class name is the receiver type (String class in our example). The this keyword inside the extension function refers the receiver object.
If you need to integrate Kotlin on the top of Java project, you do not need to modify the whole code to Koltin. Just use extension functions to add functionalities.
In this article, you will learn to create data classes in Kotlin. You will also learn about requirements that data class must fulfill, and their standard functionalities.
There may arise a situation where you need to create a class solely to hold data. In such cases, you can mark the class as data to create a data class. For example,
data class Person(val name: String, var age: Int)
For this class, the compiler automatically generates:
copy() function, equals() and hashCode() pair, and toString() form of the primary constructor
componentN() functions
Before talking about these features in detail, let’s talk about requirements that a data class must fulfill.
Kotlin Data Class Requirements
Here are the requirements:
The primary constructor must have at least one parameter.
The parameters of the primary constructor must be marked as either val (read-only) or var (read-write).
The class cannot be open, abstract, inner or sealed.
The class may extend other classes or implement interfaces. If you are using Kotlin version before 1.1, the class can only implement interfaces.
Example: Kotlin Data Class
data class User(val name: String, val age: Int)
fun main(args: Array<String>) {
val jack = User("jack", 29)
println("name = ${jack.name}")
println("age = ${jack.age}")
}
When you run the program, the output will be:
name = jack
age = 29
When you declare a data class, the compiler automatically generates several functions such as toString(), equals(), hashcode() etc behind the scenes. This helps to keep you code concise. Had you used Java, you would need to write a lot of boilerplate code.
Let’s use these functions:
Copying
For a data class, you can create a copy of an object with some of its properties different using copy() function. Here’s how it works:
data class User(val name: String, val age: Int)
fun main(args: Array<String>) {
val u1 = User("John", 29)
// using copy function to create an object
val u2 = u1.copy(name = "Randy")
println("u1: name = ${u1.name}, name = ${u1.age}")
println("u2: name = ${u2.name}, name = ${u2.age}")
}
When you run the program, the output will be:
u1: name = John, name = 29
u2: name = Randy, name = 29
toString() method
The toString() function returns a string representation of the object.
data class User(val name: String, val age: Int)
fun main(args: Array<String>) {
val u1 = User("John", 29)
println(u1.toString())
}
When you run the program, the output will be:
User(name=John, age=29)
hashCode() and equals()
The hasCode() method returns hash code for the object. If two objects are equal, hashCode() produces the same integer result.
The equals() returns true if two objects are equal (has same hashCode()). If objects are not equal, equals() returns false.
data class User(val name: String, val age: Int)
fun main(args: Array<String>) {
val u1 = User("John", 29)
val u2 = u1.copy()
val u3 = u1.copy(name = "Amanda")
println("u1 hashcode = ${u1.hashCode()}")
println("u2 hashcode = ${u2.hashCode()}")
println("u3 hashcode = ${u3.hashCode()}")
if (u1.equals(u2) == true)
println("u1 is equal to u2.")
else
println("u1 is not equal to u2.")
if (u1.equals(u3) == true)
println("u1 is equal to u3.")
else
println("u1 is not equal to u3.")
}
When you run the program, the output will be:
u1 hashcode = 71750738
u2 hashcode = 71750738
u3 hashcode = 771732263
u1 is equal to u2.
u1 is not equal to u3.
Destructuring Declarations
You can destructure an object into a number of variables using destructing declaration. For example:
data class User(val name: String, val age: Int, val gender: String)
fun main(args: Array<String>) {
val u1 = User("John", 29, "Male")
val (name, age, gender) = u1
println("name = $name")
println("age = $age")
println("gender = $gender")
}
When you run the program, the output will be:
name = John
age = 29
gender = Male
This was possible because the compiler generates componentN() functions all properties for a data class. For example:
data class User(val name: String, val age: Int, val gender: String)
fun main(args: Array<String>) {
val u1 = User("John", 29, "Male")
println(u1.component1()) // John
println(u1.component2()) // 29
println(u1.component3()) // "Male"
}
In this article, you will learn to work with nested and inner classes with the help of examples.
Kotlin Nested Class
Similar like Java, Kotlin allows you to define a class within another class known as nested class.
class Outer {
... .. ...
class Nested {
... .. ...
}
}
Since Nested class is a member of its enclosing class Outer, you can use . notation to access Nested class and its members.
Example: Kotlin Nested Class
class Outer {
val a = "Outside Nested class."
class Nested {
val b = "Inside Nested class."
fun callMe() = "Function call from inside Nested class."
}
}
fun main(args: Array<String>) {
// accessing member of Nested class
println(Outer.Nested().b)
// creating object of Nested class
val nested = Outer.Nested()
println(nested.callMe())
}
When you run the program, the output will be:
Inside Nested class.
Function call from inside Nested class.
For Java Users
The nested class in Kotlin is similar to static nested class in Java.
In Java, when you declare a class inside another class, it becomes an inner class by default. However in Kotlin, you need to use inner modifier to create an inner class which we will discuss next.
Kotlin Inner Class
The nested classes in Kotlin do not have access to the outer class instance. For example,
class Outer {
val foo = "Outside Nested class."
class Nested {
// Error! cannot access member of outer class.
fun callMe() = foo
}
}
fun main(args: Array<String>) {
val outer = Outer()
println(outer.Nested().callMe())
}
The above code won’t compile because we tried to access foo property of Outer class from inside Nested class.
In order to solve this issue, you need to mark the nested class with inner to create an inner class. Inner classes carry a reference to an outer class, and can access outer class members.
Example: Kotlin Inner Class
class Outer {
val a = "Outside Nested class."
inner class Inner {
fun callMe() = a
}
}
fun main(args: Array<String>) {
val outer = Outer()
println("Using outer object: ${outer.Inner().callMe()}")
val inner = Outer().Inner()
println("Using inner object: ${inner.callMe()}")
}
When you run the program, the output will be:
Using outer object: Outside Nested class.
Using inner object: Outside Nested class.
In this article, you will learn about interfaces and how to implement it in Kotlin with the help of examples.
Kotlin interfaces are similar to interfaces in Java 8. They can contain definitions of abstract methods as well as implementations of non-abstract methods. However, they cannot contain any state.
Meaning, interface may have property but it needs to be abstract or has to provide accessor implementations.
Abstract classes in Kotlin are similar to interface with one important difference. It’s not mandatory for properties of an abstract class to be abstract or provide accessor implementations.
How to define an interface?
Keyword interface is used to define interfaces in Kotlin. For example,
interface MyInterface {
var test: String // abstract property
fun foo() // abstract method
fun hello() = "Hello there" // method with default implementation
}
Here,
an interface MyInterface is created.
the interface has an abstract property test and an abstract method foo().
the interface also has a non-abstract method hello().
How to implement interface?
Here’s how a class or object can implement the interface:
interface MyInterface {
val test: Int // abstract property
fun foo() : String // abstract method (returns String)
fun hello() { // method with default implementation
// body (optional)
}
}
class InterfaceImp : MyInterface {
override val test: Int = 25
override fun foo() = "Lol"
// other code
}
Here, a class InterfaceImp implements the MyInterface interface.
The class overrides abstract members (test property and foo() method) of the interface.
Example: How interface works?
interface MyInterface {
val test: Int
fun foo() : String
fun hello() {
println("Hello there, pal!")
}
}
class InterfaceImp : MyInterface {
override val test: Int = 25
override fun foo() = "Lol"
}
fun main(args: Array<String>) {
val obj = InterfaceImp()
println("test = ${obj.test}")
print("Calling hello(): ")
obj.hello()
print("Calling and printing foo(): ")
println(obj.foo())
}
When you run the program, the output will be:
test = 25
Calling hello(): Hello there, pal!
Calling and printing foo(): Lol
As mentioned above, an interface may also have a property that provide accessor implementation. For example,
interface MyInterface {
// property with implementation
val prop: Int
get() = 23
}
class InterfaceImp : MyInterface {
// class body
}
fun main(args: Array<String>) {
val obj = InterfaceImp()
println(obj.prop)
}
When you run the program, the output will be:
23
Here, prop is not abstract. However, it’s valid inside the interface because it provides implementation for accessor.
However, you cannot do something like val prop: Int = 23 inside the interface.
Implementing Two or More Interfaces in a Class
Kotlin does not allow true multiple inheritance. However, it’s possible to implement two or more interfaces in a single class. For example,
interface A {
fun callMe() {
println("From interface A")
}
}
interface B {
fun callMeToo() {
println("From interface B")
}
}
// implements two interfaces A and B
class Child: A, B
fun main(args: Array<String>) {
val obj = Child()
obj.callMe()
obj.callMeToo()
}
Suppose, two interfaces(A and B) have a non-abstract method with the same name (let’s say callMe() method). You implemented these two interfaces in a class (let’s say C). Now, if you call the callMe() method using the object of class C, compiler will throw error. For example,
interface A {
fun callMe() {
println("From interface A")
}
}
interface B {
fun callMe() {
println("From interface B")
}
}
class Child: A, B
fun main(args: Array<String>) {
val obj = Child()
obj.callMe()
}
Here’s the error:
Error:(14, 1) Kotlin: Class 'C' must override public open fun callMe(): Unit defined in A because it inherits multiple interface methods of it
To solve this issue, you need to provide your own implementation. Here’s how:
interface A {
fun callMe() {
println("From interface A")
}
}
interface B {
fun callMe() {
println("From interface B")
}
}
class C: A, B {
override fun callMe() {
super<A>.callMe()
super<B>.callMe()
}
}
fun main(args: Array<String>) {
val obj = C()
obj.callMe()
}
Now when you run the program, the output will be:
From interface A
From interface B
Here, explicit implementation of callMe() method is provided in class C.
class C: A, B {
override fun callMe() {
super<A>.callMe()
super<B>.callMe()
}
}
The statement super<A>.callMe() calls the callMe() method of class A. Similarly, super<B>.callMe() calls the callMe() method of class B.
In this article, you will learn about abstract class and how to implement it in Kotlin (with the help of examples).
Like Java, abstract keyword is used to declare abstract classes in Kotlin. An abstract class cannot be instantiated (you cannot create objects of an abstract class). However, you can inherit subclasses from can them.
The members (properties and methods) of an abstract class are non-abstract unless you explictly use abstract keyword to make them abstract. Let’s take an example:
abstract class Person {
var age: Int = 40
fun displaySSN(ssn: Int) {
println("My SSN is $ssn.")
}
abstract fun displayJob(description: String)
}
Here,
an abstract class Person is created. You cannot create objects of the class.
the class has a non-abstract property age and a non-abstract method displaySSN(). If you need to override these members in the subclass, they should be marked with open keyword.
The class has an abstract method displayJob(). It doesn’t have any implementation and must be overridden in its subclasses.
Note: Abstract classes are always open. You do not need to explicitly use open keyword to inherit subclasses from them.
Example: Kotlin Abstract Class and Method
abstract class Person(name: String) {
init {
println("My name is $name.")
}
fun displaySSN(ssn: Int) {
println("My SSN is $ssn.")
}
abstract fun displayJob(description: String)
}
class Teacher(name: String): Person(name) {
override fun displayJob(description: String) {
println(description)
}
}
fun main(args: Array<String>) {
val jack = Teacher("Jack Smith")
jack.displayJob("I'm a mathematics teacher.")
jack.displaySSN(23123)
}
When you run the program, the output will be:
My name is Jack Smith.
I'm a mathematics teacher.
My SSN is 23123.
Here, a class Teacher is derived from an abstract class Person.
An object jack of Teacher class is instantiated. We have passed "Jack Smith" as a parameter to the primary constructor while creating it. This executes the initializer block of the Person class.
Then, displayJob() method is called using jack object. Note, that the displayJob() method is declared abstract in the base class, and overridden in the derived class.
Finally, displaySSN() method is called using jack object. The method is non-abstract and declared in Person class (and not declared in Teacher class).
Kotlin interfaces are similar to abstract classes. However, interfaces cannot store state whereas abstract classes can.
Meaning, interface may have property but it needs to be abstract or has to provide accessor implementations. Whereas, it’s not mandatory for property of an abstract class to be abstract.
In this article, you will learn about all 4 visibility modifiers in Kotlin and how they work in different scenarios.
Visibility modifiers are keywords that set the visibility (accessibility) of classes, objects, interface, constructors, functions, properties and their setters. (You cannot set visibility modifier of getters as they always take the same visibility as that of the property.)
In Kotlin Class and Objects article, you learned about visibility modifiers public and private in brief. You will learn about two more visibility modifiers protected and internal (as well as public and private) in detail.
Visibility Modifiers Inside Package
A package organizes a set of related functions, properties and classes, objects, and interfaces. Recommended reading:Kotlin Packages
Modifier
Description
public
declarations are visible everywhere
private
visible inside the file containing the declaration
internal
visible inside the same module (a set of Kotlin files compiled together)
protected
not available for packages (used for subclasses)
Note: If visibility modifier is not specified, it is public by default.
Let’s take an example:
// file name: hello.kt
package test
fun function1() {} // public by default and visible everywhere
private fun function2() {} // visible inside hello.kt
internal fun function3() {} // visible inside the same module
var name = "Foo" // visible everywhere
get() = field // visible inside hello.kt (same as its property)
private set(value) { // visible inside hello.kt
field = value
}
private class class1 {} // visible inside hello.kt
Visibility Modifiers Inside Classes and Interfaces
Here’s how visibility modifiers works for members (functions, properties) declared inside a class:
Modifier
Description
public
visible to any client who can see the declaring class
private
visible inside the class only
protected
visible inside the class and its subclasses
internal
visible to any client inside the module that can see the declaring class
Note: If you override a protected member in the derived class without specifying its visibility, its visibility will also be protected.
Let’s take an example:
open class Base() {
var a = 1 // public by default
private var b = 2 // private to Base class
protected open val c = 3 // visible to the Base and the Derived class
internal val d = 4 // visible inside the same module
protected fun e() { } // visible to the Base and the Derived class
}
class Derived: Base() {
// a, c, d, and e() of the Base class are visible
// b is not visible
override val c = 9 // c is protected
}
fun main(args: Array<String>) {
val base = Base()
// base.a and base.d are visible
// base.b, base.c and base.e() are not visible
val derived = Derived()
// derived.c is not visible
}
Changing Visibility of a Constructor
By default, the visibility of a constructor is public. However, you can change it. For that, you need to explicitly add constructor keyword.
The constructor is public by default in the example below:
class Test(val a: Int) {
// code
}
Here’s how you can change its visibility.
class Test private constructor(val a: Int) {
// code
}
Inheritance is one of the key features of object-oriented programming. It allows user to create a new class (derived class) from an existing class (base class).
The derived class inherits all the features from the base class and can have additional features of its own.
Before going into details about Kotlin inheritance, we recommend you to check these two articles:
Kotlin Class and Objects
Kotlin Primary Constructor
Why inheritance?
Suppose, in your application, you want three characters – a math teacher, a footballer and a businessman.
Since, all of the characters are persons, they can walk and talk. However, they also have some special skills. A math teacher can teach math, a footballer can play football and a businessman can run a business.
You can individually create three classes who can walk, talk and perform their special skill.
In each of the classes, you would be copying the same code for walk and talk for each character.
If you want to add a new feature – eat, you need to implement the same code for each character. This can easily become error prone (when copying) and duplicate codes.
It would be a lot easier if we had a Person class with basic features like talk, walk, eat, sleep, and add special skills to those features as per our characters. This is done using inheritance.
Using inheritance, now you don’t implement the same code for walk(), talk() and eat() for each class. You just need to inherit them.
So, for MathTeacher (derived class), you inherit all features of a Person (base class) and add a new feature teachMath(). Likewise, for the Footballer class, you inherit all the features of the Person class and add a new feature playFootball() and so on.
This makes your code cleaner, understandable and extendable.
It is important to remember: When working with inheritance, each derived class should satisfy the condition whether it “is a” base class or not. In the example above, MathTeacheris aPerson, Footballeris aPerson. You cannot have something like, Businessmanis aBusiness.
Kotlin inheritance
Let’s try to implement the above discussion in code:
open class Person(age: Int) {
// code for eating, talking, walking
}
class MathTeacher(age: Int): Person(age) {
// other features of math teacher
}
class Footballer(age: Int): Person(age) {
// other features of footballer
}
class Businessman(age: Int): Person(age) {
// other features of businessman
}
Here, Person is a base class, and classes MathTeacher, Footballer, and Businessman are derived from the Person class.
Notice, the keyword open before the base class, Person. It’s important.
By default, classes in Kotlin are final. If you are familiar with Java, you know that a final class cannot be subclassed. By using the open annotation on a class, compiler allows you to derive new classes from it.
Example: Kotlin Inheritance
open class Person(age: Int, name: String) {
init {
println("My name is $name.")
println("My age is $age")
}
}
class MathTeacher(age: Int, name: String): Person(age, name) {
fun teachMaths() {
println("I teach in primary school.")
}
}
class Footballer(age: Int, name: String): Person(age, name) {
fun playFootball() {
println("I play for LA Galaxy.")
}
}
fun main(args: Array<String>) {
val t1 = MathTeacher(25, "Jack")
t1.teachMaths()
println()
val f1 = Footballer(29, "Christiano")
f1.playFootball()
}
When you run the program, the output will be:
My name is Jack.
My age is 25
I teach in primary school.
My name is Cristiano.
My age is 29
I play for LA Galaxy.
Here, two classes MathTeacher and Footballer are derived from the Person class.
The primary constructor of the Person class declared two properties: age and name, and it has an initializer block. The initilizer block (and member functions) of the base class Person can be accessed by the objects of derived classes (MathTeacher and Footballer).
Derived classes MathTeacher and Footballer have their own member functions teachMaths() and playFootball() respectively. These functions are accessible only from the objects of their respective class.
When the object t1 of MathTeacher class is created,
val t1 = MathTeacher(25, "Jack")
The parameters are passed to the primary constructor. In Kotlin, init block is called when the object is created. Since, MathTeacher is derived from Person class, it looks for initializer block in the base class (Person) and executes it. If the MathTeacher had init block, the compiler would have also executed the init block of the derived class.
Next, the teachMaths() function for object t1 is called using t1.teachMaths() statement.
The program works similarly when object f1 of Footballer class is created. It executes the init block of the base class. Then, the playFootball() method of Footballer class is called using statement f1.playFootball().
Important Notes: Kotlin Inheritance
If the class has a primary constructor, the base must be initialized using the parameters of the primary constructor. In the above program, both derived classes have two parameters age and name, and both these parameters are initialized in primary constructor in the base class.
Here’s another example:open class Person(age: Int, name: String) { // some code } class Footballer(age: Int, name: String, club: String): Person(age, name) { init { println("Football player $name of age $age and plays for $club.") } fun playFootball() { println("I am playing football.") } } fun main(args: Array<String>) { val f1 = Footballer(29, "Cristiano", "LA Galaxy") } Here the primary constructor of the derived class has 3 parameters, and the base class has 2 parameters. Note that, both parameters of the base class are initialized.
In case of no primary constructor, each base class has to initialize the base (using super keyword), or delegate to another constructor which does that. For example,fun main(args: Array<String>) { val p1 = AuthLog("Bad Password") } open class Log { var data: String = "" var numberOfData = 0 constructor(_data: String) { } constructor(_data: String, _numberOfData: Int) { data = _data numberOfData = _numberOfData println("$data: $numberOfData times") } } class AuthLog: Log { constructor(_data: String): this("From AuthLog -> + $_data", 10) { } constructor(_data: String, _numberOfData: Int): super(_data, _numberOfData) { } }To learn more on how this program works, visit Kotlin Secondary Constructor.
Overriding Member Functions and Properties
If the base class and the derived class contains a member function (or property) with the same name, you can need to override the member function of the derived class using override keyword, and use open keyword for the member function of the base class.
Example: Overriding Member Function
// Empty primary constructor
open class Person() {
open fun displayAge(age: Int) {
println("My age is $age.")
}
}
class Girl: Person() {
override fun displayAge(age: Int) {
println("My fake age is ${age - 5}.")
}
}
fun main(args: Array<String>) {
val girl = Girl()
girl.displayAge(31)
}
When you run the program, the output will be:
My fake age is 26.
Here, girl.displayAge(31) calls the displayAge() method of the derived class Girl.
You can override property of the base class in similar way.
Visit how Kotlin getters and setters work in Kotlin before you check the example below.
// Empty primary constructor
open class Person() {
open var age: Int = 0
get() = field
set(value) {
field = value
}
}
class Girl: Person() {
override var age: Int = 0
get() = field
set(value) {
field = value - 5
}
}
fun main(args: Array<String>) {
val girl = Girl()
girl.age = 31
println("My fake age is ${girl.age}.")
}
When you run the program, the output will be:
My fake age is 26.
As you can see, we have used override and open keywords for age property in derived class and base class respectively.
Calling Members of Base Class from Derived Class
You can call functions (and access properties) of the base class from a derived class using super keyword. Here’s how:
open class Person() {
open fun displayAge(age: Int) {
println("My actual age is $age.")
}
}
class Girl: Person() {
override fun displayAge(age: Int) {
// calling function of base class
super.displayAge(age)
println("My fake age is ${age - 5}.")
}
}
fun main(args: Array<String>) {
val girl = Girl()
girl.displayAge(31)
}
In this article, you will learn to use getters and setters in Kotlin with the help of an example.
Before you learn about getters and setter, be sure to check Kotlin class and objects.
In programming, getters are used for getting value of the property. Similarly, setters are used for setting value of the property.
In Kotlin, getters and setters are optional and are auto-generated if you do not create them in your program.
How getters and setters work?
The following code in Kotlin
class Person {
var name: String = "defaultValue"
}
is equivalent to
class Person {
var name: String = "defaultValue"
// getter
get() = field
// setter
set(value) {
field = value
}
}
When you instantiate object of the Person class and initialize the name property, it is passed to the setters parameter value and sets field to value.
val p = Person()
p.name = "jack"
Now, when you access name property of the object, you will get field because of the code get() = field.
println("${p.name}")
Here’s an working example:
fun main(args: Array<String>) {
val p = Person()
p.name = "jack"
println("${p.name}")
}
class Person {
var name: String = "defaultValue"
get() = field
set(value) {
field = value
}
}
When you run the program, the output will be:
jack
This is how getters and setters work by default. However, you can change value of the property (modify value) using getters and setters.
Example: Changing value of the property
fun main(args: Array<String>) {
val maria = Girl()
maria.actualAge = 15
maria.age = 15
println("Maria: actual age = ${maria.actualAge}")
println("Maria: pretended age = ${maria.age}")
val angela = Girl()
angela.actualAge = 35
angela.age = 35
println("Angela: actual age = ${angela.actualAge}")
println("Angela: pretended age = ${angela.age}")
}
class Girl {
var age: Int = 0
get() = field
set(value) {
field = if (value < 18)
18
else if (value >= 18 && value <= 30)
value
else
value-3
}
var actualAge: Int = 0
}
When you run the program, the output will be:
Maria: actual age = 15
Maria: pretended age = 18
Angela: actual age = 35
Angela: pretended age = 32
Here, the actualAge property works as expected.
However, there is additional logic is setters to modify value of the age property.
In this article, you will learn about constructors in Kotlin (both primary and secondary constructors) as well as initializer blocks with the help of examples.
A constructor is a concise way to initialize class properties.
It is a special member function that is called when an object is instantiated (created). However, how they work in Kotlin is slightly different.
In Kotlin, there are two constructors:
Primary constructor – concise way to initialize a class
Secondary constructor – allows you to put additional initialization logic
Primary Constructor
The primary constructor is part of the class header. Here’s an example:
class Person(val firstName: String, var age: Int) {
// class body
}
The block of code surrounded by parentheses is the primary constructor: (val firstName: String, var age: Int).
The constructor declared two properties: firstName (read-only property as it’s declared using keyword val) and age (read-write property as it is declared with keyword var).
Example: Primary Constructor
fun main(args: Array<String>) {
val person1 = Person("Joe", 25)
println("First Name = ${person1.firstName}")
println("Age = ${person1.age}")
}
class Person(val firstName: String, var age: Int) {
}
When you run the program, the output will be:
First Name = Joe
Age = 25
When the object of Person class is created, "Joe" and 25 values are passed as if Person is a function.
This initializes firstName and age properties of person1 object to "Joe" and 25 respectively.
There are other ways of using primary constructors.
Primary Constructor and Initializer Blocks
The primary constructor has a constrained syntax, and cannot contain any code.
To put the initilization code (not only code to initialize properties), initializer block is used. It is prefixed with init keyword. Let’s modify the above example with initializer block:
fun main(args: Array<String>) {
val person1 = Person("joe", 25)
}
class Person(fName: String, personAge: Int) {
val firstName: String
var age: Int
// initializer block
init {
firstName = fName.capitalize()
age = personAge
println("First Name = $firstName")
println("Age = $age")
}
}
When you run the program, the output will be:
First Name = Joe
Age = 25
Here, parameters fName and personAge inside the parenthesis accepts values "Joe" and 25 respectively when person1 object is created. However, fName and personAge are used without using var or val, and are not properties of the Person class.
The Person class has two properties firstName, and age are declared.
When person1 object is created, code inside initializer block is executed. The initializer block not only initializes its properties but also prints them.
Here is another way to perform the same task:
fun main(args: Array<String>) {
val person1 = Person("joe", 25)
}
class Person(fName: String, personAge: Int) {
val firstName = fName.capitalize()
var age = personAge
// initializer block
init {
println("First Name = $firstName")
println("Age = $age")
}
}
To distinguish the constructor parameter and property, different names are used (fName and firstName, and personAge and age). It’s more common to use _firstName and _age instead of completely different name for constructor parameters. For example:
class Person(_firstName: String, _age: Int) {
val firstName = _firstName.capitalize()
var age = _age
// initializer block
init {
... .. ...
}
}
Default Value in Primary Constructor
You can provide default value to constructor parameters (similar to providing default arguments to functions). For example:
fun main(args: Array<String>) {
println("person1 is instantiated")
val person1 = Person("joe", 25)
println("person2 is instantiated")
val person2 = Person("Jack")
println("person3 is instantiated")
val person3 = Person()
}
class Person(_firstName: String = "UNKNOWN", _age: Int = 0) {
val firstName = _firstName.capitalize()
var age = _age
// initializer block
init {
println("First Name = $firstName")
println("Age = $age\n")
}
}
When you run the program, the output will be:
First Name = Joe
Age = 25
person2 is instantiated
First Name = Jack
Age = 0
person3 is instantiated
First Name = UNKNOWN
Age = 0
Kotlin Secondary Constructor
In Kotlin, a class can also contain one or more secondary constructors. They are created using constructor keyword.
Secondary constructors are not that common in Kotlin. The most common use of secondary constructor comes up when you need to extend a class that provides multiple constructors that initialize the class in different ways. Be sure to check Kotlin Inheritance before you learn it.
Here’s how you can create a secondary constructor in Kotlin:
class Log {
constructor(data: String) {
// some code
}
constructor(data: String, numberOfData: Int) {
// some code
}
}
Here, the Log class has two secondary constructors, but no primary constructor.
fun main(args: Array<String>) {
val p1 = AuthLog("Bad Password")
}
open class Log {
var data: String = ""
var numberOfData = 0
constructor(_data: String) {
}
constructor(_data: String, _numberOfData: Int) {
data = _data
numberOfData = _numberOfData
println("$data: $numberOfData times")
}
}
class AuthLog: Log {
constructor(_data: String): this("From AuthLog -> " + _data, 10) {
}
constructor(_data: String, _numberOfData: Int): super(_data, _numberOfData) {
}
}
When you run the program, the output will be:
From AuthLog -> Bad Password: 10 times
Note: The secondary constructor must initialize the base class or delegate to another constructor (like in above example) if the class has no primary constructor.
learngram.wordpress.com 