In Kotlin, code statements do not have to end with a semicolon (;)

The println() function is used to output values/print text

There is also a print() function, which is similar to println(). The only difference is that it does not insert a new line at the end of the output

Variables

To create a variable, use var or val, and assign a value to it with the equal sign (=):

The difference between var and val is that variables declared with the var keyword can be changed/modified, while val variables cannot.

Unlike many other programming languages, variables in Kotlin do not need to be declared with a specified type

However, it is possible to specify the type if you insist

var name: String = "John" // String
val birthyear: Int = 1975 // Int

You can also declare a variable without assigning the value, and assign the value later. However, this is only possible when you specify the type

var name: String
name = "John"
println(name)

You can also use the + character to add a variable to another variable

name rules

The general rule for Kotlin variables are:

• Names can contain letters, digits, underscores, and dollar signs
• Names should start with a letter
• Names can also begin with $ and _ (but we will not use it in this tutorial)
• Names are case sensitive (“myVar” and “myvar” are different variables)
• Names should start with a lowercase letter and it cannot contain whitespace
• Reserved words (like Kotlin keywords, such as var or String) cannot be used as names

Date Type

Data types are divided into different groups:

• Numbers

  Number types are divided into two groups:

  Integer types store whole numbers, positive or negative (such as 123 or -456), without decimals. Valid types are Byte, Short, Int and Long.

  Floating point types represent numbers with a fractional part, containing one or more decimals. There are two types: Float and Double.

  To convert a numeric data type to another type, you must use one of the following functions: toByte(), toShort(), toInt(), toLong(), toFloat(), toDouble() or toChar()

• Characters

  The Char data type is used to store a single character. A char value must be surrounded by single quotes

• Booleans

• Strings

  Instead of concatenation, you can also use “string templates”, which is an easy way to add variables and expressions inside a string.

  Just refer to the variable with the $ symbol:

  var firstName = "John"
  var lastName = "Doe"
  println("My name is $firstName $lastName")
  

• Arrays

Condition

• if..else:In Kotlin, you can also use if..else statements as expressions (assign a value to a variable and return it):

• Instead of writing many if..else expressions, you can use the when expression(like switch-case), which is much easier to read. The when expression is similar to the switch statement in Java.

  val day = 4
  
  val result = when (day) {
    1 -> "Monday"
    2 -> "Tuesday"
    3 -> "Wednesday"
    4 -> "Thursday"
    5 -> "Friday"
    6 -> "Saturday"
    7 -> "Sunday"
    else -> "Invalid day."
  }
  println(result)
  

• for...in

  With the for loop, you can also create ranges of values with “..”:

  for (chars in 'a'..'x') {
    println(chars)
  }
  

Arrays

Arrays are used to store multiple values in a single variable, instead of creating separate variables for each value.

To create an array, use the arrayOf() function, and place the values in a comma-separated list inside it:

val cars = arrayOf("Volvo", "BMW", "Ford", "Mazda")

Functions

The fun keyword is used to declare a function.

fun myFunction(x: Int): Int {
  return (x + 5)
}

There is also a shorter syntax for returning values. You can use the = operator instead of return without specifying the return type. Kotlin is smart enough to automatically find out what it is:

fun myFunction(x: Int, y: Int) = x + y

fun main() {
  var result = myFunction(3, 5)
  println(result)
}

Class

we can use the class name to create objects.

Class Car{
    ...
}

var car=Car()

inheritance

Use the open keyword in front of the superclass/parent, to make this the class other classes should inherit properties and functions from.

To inherit from a class, specify the name of the subclass, followed by a colon :, and then the name of the superclass.

// Superclass
open class MyParentClass {
  val x = 5
}

// Subclass
class MyChildClass: MyParentClass() {
  fun myFunction() {
    println(x) // x is now inherited from the superclass
  }
}

// Create an object of MyChildClass and call myFunction
fun main() {
  val myObj = MyChildClass()
  myObj.myFunction()
} 

*unrar x -o- -y dtu_training.rar /home/lab303/PointMVSNet/