Intro to Kotlin

Introduction to Kotlin

Kotlin Hello World

To test basic Kotlin programs, which are not part of an Android Studio app, use this Kotlin Playground environment:
play.kotlinlang.org
This Kotlin Playground includes a Kotlin Tutorial. Find this tutorial at
Docs >> Language >> Language Guide
Compile and run a Hello World program in the Kotlin Playground:
enter these lines of code into the interactive editor.
```
// Example 1.
fun main( ) {
    println("Hello, World")
}
```
Run this main method by clicking the blue button at the top right of the program editor. You should obtain this output:
```
Hello, World
```

The main Function with and without
Command Line Arguments

The header of a Java main method:
```
public static void main(String[ ] args) {
```
The array parameter args is required for a Java main method.
However, the args parameter is optional for a Kotlin main method.
The main method header
```
fun main(args : Array<String>) {
```
can shortened to
```
fun main( ) {
```
This short version assumes that the args parameter is not needed.
Try this example main method that uses the args parameter to input the addends for addition:
```
fun main(args : Array<String>) {
    var addend1 = args[0].toInt( )
    var addend2 = args[1].toInt( )
    println("Sum: ${addend1 + addend2})
}
```
Run this program in the Kotlin Playground (see above for URL). Enter the command line arguments (for example 5 7) in the Program arguments box. Click the Run button to test the program.
We will use a Kotlin main method without command line arguments for testing our Project 3a app.
However, since a main method is not used in an Android app, command line arguments are not needed there.

Datatypes and Variables

Here is a table of common Java built in datatypes and the corresponding Kotlin datatypes:

Java Datatype	Kotlin Datatype
boolean	Boolean
byte	Byte
char	Char
double	Double
float	Float
int	Int
long	Long
short	Short
String	String

In the Java column of the table, all of the datatypes except String are primitive types. However, primitive types do not exist in Kotlin; all of the datatypes in the second column are class types.
Here are Kotlin statements that declare the variable n to be of datatype Int and assign it to the value 427:
```
var n : Int
n = 427
```
The preceding two statements can be combined to perform declaration and initialization in one line:
```
var n : Int = 427
```
This declarion and initialization can be shorted even more by using duck typing:
```
var n = 428
```
Duck typing means "if it looks like a duck and quacks like a duck, it's a duck." In the case of an Int: "if it looks like an Int and quacks like an Int, as 428 does, it's an Int so n must also be an Int.

Example 2: Create and run this Kotlin file:

fun main( ) {
    var n : Int = 893
    var x : Double = 2.78;
    var b : Boolean = true
    var s : String = "abc"
    var c : Char = 'A'

    // $n is expression interpolation: insert the
    // value of the variable n into the output string. 
    println("n: $n; x: $x; b: $b; s: $s; c: $c")
}
// Output:
n: 893; x: 2.78; b: true; s: abc; c: A

Because Kotlin uses duck typing, the variable declarations are not always necessary. We can simplify the preceding main function to look like this:

fun main( ) {
    var = 893
    var = 2.78;
    var = true
    var = "abc"
    var = 'A' 
    println("n: $n; x: $x; b: $b; s: $s; c: $c")
}
// Output:
n: 893; x: 2.78; b: true; s: abc; c: A

Constants

To define a constant, use the val keyword:

val n = 5;
// The following line causes an error because
// the value of a constant cannot be changed:
n++;

It is common in many languages use uppercase letters for constant names, for example:
```
val MAX_NUMBER_OF_OCCUPANTS = 400
```

Control Structures: Decision

If-else statements look like Java:

// Example 3:
fun main( ) {
    print("Enter an Int: ")
    var line = readln( )
    var n = line.toInt( )
    if (n >= 100) {
        println("Large");
    }
    else {
        println("Small")
    }
}

Here is Kotlin's version of the Java Elvis (tertiary conditional) operator:

// Example 4.
fun main( ) {
    print("Enter an Int: ")
    var line = readln( )
    var n = line.toInt( )
    var output = if (x >= 100) "Large" else "Small"
    println(output)
}

Finally, here is Kotlin's version of aJava switch statement:

