Kotlin Operator Overloading

Operator overloading are special concept to provides new meaning to existing operator without lose the operator original behaviour. that is normally exist in all modern programming language. kotlin programming also support this features.

Kotlin : Example Assignments Operator Overloading

In this section given example how to overload Assignment operators in kotlin programming. there is five function are available to overload (+=,-=,*=,/=,%=) this operators.

for example assume that there is two different objects objA and objB are same properties that is x (integer data type).

Overload += operators

class Assignments(var x:Int){
    //definition of assignment operator overload
    operator fun plusAssign(other:Assignments):Unit{ x+=other.x}
}
fun main(args: Array<String>){
    //make two object
    var objA=Assignments(3)
    var objB=Assignments(9)
    
    println("Before objA.x = ${objA.x}  objB.x = ${objB.x}")
    
    objA+=objB //add and assign

    println("After  objA.x = ${objA.x} objB.x = ${objB.x}")
    
    println("Alternatives")
    var objC=Assignments(3)
    var objD=Assignments(9)
    println("Before objC.x = ${objC.x}  objD.x = ${objD.x}")
    objC.plusAssign(objD) //add and assign
    println("After  objC.x = ${objC.x} objD.x = ${objD.x}")
   
    
}

Output

Before objA.x = 3  objB.x = 9
After  objA.x = 12 objB.x = 9
Alternatives
Before objC.x = 3  objD.x = 9
After  objC.x = 12 objD.x = 9

Overload -= operators

class Assignments(var x:Int){
    //definition of assignment operator overload
    operator fun minusAssign(other:Assignments){ x-=other.x}
}
fun main(args: Array<String>){
    //make two object
    var objA=Assignments(8)
    var objB=Assignments(5)
    
    println("Before objA.x = ${objA.x}  objB.x = ${objB.x}")
    
    objA-=objB //Subtract and assign

    println("After  objA.x = ${objA.x}  objB.x = ${objB.x}")
    
    println("Alternatives")
    var objC=Assignments(8)
    var objD=Assignments(5)
    println("Before objC.x = ${objC.x}  objD.x = ${objD.x}")
    objC.minusAssign(objD) //Subtract and assign
    println("After  objC.x = ${objC.x}  objD.x = ${objD.x}")
   
    
}

Output

Before objA.x = 8  objB.x = 5
After  objA.x = 3  objB.x = 5
Alternatives
Before objC.x = 8  objD.x = 5
After  objC.x = 3  objD.x = 5

That Similar concept overload of other assignments operators. See this examples.

class Assignments(var x:Int){
    //definition of assignment operator overload
    operator fun plusAssign(other:Assignments):Unit{ x+=other.x}
    operator fun minusAssign(other:Assignments):Unit{ x-=other.x}
    operator fun timesAssign(other:Assignments):Unit{ x*=other.x}
    operator fun divAssign(other:Assignments):Unit{ x/=other.x}
    operator fun remAssign(other:Assignments):Unit{ x%=other.x}
    
    fun before(operation:String =" " ,other:Assignments){
        println("\nBefore $operation $x   ${other.x} ")
    }
    fun after(operation:String =" " ,other:Assignments){
        println(" After $operation $x   ${other.x} ")
    }
 
}
fun main(args: Array<String>){
    //make two object
    var objA=Assignments(3)
    var objB=Assignments(9)
    
    objA.before("[objA+=objB] = ",objB)
    
    objA+=objB //add and assign
    
    objA.after("[objA+=objB] = ",objB)
    
    
    var objC=Assignments(2)
    var objD=Assignments(5)
    
    objC.before("[objC-=objD] = ",objD)
    
    objC-=objD //minus and assign
    
    objC.after("[objC-=objD] = ",objD)
    
    var objE=Assignments(6)
    var objF=Assignments(3)
    
    objE.before("[objE*=objF] = ",objF)
    
    objE*=objF //times and assign
    
    objE.after("[objE*=objF] = ",objF)
    
    
    var objG=Assignments(8)
    var objH=Assignments(2)
    
    objG.before("[objG/=objH] = ",objH)
    
    objG/=objH //div and assign
    
    objG.after("[objG/=objH] = ",objH)
    
    
    var objI=Assignments(6)
    var objJ=Assignments(4)
    
    objI.before("[objI/=objJ] = ",objJ)
    
    objI%=objJ //% and assign
    
    objI.after("[objI/=objJ] = ",objI)
    
    
    
}

