Types

A type is a set of values together with its associated operations. Every piece of Kotlin datum has a type.
Kotlin is a statically-typed language, i.e., the type of a variable is determined at compile time. (This is in contrast to dynamically-typed language, e.g. Python.)
Kotlin is an object-oriented language and every value is an object.
However, values of the following basic types have special implementation, making it take less space and execute faster: Boolean, Char, Byte, Short, Int, Long, Float, Double. We’ll call these the primitive types.
String and Array are basic types but not primitive.
There are a lot more types than the basic types; we’ll study them later.

Literals, integer literals

A literal is a source code level representation of data value.
An integer literal may be written in 3 different bases: two, ten, and sixteen. Here are the different ways to write the number twelve.
- in binary (base-two): 0b1100
- in decimal (base-ten): 12
- in hexadecimal (base-sixteen): 0xC
An Int literal can be assigned to a Byte or Short variable without getting a compile-time error if the value is within range.
All integer literals has Int type (unless suffixed by L).
A Long literal can be obtained by appending the suffix L to an integer literal. E.g. 34L has a Long type.

Floating-point literals

A floating point literal can be written in 2 different ways
- like how we write real numbers in mathematics: 3.134
- in scientific notation: 2.1e10, 3e-7
The type of all floating point literals is Double by default.
To get a Float literal, add a suffix ‘f’ or ‘F’. E.g. 3.14F has a Float type.

String literals

A string literal is any sequence of characters enclosed in a pair of double quotation marks.
Example string literals are
- “Hello”
- “Good Bye!”
- “123456”
- “true”
- “false”
- “Int”
- “print()”
We will explore string literals in detail later.

Operators

The are several groups, taking operands of different types. Here is a selection of some operators:
- arithmetic: + \(-\) * / %
- logical: && || !
- comparison: < <= >= >
- equality: == !=
- bit-wise: shl shr ushr and or xor inv
- increment & decrement: ++ \(-\)\(-\)
- assignment: = += \(-\)= *= /= %=
- miscellaneous: + \(-\) . [] () in !in is !is
Some operators are overloaded. Therefore, it’s important to know what each operator means in all possible contexts. Examples of overloaded operators are + \(-\) * / %

Operator Precedence

The term precedence denotes the degree of tightness of binding of operators to operand(s).
Each operator has a precedence level.
In an ambiguous expression, operator precedence is used to determine which operation to perform first.
For example, *, /, and % are at the same precedence level. Also, + and \(-\) are at the same level. However, the precedence level of *, /, and % is higher than that of + and \(-\).
Therefore, in the expression 2+3*4, multiplication is performed before addition since the * operator has higher precedence than +.

Operator Associativity

When an expression involves at least two operators of the same precedence level applied successively, Kotlin uses associativity of operators to determine whether to associate the middle operand with the left operator (left-associative) or the right operator (right-associative).
Most operators in Kotlin are left-associative. Examples of right-associative operators are the unaryPlus + and unaryMinus \(-\) operators.
For example, the expression 1-3-4 will be parsed by the Kotlin compiler as if we had written (1-3)-4 due to the fact that the minus operator is left-associative.
Notes.
- We can use parentheses to overide the precedence and associativity rules if desired.
- When in doubt, parenthesize the expression to make your intention clear.

Basic Types

Type	Size in Bits	Sample Operators	Literals
Boolean	unspecified	&& \|\| !	true false
Byte	8	+ \(-\) * / %
Char	16	+	‘a’ ‘0’ ‘\\’
Short	16	+ \(-\) * / %
Int	32	+ \(-\) * / %	321 0x3A 0b11
Long	64	+ \(-\) * / %	3L
Float	32	+ \(-\) * / %	2F 14.2e23f
Double	64	+ \(-\) * / %	3.21 14.2e23
String		+	“Hello”
Array		[]

String Type

Strings have some features of basic types.
- We can write a string value using literals, e.g., “Hello”
- Strings can be concatenated with the operator +, e.g.,
  - “This is an example” + " string" ⇒ “This is an example string”
  - “The value is ” + 13 ⇒ “The value is 13”
We will study strings in more detail later.

Keywords

Keywords are the reserved words of Kotlin. Their meanings are pre-defined and fixed. You cannot use a keyword to mean something else, unless you quote them in backticks, like this: `in`.

Here is a list of the hard keywords

as as? break class continue do else false for fun
if in !in interface is !is null object package return
super this throw true try typealias val var when while

There are other kinds of keywords. We may encounter some of them later.

Identifiers

Kotlin is a case-sensitive language; it distinguishes the uppercase from the lowercase letters.
An identifier is a programmer-invented name to denote program constructs like variable, class, interface, function, etc.
Syntactically, an identifier is a sequence of letters, digits, or underscore character such that its first character is not a digit. An identifier cannot be a keyword.
Convention for writing an identifier:
- the camel hump style is recommended, e.g., ticketNumber
- variable name starts with a lowercase letter
- class name starts with a uppercase letter, e.g., BigInteger
- constants & enumerated literals are in all caps, e.g., MAX_LINE_LENGTH