// Example 5.
fun main( ) {
    print("Enter an Int: ")
    var line = readln( )
    var n = line.toInt( )
    when (n) {
        1 -> println("one")
        2 -> println("two")
        3 -> println("three")
        else -> println("value not found")
    }
}

Control Structures: Repetition

Kotlin while loops look like Java:

// Example 6.
fun main( ) {
    // Print integers from 1 to 10.
    var n = 1
    while (n <= 10) {
        print("$n ")
        n++
    }
}

However, a Kotlin for loop is different than a Java for loop. Here is Example 6 rewritten as a Kotlin for loop:

// Example 7.
fun main( ) {
    // Print integers from 1 to 10
    for (n in 1..10) {
        print("$n ")
    }

    // Print integers from 1 to 10 by 2
    println( )
    for (n in 1..10 step 2) {
        print("$n ")
    }

    // Print integers from 10 downto 1
    println( )
    for (n in 10 downTo 1) {
        print("$n ")
    }

    // Print integers from 100 down
    // to 1 by 7s.
    println( )
    for (n in 100 downTo 1 step 7) {
        print("$n ")
    }
}

Functions

Kotlin functions are defined with the keyword fun, which means function. Otherwise they work like Java functions. Here is an example:

// Example 8a.
fun main( ) {
    print("Enter a name: ")
    var name = readln( )
    var greeting = makeGreeting(name)
    println(greeting)
}

fun makeGreeting(n : String) : String {
    var greeting = "Hello, $n, how are you?")
    return greeting
}
// Output:
Enter a name: Larry
Hello, Larry, how are you?

Here is a shorter version of this example:

// Example 8a.
fun main( ) {
    print("Enter a name: ")
    println(makeGreeting(readln( )))
}

fun makeGreeting(n : String) : String {
    return "Hello, $n, how are you?"
}

// Output:
Enter a name: Larry
Hello, Larry, how are you?

Here are two more examples of Kotlin functions:
Example 9: The countDown function counts down from the specified start value to zero:

fun main( ) {
    countDown(10)
}

fun countDown(start : Int) {
    for(i in start downTo 0) {
        print("$i..")
    }
    println( )
}

Example 10: the square function.

fun main( ) {
    print("Enter a positive int: ")
    var n = readln( ).toInt( )
    println("The square of $n is ${square(n)}.")
}

fun square(n : Int) : Int {
    return n * n;
}

We will learn more about functions when they are used as instance methods in classes.

Unit

The HelloWorld main function:

fun main( ) {
    println("Hello, World.")
}

This main function can also be written like this:
```
fun main( ) : Unit {
    println("Hello, World.")
}
```
We can infer that Unit corresponds to the Java datatype void.
The name Unit comes from the functional programming language theorists. It means that a function declared with the return type Unit can only return the single value also named Unit. This way, every function returns a value; this maintains consistancy within Kotlin's type system.
In the Kotlin language, every function returns a value, but the return type Unit means that a function does not return a useful type.
When the return type Unit is omitted when defining the main method, the Unit return value is assumed by default.

Named Parameters

Unlike Java, Kotlin supports named parameters for functions.
This means specifying the parameter name when passing in a value, rather than solely relying on the order of the parameters.

Example 11. This example uses named parameters. It also defines a default parameter.

// The greeting parameter has the default value "Hello".
fun greet(name : String, greeting : String = "Hello") {
    return "$greeting, $name, how are you?"
}

