Kotlin Basic Concepts

In Kotlin, operators are special symbols that carry out operations on operands. For instance, + and – are operators that perform addition and subtraction, respectively. Similar to Java, Kotlin provides various kinds of operators:

• Arithmetic operators
• Relational operators
• Assignment operators
• Unary operators
• Logical operators
• Bitwise operators

Arithmetic Operators : Arithmetic operators are used to perform basic mathematical operations. Here’s a breakdown:

Example:

fun main(args: Array<String>) {
    var a = 20
    var b = 4
    println("a + b = " + (a + b))
    println("a - b = " + (a - b))
    println("a * b = " + (a.times(b)))
    println("a / b = " + (a / b))
    println("a % b = " + (a.rem(b)))
}

Output:

a + b = 24
a - b = 16
a * b = 80
a / b = 5
a % b = 0

Relational Operators : These operators compare two values:

Example:

fun main(args: Array<String>) {
    var c = 30
    var d = 40
    println("c > d = " + (c > d))
    println("c < d = " + (c.compareTo(d) < 0))
    println("c >= d = " + (c >= d))
    println("c <= d = " + (c.compareTo(d) <= 0))
    println("c == d = " + (c == d))
    println("c != d = " + (!(c?.equals(d) ?: (d === null))))
}

Output:

c > d = false
c < d = true
c >= d = false
c <= d = true
c == d = false
c != d = true

Assignment Operators : These operators are used to assign values to variables and also modify the current values.

Example:

fun main(args: Array<String>) {
    var a = 10
    var b = 5
    a += b
    println(a)
    a -= b
    println(a)
    a *= b
    println(a)
    a /= b
    println(a)
    a %= b
    println(a)
}

Output:

15
10
50
10
0

Unary Operators : Unary operators are applied to a single operand to modify its value.

Example:

fun main(args: Array<String>) {
    var e = 10
    println("Print then increment: " + e++)
    println("Increment then print: " + ++e)
    println("Print then decrement: " + e--)
    println("Decrement then print: " + --e)
}

Output:

Print then increment: 10
Increment then print: 12
Print then decrement: 12
Decrement then print: 10

Logical Operators : Logical operators work with boolean values.

Example:

fun main(args: Array<String>) {
    var x = 100
    var y = 25
    var z = 10
    var result = false
    if (x > y && x > z) println(x)
    if (x < y || x > z) println(y)
    if (result.not()) println("Logical operators")
}

Output:

100
25
Logical operators

Bitwise Operators: Bitwise operators work directly on the bits of binary numbers.

Example:

fun main(args: Array<String>) {
    println("5 shifted left by 1: " + 5.shl(1))
    println("10 shifted right by 2: " + 10.shr(2))
    println("12 unsigned shifted right by 2: " + 12.ushr(2))
    println("36 AND 22: " + 36.and(22))
    println("36 OR 22: " + 36.or(22))
    println("36 XOR 22: " + 36.xor(22))
    println("Bitwise inverse of 14: " + 14.inv())
}

Output:

5 shifted left by 1: 10
10 shifted right by 2: 2
12 unsigned shifted right by 2: 3
36 AND 22: 4
36 OR 22: 54
36 XOR 22: 50
Bitwise inverse of 14: -15

In Kotlin, standard input and output operations are used to transfer byte streams from input devices (like the keyboard) to the system’s memory and from memory to output devices (such as the monitor). This guide covers how to take input and display output using Kotlin.

Kotlin Output

In Kotlin, output is displayed using the print() and println() functions. Unlike Java, where we use System.out.println(), Kotlin directly provides print() and println().

Here is an example of basic output:

fun main(args: Array<String>) {
    print("Hello, World! ")
    println("Welcome to Kotlin.")
}

Output:

Hello, World! Welcome to Kotlin.

Difference Between print() and println()

• print() displays the message inside the double quotes, but the cursor stays on the same line.
• println() also displays the message but moves the cursor to the next line after printing.

Example:

fun main(args: Array<String>) {
    println("Kotlin Programming")
    println("Language Overview")

    print("Kotlin - ")
    print("Language")
}

Output:

Kotlin Programming
Language Overview
Kotlin - Language

Printing Literals and Variables

You can print literals, variables, and even the result of function calls directly using string interpolation.

Example:

fun sum(a: Int, b: Int): Int {
    return a + b
}