Variables and assignment

A variable is a name associated with memory location whose value is changeable via an assignment statement.
A variable has many attributes, e.g., memory location, name, type, value, scope, life time.
An assignment statement starts with name of the variable, followed by the = operator, followed by an expression. E.g.
```
a = 2 * b + 6
```
For simplicity, assume the variable has primitive type. Then the assignment statement means to evaluate the expression on the right-hand-side (RHS) of =, then put its value in memory location of the variable on the left-hand-side (LHS).
Thus, the variable name appearing on the LHS denotes memory location while any variable name appearing on the RHS denotes value.

Variables, continued

There are two kinds of variables, the readonly kind, and the writable kind.
A better name for readonly variable is “assign-once” variable. A better name for writable variable is “assignable-multiple-times” variable.
Both kinds must be declared before use.
You should preferentially use the readonly kind of variables whenever possible. Use the writable kind only when necessary.

Readonly variables

The readonly variables are declared using the keyword val.
They must be initialized with some value (using the assignment syntax) exactly once in a program.
After initialization, the value of a readonly variable is fixed. You are not allowed to assign a value to it again.

Example declaration and usage:

val c : Char = 'A'
val digit : Char = '9'
val greeting : String = "Hi"
val person : String = "Alice"
println(greeting + " " + person)

Writable variables

A writable variable is declared with the keyword var.
It can be assigned values many times during the execution of a program.

Example declaration, usage, and reassignment:

var n : Int = 1
var f : Float = 0F
var d : Double = 2.1
f = f * 3.1F
d = 3e-2
var greet : String = "Hello!"
greet = "Hi"

Expressions

In the simplest case, an expression consists of literals, variables, and function calls joined together by operators.
```
b * 2 / 3 + kotlin.math.sin(4)
```
Every expression has a type and value.
There are other kinds of expressions. We’ll come to them soon.

Type conversion

In an arithmetic expression involving mixed types of numeric operands, Kotlin has overloaded the operators so it seems as if to convert the values in the following direction to make both operands have the same type as the “biggest” type.
```
Byte → Short → Int → Long → Float → Double
```

Examples:

3 + 4.2        // value: 7.2, type: Double
1 + 7L - 2     // value: 6L,  type: Long

The user can also explicitly requests the compiler to convert a value of one type into another type. E.g.
```
val a : Int = 2
val b : Byte = (a + 3).toByte()
val s : Short = 4.toShort()
```

Function calls

These type conversion functions are associated with objects. You call them using the . operator.
- toBoolean()
- toChar()
- toByte()
- toShort()
- toInt()
- toLong()
- toFloat()
- toDouble()

Example usage:

"TrUe".toBoolean() ⇒ true  
66.toChar() ⇒ 'B'  
25.toByte() ⇒ a Byte type with value of twenty-five  
265.toByte() ⇒ a Byte type with value of nine

Input/Output Functions

These are the output functions you can use. All of them output their argument(s) to the standard output.
- print() — outputs its argument.
- println() — outputs its argument and a newline, and flushes the output buffer.
Both the print() and println() functions take exactly one argument. Their argument can be of any type, and it is automatically converted to the String type (if necessary) before being output.

The ‘kotlin.math’ class

This is a kotlin class that provides many useful mathematical functions and constants. Here is a partial selection:
- abs — for Double, Float, Int, and Long
- min, max — for Double, Float, Int, and Long
- floor, ceil, round, truncate — for Double and Float
- sin, cos, tan — for Double and Float
- exp, ln, log10, log2, log — for Double and Float
- pow — for Double and Float
- sqrt — for Double and Float
- roundToInt, roundToLong — for Double and Float
- E — the famous \(e\) (the base of natural logarithm)
- PI — \(\pi\) (the circle constant: circumference \(\div\) diameter)

Generating random numbers

/*
 * This program expects one command line argument n as a positive integer.
 * Firstly, it generates a random integer (in the range of Int) and prints it.
 * It then generates a random real in the range [0,1) and prints it.
 * Lastly, it generates a random integer between 0 and n-1 inclusive
 * and prints it.
 */
fun main(args: Array<String>) { 
    val randGen = java.util.Random()
    val n = args[0].toInt()

    // a pseudo-random integer
    var k = randGen.nextInt()
    println("Your random integer is: $k")

    // a pseudo-random real between 0.0 and 1.0
    val r = randGen.nextDouble()
    println("Your random real number in [0, 1) is: $r")

    // a pseudo-random integer between 0 and n-1
    k = randGen.nextInt(n)
    println("Your random integer between 0 and ${n-1} inclusive is: $k")
}

Basics

San Skulrattanakulchai

September 19, 2018

Topics

Types

Literals, integer literals

Floating-point literals

String literals

Operators

Operator Precedence

Operator Associativity

Basic Types

String Type

Keywords

Identifiers

Variables and assignment

Variables, continued

Readonly variables

Writable variables

Expressions

Type conversion

Function calls

Input/Output Functions

The ‘kotlin.math’ class

Generating random numbers