fun main( ) {
    println(greet("Alice", "Hi"))
    println(greet(name = "Bob"))
    println(greet(greeting = "Chao", name = "Chloe")
}
// Output:
Hi, Alice, how are you?
Hello, Bob, how are you?
Chao, Chloe, how are you?

Named parameters are important for Jetpack Compose apps, which we discuss later in these notes.

Arrays

Example 12: This example creates arrays of String, Int, and Boolean.

fun main( ) {

    // Create and print array of String.
    var stringArray : Array<String> =
        arrayOf("C#", "Java", "Kotlin", "Python")
    for(s in stringArray) {
        print("$s ")
    }
    println("\nstringArray[1]: ${stringArray[1]}\n")

    // Create and print array of String.
    var intArray : Array<Int> = 
        arrayOf(236, 740, 981, 227)
    for(n in intArray) {
        print("$n ")
    }
    println("\nintArray[3]: ${intArray[3]}")

    // Create and print array of Boolean.
    var boolArray : Array<Boolean> = 
        arrayOf(true, false, true, true)
    for(b in boolArray) {
        print("$b ")
    }
    println("\nboolArray[0]: ${boolArray[0]}")
}

Duck typing works for arrays. The statement

var stringArray : Array<String> =
    arrayOf("C#", "Java", "Kotlin", "Python")

can also be written as

var stringArray = arrayOf("C#", "Java", "Kotlin", "Python")

Printing an array directly without using a loop does not give useful information:
```
println(stringArray)
// Output:
[Ljava.lang.String;@b684286
```

As in Example 12, an array can be printed with a Kotlin for loop resembling a traditional Java for loop:

for (i in 0..stringArray.size - 1) {
    print("${stringArray[i]} ")
}
// Output:
C++ Java Kotlin Python

Like a Java array, the size of a Kotlin array cannot be changed.
Also like a Java array, a Kotlin array is mutable, which means that its elements can be changed:
```
stringArray[4] = "JavaScript" 
```

Lists

A Kotlin list is like a Java ArrayList collection.
Kotlin lists come in two versions: MutableList, whose elements can be changed and List, which is immutable.

Example 13: This example shows the difference between lists and mutable lists:

fun main( ) {
    // Create an mutable list.
    var mList : MutableList<String> =
        mutableListOf("C++", "Java", "Kotlin", "Python")
    mList[2] = "Go";
    for(s in mList) {
        print("$s ")
    }
    
    // Create an immutable list.
    var animalList : List<String> = 
        listOf("deer", "raccoon", "skunk")
    for(t in animalList) {
        print("$t ")
    }
    // The following line causes an error:
    // animalList[2] = "squirrel"
    // However, this line is okay:
    println("\n${animalList[2]}")
}

Classes

Like a Java class, a Kotlin class contains instance variables and instance methods.
Unlike Java, getters and setters can be created automatically by the compiler.

Example 14: create a Dog class defined by this UML diagram:

+----------------------------+
|             Dog            | 
+----------------------------+
| - name : String {get}      |
| - breed : String {get}     |
| - age : Int {get, set}     |
| - weight : Int { get, set} |
+----------------------------+
| + haveBirthday( )          |
| + bark( ) : String         |
+----------------------------+

Here is the Kotlin code for the Dog class and a main method to test it:

//--------------------------------------
// Example 14.
// Source code file: Dog.kt
// The fields name and breed cannot be changed, so
// they are defined with val; age and weight can be
// changed, so they are defined with var.
class Dog(val name : String, val breed : String,
          var age : Int, var weight : Int) {
    
    fun haveBirthday( ) {
        age++;
    }

    fun bark( ) : String {
        if (weight >= 20) {
            return "Woof"
        }
        else {
            return "Yip"
        } 
    }

    override fun toString( ) : String {
        return "$name;$breed;$age;$weight"
    }
}
//--------------------------------------
// Example 14.
// Source code file: Test1.kt
fun main( ) {
    var dog1 = Dog("Sparky", "Dachshund", 3, 12)
    println(dog1)
    println("Name: ${dog1.name}")
    println("Breed: ${dog1.breed}")
    println("Age: ${dog1.age}")
    println("Weight: ${dog1.weight}")
    dog1.haveBirthday( )
    println(dog1.age)
    println(dog1.bark( ))
    dog1.weight = 22
    println(dog1.bark( ))
}

Example 15. Another example is the Point class. It contains the dist method that measures the distance from the current Point object (x, y) to the origin (0, 0). The equals method returns true, which indicates that the two points this and other are equal if
this.x == other.x
and
this.y == other.y.
The toString method of the Point class outputs the point in ordered pair notation, for example (3.2, 9.0).

// Example 15
// Source code file: Point.kt
class Point(var x : Float, var y : Float) : Comparable<Point> {

    fun dist( ) : Float {
        var x2 : Double = (x * x).toDouble( )
        var y2 : Double = (y * y).toDouble( )
        return Math.sqrt(x2 + y2).toFloat( )
    }

    override fun compareTo(other : Point) : Int {
        if(this.dist( ) > other.dist( )) return 1
        else if(this.dist( ) < other.dist( )) return -1
        else return 0
    }

    fun equals(other : Point) : Boolean {
        return this.x == other.x && this.y == other.y
    }

    override fun toString( ) : String {
        return "($x, $y)"
    }
}
----------------------------------------
// Example 15.
// Source code file: Test1.kt
fun main( ) {

    // Create array of four Point objects. The f suffix
    // makes the constants of type Float.
    var arr = arrayOf(Point(3.4f, 7.5f), Point(1.9f, 2.6f),
    Point(0.3f, 0.7f), Point(1.5f, 6.1f))

    // Sort points in order from closest to the origin 
    // to furthese from origin.
    arr.sort( )

    // Print sorted points.
    for(p in arr) {
        print("$p ${p.dist( )} ")
    }
}

Example 16. This example is inspired by Griffiths and Griffiths, Head First Kotlin, A Brain Friendly Guide, 2019, O'Reilly

Sometimes we want to include instance variables in our class that are not initialized with constructor parameters; sometimes we want to include custom getters and setters in our class. Here is an example that does this:

//--------------------------------------
// Example 16.
// Source code file: Dog.kt

// Parameters defined in the class header are passed
// in to a class object via the constructor, but they
// do not immediately define instance variables because 
// val or var are not used.
class Dog(name_param: String, breed_param: String,
          weight_param: Int) {

    // Define name field to be read only; ensure that
    // it is it non-empty.
    var name = if (name_param.equals("")) "Unknown" else name_param

    // Define breed field. Define getter to return
    // the breed in all caps.
    val breed = breed_param
        get( ) = field.uppercase( )

    // Define weight field.  Ensure that weight
    // is non-negative.
    var weight = if (weight_param > 0) weight_param else 0
        set(value) {
            field = if (value > 0) value else 0
        }

    // toString method
    override fun toString( ) : String {
        return "$name;$breed;$weight"
    }
}

//--------------------------------------
// Example 16.
// Source code file: Test1.kt
fun main( ) {
    var dog1 = Dog("Bentley", "Bernese Mountain Dog", 115)
    println(dog1)
    println(dog1.name + " " + dog1.breed + " " + dog1.weight)

    var dog2 = Dog("", "Cocker Spaniel", -20)
    println(dog2)
    println(dog2.name + " " + dog2.breed + " " + dog2.weight)
    dog2.weight = 85
    println(dog2.weight)
}

Why is wrong with these lines of code for defining a setter?

var weight = weight_param
    set(value) {
       if (value > 0) weight = value
    }
}