fun main(args: Array<String>) {
    var x = 10
    var y = 20
    var z = 50L
    var score = 88.5

    println("Sum of $x and $y is: ${sum(x, y)}")
    println("Long value is: $z")
    println("Score: $score")
}

Output:

Sum of 10 and 20 is: 30
Long value is: 50
Score: 88.5

Kotlin Input

Kotlin provides several ways to take input from the user.

1. Using readLine(): The readLine() function reads input from the user as a string. It’s commonly used for string input but can be converted to other types like integers or doubles using conversion functions.

Example:

fun main(args: Array<String>) {
    print("Enter some text: ")
    var input = readLine()
    print("You entered: $input")
}

Output:

Enter some text: Kotlin Input
You entered: Kotlin Input

2. Using the Scanner Class : For more advanced input handling, such as accepting numbers, we can use the Scanner class from Java. You need to import java.util.Scanner before using it.

Example:

import java.util.Scanner

fun main(args: Array<String>) {
    val scanner = Scanner(System.`in`)

    print("Enter an integer: ")
    val intValue = scanner.nextInt()
    println("You entered: $intValue")

    print("Enter a float value: ")
    val floatValue = scanner.nextFloat()
    println("You entered: $floatValue")

    print("Enter a boolean: ")
    val boolValue = scanner.nextBoolean()
    println("You entered: $boolValue")
}

Output:

Enter an integer: 10
You entered: 10
Enter a float value: 25.5
You entered: 25.5
Enter a boolean: true
You entered: true

3. Taking Input Without Using the Scanner Class : You can also take input without importing the Scanner class by using readLine() and converting the string to other data types.

Example:

fun main(args: Array<String>) {
    print("Enter an integer: ")
    val inputString = readLine()!!
    val intValue: Int = inputString.toInt()
    println("You entered: $intValue")

    print("Enter a double value: ")
    val doubleString = readLine()!!
    val doubleValue: Double = doubleString.toDouble()
    println("You entered: $doubleValue")
}

Output:

Enter an integer: 42
You entered: 42
Enter a double value: 99.99
You entered: 99.99

An expression in Kotlin consists of variables, operators, method calls, and other elements that produce a value. Expressions are building blocks of a program, often created to compute new values or assign them to variables. It’s worth noting that expressions can also contain other expressions.

A few things to note:

• A variable declaration is not an expression (e.g., var a = 100).
• Assigning a value is not an expression (e.g., b = 15).
• A class declaration is not an expression (e.g., class XYZ { ... }).

In Kotlin, every function returns at least a Unit type, meaning every function is treated as an expression.

Here is an example of Kotlin expressions:

fun sumOf(a: Int, b: Int): Int {
    return a + b
}

fun main(args: Array<String>) {
    val a = 10
    val b = 5
    val sum = sumOf(a, b)
    val mul = a * b
    println(sum)
    println(mul)
}

Output:

15
50

Kotlin if Expression

Unlike Java, where if is a statement, in Kotlin, if is an expression. It evaluates a condition and returns a value based on the result. This is why Kotlin doesn’t have a ternary operator like (a > b) ? a : b, as the if expression serves this purpose.

if (condition) conditionMet else conditionNotMet

Example: Here’s an example to find the maximum of two values:

if (condition) conditionMet else conditionNotMet

Output:

if (condition) conditionMet else conditionNotMet

Kotlin Statements

A statement is a syntactic unit in programming that expresses an action to be carried out. Programs are made up of one or more statements. While Java requires a semicolon at the end of every statement, Kotlin makes this optional.

Examples of statements:

• Declaring a variable: val marks = 90
• Assigning a value: var sum = 10 + 20

In the example var sum = 10 + 20, the part 10 + 20 is an expression, while var sum = 10 + 20 is a statement.

Multiple Statements: Multiple statements can be written on a single line.

fun main(args: Array<String>) {
    val sum: Int
    sum = 100
    println(sum)                       // single statement
    println("Hello"); println("World")  // multiple statements
}

Output:

100
Hello
World

Kotlin Block

A block in Kotlin is a section of code enclosed in curly braces { ... }. A block can consist of one or more statements, often with variable declarations. Blocks can also be nested. Each function in Kotlin has its own block, and the main function also contains a block.

Here’s an example of a block with a nested block:

fun main(args: Array<String>) {              // start of outer block
     val array = intArrayOf(2, 4, 6, 8)
     for (element in array) {                // start of inner block
        println(element)
     }                                       // end of inner block
}                                            // end of outer block

Output:

2
4
6
8