Kotlin Fundamentals.pptx

This work is licensed under the Apache 2.0 License
Kotlin Fundamentals

Compose apps are written in
the Kotlin programming
language.
Kotlin is the language that the
majority of professional Android
developers use to build apps.

Kotlin Playground
Write and run Kotlin code in
the browser.
https://play.kotlinlang.org/

Program
A series of instructions for a
computer to perform some
action.
fun main() {
println("Hello, world!")
}
Output:
Hello, world!

Functions
A function is a segment of a program that
performs a specific task.
You can have many functions in your program

main Function
The main function is the entry
point, or starting point, of the
program.
Start here
fun main() {
println("Hello, world!")
}
Output:
Hello, world!

Defining a function
Functions begin with the fun
keyword.
fun displayIntroduction() {
}

Defining a function
Functions have a name so that
they can be called.
}

Defining a function
Functions need a set of parentheses
after the function name in order to
surround the function inputs or
parameters.
}

Defining a function
The curly braces make up the
function body and contain the
instructions needed to execute
a task.
// Body
}

Putting it together
fun main() {
firstFunction() // Call a function
}
// Define a function
fun firstFunction() {
// Function Body
}

Basic data types
Kotlin Data type What kind of data it can contain Example literal values
String Text
“Add contact”
“Search”
Int Whole integer number
32
-59873
Double Decimal number
2.0
-37123.9999
Float
Decimal number (less precise than a Double).
Has an f or F at the end of the number.
5.0f
-1630.209f
Boolean
true or false. Use this data type when there
are only two possible values.
true
false

A container for a single piece of
data.
Variables

val keyword
Use when you expect the variable value will
not change.
Example: name
var keyword
Use when you expect the variable value can
change.
Example: age
Defining a variable

Defining a variable
Variables start with a var or val
keyword.
fun main() {
val name: String = "Bhavye"
var age: Int = 20
}

Defining a variable
All variables must have a name.
fun main() {
val name: String = "Meghan"
var age: Int = 28
}

Defining a variable
Data type is the type of data
that the variable holds.
fun main() {
var age: Int = 28
}

Defining a variable
The initial value is the value that
is stored in the variable.
fun main() {
var age: Int = 28
// val name = “Meghan”
// var age = 28
}

Defining a variable
If we want to define a variable
with no initial value.
fun main() {
val name: String
var age: Int
// var age => Error
}

Nullability
When we don’t want to assign any value
to a variable, we use ‘null’.
fun main() {
val favoriteActor =
null
}

fun main() {
var favoriteActor :
String = "SRK"
favoriteActor = null
}
⇒ Error generated
Non-nullable and nullable
variables
Nullable types are variables that
can hold null.
Non-null types are variables that
can't hold null.

How to declare a
nullable variable
To declare a nullable variable, you need to explicitly add the nullable type. For
example String?
fun main() {
var favoriteActor:
String? = "Hello"
favoriteActor = null
}

How to handle nullable variables
fun main() {
var favoriteActor: String? = “SRK”
println(favoriteActor.length) // ⇒ Error
println(favoriteActor?.length) // ⇒ No
error
}

Return Value
We have to mention what has to
be returned by the function by
providing the data type for it.
If a function does not return
anything then it is having ‘Unit’
return type
fun firstFunction() : String {
// Body
return “value”
}

Parameters
We can define various parameters or inputs for the function
fun firstFunction(age : Int): Int{
// body
return age
}
fun main(){
// calling the function
}

Function with multiple
parameters
fun firstFunction(age : Int, name : String){
// body
}
fun main(){
firstFucntion(21, “bhavye”)
}

Named arguments
fun firstFunction(age : Int, name : String){
// body
}
fun main(){
firstFunction(name = “bhavye”, age = 20)
}
We need to keep in mind the order of parameters while passing the
arguments so we can use named arguments.

Function with default parameters
fun firstFunction(age : Int, name : String = “noName”){
// body
}
fun main(){
firstFucntion(21, “bhavye”)
firstFunction(21)
}

Arrays
● An array contains multiple values called elements, or sometimes, items.
● The elements in an array are ordered and are accessed with an index.
An array has a fixed size. This means that we can't add elements to an array
beyond this size. We can, however, modify the values at indexes in the array.

val rockPlanets = arrayOf<String>("Mercury", "Venus", "Earth",
"Mars")
println(rockPlanets[0])
Declaration of an Array

Lists
A list is an ordered, resizable collection, typically implemented as a resizable array.
When the array is filled to capacity and you try to insert a new element, the array
is copied to a new bigger array.

listOf()
fun main() {
val solarSystem = listOf("Mercury", "Venus", "Earth",
"Mars", "Jupiter", "Saturn", "Uranus", "Neptune")
println(solarSystem.size)
println(solarSystem.get(3))
println(solarSystem.indexOf("Earth"))
// What happens when we try to find index of an item not
present in the list?
}

val solarSystem = mutableListOf("Mercury", "Venus", "Earth",
solarSystem.add("Pluto")
solarSystem.add(3, "Theia")
solarSystem[3] = "Future Moon"
solarSystem.removeAt(9)
solarSystem.remove("Future Moon")
println(solarSystem.contains("Pluto"))

Sets
A set is a collection that does
not have a specific order and
doesn't allow duplicate values.

val solarSystem = mutableSetOf("Mercury", "Venus", "Earth",
solarSystem.remove("Pluto")
println(solarSystem.contains("Pluto"))

If Statements

If statement :
if (condition) {
}
If/else statement :
if(condition) {
}
else {
}
1.
2.
Else if condition :
if(condition){
}
else if(condition){
}
3.

if/else as an expression :
if(condition)
println(“Text1”)
else println(“Text2”)
message = if(
condition) “Text1”
else
“Text2”
println(message)

When Statement
When statements are preferred when there are more than two branches to consider

fun main() {
val x: Any = 20
when (x) {
2, 3, 5, 7 -> println("x is a prime number between 1 and 10.")
in 1..10 -> println("x is a number between 1 and 10, but not a
prime number.")
is Int -> println("x is an integer number, but not between 1
and 10.")
else -> println("x isn't an integer number.")
}
}
Output:
x is an integer number, but not between 1 and 10.

Classes
A class consists of three major parts :
● Properties. Variables that specify the attributes
of the class's objects.
● Methods. Functions that contain the class's
behaviors and actions.
● Constructors. A special member function that
creates instances of the class throughout the
program in which it's defined.
class Student {
// empty body
}
fun main() {
}
Classes provide blueprints from which objects can be constructed. An object
is an instance of a class that consists of data specific to that object.

Class Objects or Instances
class Student {
// empty body
}
fun main() {
val student1 = Student()
}

Class Methods
class Student {
fun printStudent(){
println(“I am a Student”)
}
}
fun main() {
student1.printStudent()
}

Class Properties
class Student {
var name: String
fun printStudent(){
println(name)
}
}
fun main() {
Student1.name = “Bhavye”
student1.printStudent()
}

Quiz Time!

Break Time!

Kotlin Fundamentals.pptx

Recommended

Recommended

More Related Content

Similar to Kotlin Fundamentals.pptx

Similar to Kotlin Fundamentals.pptx (20)

Recently uploaded

Recently uploaded (20)

Kotlin Fundamentals.pptx

Editor's Notes