To the Dog class in Example 16, add and test this property that is not initialized with a constructor parameter:
```
var vaccinated = false;
```
When a Dog object is created, it is initially unvaccinated. To vaccinate the dog, the use the setter for vaccinated:
```
dog1.vaccinated = true
```

Secondary Constructors

Kotlin classes can use secondary constructors, which must call the primary constructor.

Example 17.

// Example 17.
// Source code file: Person.kt
class Person(var name : String, 
             var gender : Char, var age : Int) {

    // In the secondary constructor, 
    // this refers to the primary constructor.
    constructor(name : String) : this(name, "U", -1)
  
    override fun toString( ) : String {
        return "$name; $gender; $age"
    }
}

// Example 17.
// Source code file: Main.kt
fun main( ) {
    var p1 = Person("Alice", 'F', 11)
    var p2 = Person("Bob")
    println(p1)
    println(p2)
}

Many authors do not recommend secondary constructors; they recommend default parameters for the primary constructor instead. For example:

class Person(var name : String, var gender : Char = 'U', 
             var age : Int = -1) {
    // body of constructor goes here
}

More Collections

The Map and MutableMap collections:

// Example 18
// Source code file: Test1
// Once a MutableMap collection is created,
// it cannot be modified.
fun main( ) {
    var m1 : Map<String, String> = mapOf("C001" to "Green Beans",
        "C002" to "Quinoa Salad", "C003" to "Garlic Hummus")
    println(m1)
    println(m1.getValue("C002"))
    for ((key, value) in m1) {
        println("{$key=$value}")  
    }
    // Show that these statements cause errors:
    // m1.put("C004", "Frozen Spinach")
    // m1.remove("C001")
    // m1.clear( )

    var m2 : MutableMap<String, String> = mutableMapOf(
        "C001" to "Green Beans", "C002" to "Quinoa Salad",
        "C003" to "Garlic Hummus")
    println(m2)
    println(m2.getValue("C002"))
    for ({key, value} in m2) {
        println("($key=$value)")  
    }
    m2.put("C004", "Frozen Spinach")
    println(m2)
    m2.remove("C001")
    println(m2)
    m2.clear( )
    println(m2)
}

