The document provides an introduction to Kotlin programming and its use in Android development. It discusses why Kotlin is a good choice, its key features like interoperability with Java, concise code, and tool support. It also outlines Kotlin constructs like functions, variables, conditionals, loops, classes and objects. The document demonstrates basic Kotlin code examples and how to create an Android app with Kotlin. It positions Kotlin as a growing option for cross-platform apps, services, machine learning and more.

1. Kotlin Basic & Android
Programming
Handled By
Dr.T.Abirami
Associate Professor
Department of IT
Kongu Engineering College Perundurai

2. Why Learn Kotlin?
• Kotlin is 100 percent interoperable with Java.
Hence your Java/Android code works with Kotlin.
• Kotlin allows you to cut off the lines of code by
approximately 40% (compared to Java).
• Learning Kotlin is easy. It is particularly easy if
you already know Java.
• Kotlin is tool-friendly. You can use any Java IDE or
command line to run Kotlin.

3. Present and Future of Kotlin
Present
• Many companies like Netflix, Uber, Trello, Pinterest, Corda, etc
are using Kotlin (along with other programming languages) to
create applications.
• Google's Android team announced Kotlin as an official language
for Android app development.
• You can replace Java code with Kotlin seamlessly. It is 100%
interoperable with Java and Android.
Future
• Cross-platform game development
• Cross-platform mobile application development
• Server-side and microservices
• Data analysis and machine learning
• Embedded system: Arduino/Raspberry Pi to professional
controllers directly

4. Kotlin
• Kotlin is a programming language introduced
by JetBrains
• The main() function in Kotlin is the entry point
to a Kotlin program.
• It supports both procedural programming and
object oriented programming.

5. Program entry point
fun main()
{
println("Hello world!")
}
------------------------------
fun main(args: Array<String>) {
println("Hello World!")
print("Welcome to JavaTpoint")
}

6. fun main(args: Array<String>){
println(10)
println("Welcome to JavaTpoint")
print(20)
print("Hello")
}
10 Welcome to JavaTpoint
20Hello
Kotlin Output

7. Variable Declaration
Kotlin variable is declared using keyword var and val.
• var (Mutable variable): We can change the value of
variable declared using var keyword later in the
program.
• val (Immutable variable): We cannot change the
value of variable which is declared using val keyword.
• var language ="Java"
• val salary = 30000
explicitly specify the type of variable while declaring it.
• var language: String ="Java"
• val salary: Int = 30000

8. Example
• var salary = 30000
• salary = 40000 //execute
Here, the value of variable salary can be changed (from
30000 to 40000) because variable salary is declared
using var keyword.
• val language = "Java"
• language = "Kotlin" //Error
Here, we cannot re-assign the variable language from
"Java" to "Kotlin" because the variable is declared
using val keyword.

9. • val a: Int = 1 // immediate assignment
• val b = 2 // `Int` type is inferred
• val c: Int // Type required when no initializer is
provided
• c = 3 // deferred assignment
var x = 5 // `Int` type is inferred
x += 1

10. val PI = 3.14
var x = 0
fun incrementX() {
x += 1
}

11. fun main(args: Array<String>)
{
val first: Int = 10
val second: Int = 20
val sum = first + second
println("The sum is: $sum")
}

12. Kotlin Input
• standard library function readLine()- is used for reads line
of string input from standard input stream.
fun main(args: Array<String>) {
println("Enter your name")
val name = readLine()
println("Enter your age")
var age: Int =Integer.valueOf(readLine())
println("Your name is $name and your age is $age")
}

13. Example Getting Integer Input
import java.util.Scanner
fun main(args: Array<String>) {
val read = Scanner(System.`in`)
println("Enter your age")
var age = read.nextInt()
println("Your input age is "+age)
}

14. User-defined Function
fun main(args: Array<String>)
{
sum()
print("code after sum")
}
fun sum()
{
var num1 =8
var num2 = 9
println("sum = "+(num1+num2))
}
fun functionName()
{
//body of the code
}

15. • function having two Int parameters
with Int return type:
fun sum(a: Int, b: Int): Int
{
return a + b
}

16. Unit return type can be omitted:
fun printSum(a: Int, b: Int): Unit {
println("sum of $a and $b is ${a + b}")
}

17. Conditional expressions
fun maxOf(a: Int, b: Int): Int {
if (a > b) {
return a
} else {
return b
}
}

18. for loop
Syntax:
for (item in collection)
print(item)
----------------------------------------------------------------
for (i in 1..3)
{
println(i)
}
-----------------------------------------------------------------
Example:
val items = listOf("apple", "banana", "kiwifruit")
for (item in items) {
println(item)
}

19. Kotlin OOPs
• Class and Objects
• Constructors
• Inheritance
• Abstract Class

20. Class in Kotlin
class ClassName
{
// property
// member function
}
class Example
{ // data member private
var number: Int = 5 //
member function
fun calculateSquare(): Int
{
return number*number
}
}

21. Objects in Kotlin
Syntax:
var obj1 = ClassName()
Example e = Example()
//Access data member
e.number
//Access member function e.calculateSquare()

22. class Example
{
// data member
private var number: Int = 5
// member function
fun calculateSquare(): Int
{
return number*number
}
}
fun main(args: Array<String>)
{
// create obj object of Example class
val obj = Example()
println("${obj.calculateSquare()}")
}

23. Constructors in Kotlin
class myClass(valname: String,varid: Int)
{
// class body
}

24. Constructors in Kotlin
class Person(val firstName: String, var age: Int)
{
}
fun main(args: Array<String>)
{
val person1 = Person(“Kongu", 35)
println("First Name = ${person1.firstName}")
println("Age = ${person1.age}")
}

25. Inheritance
open class ParentClass(primary_construct)
{ // common code
}
class ChildClass(primary_construct): ParentClass(primary_construct_initializ)
{
// ChildClass specific behaviours
}

26. import java.util.Arrays
open class ABC
{
fun think ()
{
print("Hey!! i am thiking ")
}
}
class BCD: ABC()
{
// inheritence happend using default constructor
}
fun main(args: Array<String>)
{
var a = BCD()
a.think()
}
Inheritance

27. Kotlin Android

28. import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.widget.Button
import android.widget.EditText
import android.widget.TextView
import android.widget.Toast
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
val button = findViewById<Button>(R.id.button)
val tv = findViewById<TextView>(R.id.textView)
val ed =findViewById<EditText>(R.id.editTextTextPersonName)
button.setOnClickListener {
Toast.makeText(this,"Hi",Toast.LENGTH_LONG).show()
tv.setText("Hello").toString()
val inputValue: String = ed.text.toString()
tv.setText(inputValue).toString()
}
}
}

29. Reference
• https://www.javatpoint.com/kotlin-tutorial
• https://www.programiz.com/kotlin-
programming