Arithmetic operators

Preface

In Kotlin, like many other programming languages, there is concept of operators and Operands. An operand is typically a value or variable to which an operator is applied to perform a specific operation.

In the example below, the numbers 100 and 50 are operands and the plus sign + is an operator.

There are different types of operators:

• Arithmetic operators
• Assignment operators
• Comparison operators
• Logical operators
• Bitwise operators
• Index operators

Arithmetic operators

These make it possible to carry out simple mathematical calculations, such as: Addition (+), Subtraction (-), multiplication (*), division (/) and more.

fun main() {
// Addition:
    val a: Int = 5
    val b: Int = 11
    val c: Int
    c = a + b
    println(c) // c = 16
}

fun main() {
// Substraktion:
    val a: Int = 20
    val b: Int = 8
    val c: Int
    c = a - b
    println(c) // c = 12
}

fun main() {
// Multiplikation:
    val a: Int = 10
    val b: Int = 9
    val c: Int
    c = a * b
    println(c) // c = 90
}

fun main() {
// Division:
    val a: Int = 50
    val b: Int = 10
    val c: Int
    c = a / b
    println(c) // c = 5
}

Special feature of division: If both operands in a division are integers, the result is also an integer. However, if a fraction is created in the division process, it is cut off. For example: If 22 is divided by 5, according to the rules of mathematics, this equals 4,4. However, since both operands are integers (Int type), the fractional 0,4 is truncated and the result is 4, while the variable c represents Int type.

fun main() {
// Division:
    val a: Int = 22
    val b: Int = 5
    val c: Int
    c = a / b   // 22 geteilt durch 5 ergibt eigentlich 4,4
    println(c) // Da aber die Variablen "a" und "b" den Datentyp "Int" (ganzzahlige Werte ohne Nahckommastellen) haben, wird der Bruchteil 0,4 abgeschnitten. Ergebnis: c = 4
}

If you want a result as a decimal number, one of the two operands must be a floating point number.

fun main() {
// Division mit Nachkommastellen:
    val a: Int = 22
    val b: Double = 5.0
    val c: Double
    c = a / b   
    println(c) // c = 4,4
}

fun main() {
// Und noch mal das Gleiche nur in einer vereinfachten Schreibweise
    val a = 22
    val b  = 5.0
    val c = a / b   
    println(c) // c = 4,4
}

Other arithmetic operators also include Modulo(%), increment(++) and decrement(–).

% (modulo operator) calculates the remainder of a division. For example, if you calculate 7% 3, you get 1 because the remainder of dividing 7 by 3 is 1.

fun main() {
// Modulo
    val a = 7
    val b  = 3
    val c = a % b   
    println(c) // c = 1
}

++ (increment operator) increases the value of a variable by 1. For example, if you have a variable a with the value 10 have and ++ a you write, the value of a on 11 elevated.

fun main() {
// ++ (Inkrement-Operator)
    var a = 10
    val b = ++a 
    println(b) // b = 11
}

— (decrement operator) decreases the value of a variable by 1. For example, if you have a variable a with the value 10 have and -A you write, the value of a on 9  reduced.

fun main() {
// ++ (Inkrement-Operator)
    var a = 10
    val b = --a 
    println(b) // b= 9
}

It is important to note that the position of the increment or decrement operator affects the value that the variable has after the operation. If you for example a ++ you write, the value of a only increased after the operation. 

fun main() {
    var a = 5
    println(a++) // Ausgabe: 5
    println(a) // Ausgabe: 6
}

However, if you ++ a you write, the value of a increased immediately.

fun main() {
    var a = 5
    println(++a) // Ausgabe: 6
    println(a) // Ausgabe: 6
}