Arithmetische Operatoren

Einführung

In Kotlin gibt es, wie in vielen anderen Programmiersprachen, Konzept von Operatoren und Operanden. Ein Operand ist in der Regel ein Wert oder eine Variable, auf die ein Operator angewendet wird, um eine bestimmte Operation durchzuführen.

Im nachstehenden Beispiel sind die Zahlen 100 und 50 Operanden und das Pluszeichen + ist ein Operator.

Operand	Operator	Operand
10	+	5

Es gibt verschiedene Arten von Operatoren:

• Arithmetische Operatoren
• Zuweisungsoperatoren
• Vergleichsoperatoren
• Logische Operatoren
• Bitweise Operatoren
• Index-Operatoren

Arithmetische Operatoren

Diese ermöglichen es, einfache mathematische Berechnungen durchzuführen, wie z.B. Addition (+), Subtraktion (-), Multiplikation (*), Division (/) und weitere.

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

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

fun main() {
// Multiplication:
    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
}

Besonderheit bei der Division: Wenn beide Operanden in einer Division ganze Zahlen sind, ist das Ergebnis ebenfalls eine ganze Zahl. Ist jedoch ein Bruchteil im Divisionprozess entstanden, wird er abgeschnitten. Zum Beispiel: Wenn 22 durch 5 geteilt wird, entspricht das nach den Mathematikregeln 4,4. Da jedoch beide Operanden ganze Zahlen sind (Typ Int), wird der Bruchteil 0,4 abgeschnitten und das Ergebnis ist 4, während die Variable c den Typ Int darstellt.

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) // Since the variables 'a' and 'b' have the data type 'Int' (whole numbers without decimal points), the fractional part, 0.4, is truncated. As a result, c = 4.
}

Wenn man ein Ergebnis als Dezimalzahl haben möchte, muss einer der beiden Operanden eine Fließkommazahl sein.

fun main() {
// Division with numbers that have decimal points:
    val a: Int = 22
    val b: Double = 5.0
    val c: Double
    c = a / b   
    println(c) // c = 4,4
}

fun main() {
// The same again, but with simplified writing:
    val a = 22
    val b  = 5.0
    val c = a / b   
    println(c) // c = 4,4
}

Zu weiteren arithmetischen Operatoren gehören auch Modulo(%), Inkrement(++) und Dekrement(–).

% (Modulo-Operator) berechnet den Rest einer Division. Wenn du zum Beispiel 7 % 3 ausrechnen, erhälst du 1, da der Rest der Division 7 durch 3 1 ist.

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

++ (Inkrement-Operator) erhöht den Wert einer Variablen um 1. Wenn du zum Beispiel eine Variable a mit dem Wert 10 hast und ++a schreibst, wird der Wert von a auf 11 erhöht.

fun main() {
// ++ (Increment operator)
    var a = 10
    val b = ++a 
    println(b) // b = 11
}

– – (Dekrement-Operator) verringert den Wert einer Variablen um 1. Wenn du zum Beispiel eine Variable a mit dem Wert 10 hast und – -a schreibst, wird der Wert von a auf 9  verringert.

fun main() {
// -- (Decrement operator)
    var a = 10
    val b = --a 
    println(b) // b= 9
}

Es ist wichtig zu beachten, dass die Position des Inkrement- oder Dekrement-Operators den Wert beeinflusst, den die Variable nach der Operation hat. Wenn du zum Beispiel a++ schreibst, wird der Wert von a erst nach der Operation erhöht. 

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

Wenn du jedoch ++a schreibst, wird der Wert von a sofort erhöht.

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