Output

Before [objA+=objB] =  3   9 
 After [objA+=objB] =  12   9 

Before [objC-=objD] =  2   5 
 After [objC-=objD] =  -3   5 

Before [objE*=objF] =  6   3 
 After [objE*=objF] =  18   3 

Before [objG/=objH] =  8   2 
 After [objG/=objH] =  4   2 

Before [objI/=objJ] =  6   4 
 After [objI/=objJ] =  2   2 

Example --,++ Operator Overloading

class Modifier(var x:Int){

    operator fun inc()=Modifier(++x)
    operator fun dec()=Modifier(--x)
}
fun main(args: Array<String>){
    //make two object
    var obj1=Modifier(10)
    var obj2=Modifier(10)
    
    println(" Initial (obj1,obj2): ${obj1.x} ${obj2.x}")
    ++obj1
    --obj2
    println(" After (++obj1,--obj2) : ${obj1.x} ${obj2.x}")
    
    obj1++
    obj2--
    println(" After (obj1++,obj2--) : ${obj1.x} ${obj2.x}")
   
}

Output

 Initial (obj1,obj2): 10 10
 After (++obj1,--obj2) : 11 9
 After (obj1++,obj2--) : 12 8

Example Arithmetic operators

This is similar to first example.

/*Arithmetic Operator overload*/
class Arithmetic(var operands:Int=0) {
    
    operator fun plus(other:Arithmetic) : Number{
        return operands+other.operands
    }
    operator fun minus(other:Arithmetic) : Number{
        return operands-other.operands
    }
    
    operator fun times(other:Arithmetic) : Number{
        return operands * other.operands
    }
     operator fun div(other:Arithmetic) : Number{
        if(other.operands==0) return 0 
        return operands/other.operands
    }
    operator fun rem(other:Arithmetic) : Number{
        return operands%other.operands
    }
}


fun main(args: Array<String>) {
 
    val obj1=Arithmetic(5)
    val obj2=Arithmetic(3)
    
    println("Basic Method")
    //overload Arithmetic operators
    println(obj1+obj2)
    println(obj1-obj2)
    println(obj1*obj2)
    println(obj1/obj2)
    println(obj1%obj2)
    
    println("Other Method")
    println(obj1.plus(obj2))
    println(obj1.minus(obj2))
    println(obj1.times(obj2))
    println(obj1.div(obj2))
    println(obj1.rem(obj2))
    
}

Output

Basic Method
8
2
15
1
2
Other Method
8
2
15
1
2

Example Comparison operators

class Comparison(var operands:Int){
   
    operator fun compareTo(other:Comparison):Int{
        if(operands >(other.operands)) return 1
        else return 0   
    }
   
}

fun main(args: Array<String>) {
 
    val setA=Comparison(40)
    val setB=Comparison(20)
    if(setA>setB){
        println("Set A Is Win")
    }else{
        println("Set B Is Win")
    }
}

Set A Is Win

Example Invoke operator overloading

class Money(val price:Number=50000){
    
    //Invoke of none parameter 
    operator fun invoke(): Number =price
    //Invoke of one number parameters 
    operator fun invoke(discount:Number)=println("Price: $price Discount :$discount")
    
    //Invoke of two parameters 
    operator fun invoke(discount:Number,typeInfo:String){
        println("Price :$price Discount :$discount  Type = $typeInfo")
    }
}

fun main(args: Array<String>) {
   val set1=Money()
    
   println(set1()) //50000
   
   set1(1000) 
   set1(2000)
   set1(3000,"Special User") 
 
}

Output

50000
Price: 50000 Discount :1000
Price: 50000 Discount :2000
Price :50000 Discount :3000  Type = Special User