The Set and MutableSet collections are like the List and MutableList collections, with the difference that Set and MutableSet cannot contain duplicate items.

// Example 19
// Source code file: Test1.kt
fun main( ) {

    // Create s1 as a set of prime numbers.
    var s1 : Set<Int> = setOf(2, 3, 5, 7, 11, 13, 17)
    println(s1)
    println(s1.elementAt(2))
    println(s1.indexOf(13))

    // Create s2
    var s2 : Set<Int> = setOf(2, 4, 6, 8, 10)
    println(s2)
    println(s1.intersect(s2))
    println(s1.union(s2))

    // For Set objects a and b, a == b returns
    // true of a and b contain the same objects,
    // not necessarily in the same order.
    // To see if a and b are the same object,
    // use the === operator.
    var s3 : Set<Int> = setOf(2, 4, 8, 6, 10)
    println("${s1 == s2} ${s2 == s3}")

    var s4 : MutableSet<Int> = mutableSetOf(2, 3, 5, 7, 9)
    println(s4)
    for(item in s4) {
        print("$item, ")
    }
    s4.add(11)
    s4.remove(2)
    println("\n" + s4)
    s4.clear( )
    println(s4)

Notice that the keys used to insert items into a Map or a MutableMap form a set because duplicate keys are not allowed.

Inheritance

Kotlin inheritance is similar to Java inheritance. However, instead of using the Java extends keyword, Kotlin uses the symbol : to mark inheritance. If A is the base class and B is the derived class, then the class B is implemented like this:

class B(var x : Int, var y : Int) : A(x) {
    // body of class B goes here.
}

The class B has the Int instance variables x and y. In addition to specifying A as the base class, the parameter x is passed to the A constructor.

----------------------------------------
// Example 20
// Source Code File: Animal.k1
// Animal is the base class.  It is marked by the keyword
// open, which means that this class is open to being
// inherited from.
open class Animal(val breed : String, var age : Int) {

    // vaccinated is an instance variable not initialized
    // by a constructor parameter
    var vaccinated = false

    // The triple quotes """ work like Python. New line
    // characters can be included inside the quotes.
    override fun toString(): String {
        return """Breed: $breed
Age: $age
Vaccinated: $vaccinated"""
    }
}
----------------------------------------
// Example 20
// Source Code File: animal.kt
class Pet(val name: String, breed: String,
    age: Int, var owner: String) : Animal(breed, age) {

    override fun toString( ) : String {
        return """Name: $name
Owner: $owner
"""    + super.toString( )
    }
}
----------------------------------------

// Example 20
// Source Code File: Test1.kt
fun main( ) {
    var a1 = Animal("Dog", 3)
    println(a1)
    a1.vaccinated = true
    println(a1)
    println( )

    var p1 = Pet("Shadow", "Cat", 3, "Julie")
    println(p1)
    p1.vaccinated = true
    println(p1)
}
----------------------------------------

Nullable Types

By default, Kotlin does not allow null to be assigned to a variable.
To be able to be assigned the value a null, a variable must be declared as nullable:
```
var d : Dog? = null
```
The ? means that the variable d is nullable, which means that the instance variable d can be assigned the value null. This means that d does not contain a reference to any object.
Making a variable nullable makes bugs in code more likely, so use with care.
If the variable d is declared as nullable, there are two ways of using this variable.
1. Make a safe call, which means that if the object d is assigned to null, the statement
```
println(d?.weight)
```
  will also output null.
2. Make a non-null assertion call. The statement
```
println(d!!.weight)
```
  means that the programmer is aware that the variable d is declared as nullable, but guarentees that the value of d is not null. If, in fact, d is null, an exception will be thrown.

Anonymous and Lambda Functions

An anonymous function is a function without a name.
A lambda function is an anonymous function defined using arrow notation.

Start with this Kotlin function:

fun makeGreeting(name : String) : String {
    return "Hello, $name, how are you?"
}

The same function written as an anonymous function assigned to the variable f:

var f = fun(name : String) : String {
    return "Hello, $name, how are you?"
}

The same function written as a lambda function:

var f = { name : String -> "Hello, $name, how are you?" }

If a lambda function has no parameters, the arrow is omitted:

// This function in arrow notation with no parameters
var f = { ( ) -> "Hello, how are you?" }
// can be simplified to this:
var f = { "Hello, how are you?" }

If a function has exactly one parameter, it can stand in for that parameter:
```
var f : (String) -> String = { "Hello, ${it}, how are you?" }
println(f("Alice"))
```
The type of f is specified by (String) -> String. This is needed for the compiler to know that the datatype of it is String.

Lambda functions can be passed as arguments to other functions. Here is an example:

// Example 21
// Source Code File: TestConvert.kt
// Test the convert function.
fun main( ) { 
    println(convert(2.0, inToCm))
    println(convert(20.0, celToFahr)) 
} 

// Function to convert inches to centimeters: 
var inToCm = { inches : Double -> 2.54 * inches }

// Function to convert Celsius temperature to Fahrenheit
var celToFahr = { cel : Double -> (9.0/5.0) * cel + 32 }

// The convert function accepts a function as a parameter 
var convert = fun(value : Double, 
    f: (Double) -> Double) : Double { 
    return f(value) 
}

We can simplify the main function by using anonymous functions instead of inToCm and celToFahr:

fun main( ) {
    // If the last argument of a function is an anonymous function,
    // enclose the body of the anonymous function with braces and
    // denote the argument by it.
    println(convert(2.0) { 2.54 * it })
    println(convert(20.0) { (9.0/5.0) * it + 32.0 })

}

For the previous main method to work, the anonymous function must be the last argument of the convert method: the anonymous function's body is enclosed in braces, the other arguments (in this case the value to convert) are inside the parentheses.
Kotlin has several built in methods that accept lambda functions as arguments. Here is a partial list:
```
List methods: max  min  maxBy  minBy
filter  filterNot  forEach  groupBy
```

A Kotlin Android App: TempConverter5

Implement the Kotlin Android App with these source code files:

---------------------------------------------------
<?xml version="1.0" encoding="utf-8"?>

<!-- TempConverter5 Example
     Source Code File: activity_main.xml -->

<androidx.constraintlayout.widget.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/main"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <EditText
        android:id="@+id/edt_cel"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginTop="50dp"
        android:ems="10"
        android:inputType="numberSigned"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

    <Button
        android:id="@+id/button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginTop="50dp"
        android:text="Convert to Fahrenheit"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/edt_cel" />

    <TextView
        android:id="@+id/txt_fahr"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginTop="50dp"
        android:text="TextView"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/button" />

</androidx.constraintlayout.widget.ConstraintLayout>

---------------------------------------------------

// TempConverter Example
// Source Code File: MainActivity.java
package it372.sjost.tempconverter5
import android.os.Bundle
import android.widget.Button
import android.widget.EditText
import android.widget.TextView
import androidx.appcompat.app.AppCompatActivity
class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // Create Kotlin objects for widgets
        var edtCel = findViewById<EditText>(R.id.edt_cel)
        var button = findViewById<Button>(R.id.button);
        var txtFahr = findViewById<TextView>(R.id.txt_fahr)

        // Set onClick listener for button.
        button.setOnClickListener {
            var cel = edtCel.getText( ).toString( ).toInt( )
            var fahr = cel * (9.0/5.0) + 32.0
            txtFahr.setText(fahr.toString( ))
        }
    }
}
---------------------------------------------------