Introduction to Koltin for Android Part I

& Android
Android Best Practices and Advance Kotlin
Kotlin and Android 1

About Me
• Muhammad Atif
• Work at Telenor
• My favorite language is Java & Kotlin
• Love Hiking

Table of Content
Basic Syntax
Advance Kotlin
Android Best Pratices

What Kotlin is Not

Kotlin programming language, design goals
• Concise:
• Reduce the amount of code
• Safe
• No more NullPointerExceptions
• Val name = data?.getStringExtra(NAME)
• Interoperable
• Use existing libraries for JVM (like Android API)
• Compile to JVM or JavaScript
• Tool-friendly
• Support for the programmer using editors (like Android Studio)

Kotlin, a little syntax
• Semicolons are optional
• Adding a new-line is generally enough
• Variables and constants
• var name = ”Atif” // variable
• var means ”variable”
• val name2 = ” Atif” // read-only (constant)
• val means ”value”
• Types are not specified explicity by the programmer
• Types are infered by the compiler

• var
• val
• lateinit
• lazy
• getters
• setters
Data types , variable declaration and initialization

• Mutable.
• non-final variables.
• Once initialized, we’re free to
mutate/change the data held by
the variable.
For example, in Kotlin:
var myVariable = 1
• read-only/nonmutable/imutable.
• The use of val is like declaring a
new variable in Java with
the final keyword.
For example, in Kotlin:
val name: String = "Kotlin"
Difference b/w var & val Kotlin’s keyword .

• lateinit means late initialization.
• If you do not want to initialize a
variable in the constructor instead
you want to initialize it later
• if you can guarantee the initialization
before using it, then declare that
variable with lateinit keyword.
• It will not allocate memory until
initialized.
• It means lazy initialization.
• Your variable will not be
initialized unless you use that
variable in your code.
• It will be initialized only once
after that we always use the same
value.
How Kotlin Keywords & delegate,
Lateinit & Lazy works?

setters are used for setting value of
the property. Kotlin internally
generates a
default getter and setter for
mutable properties using var.
Property type is optional if it can be
inferred from the initializer.
set(value)
getters are used for getting value of
the property. Kotlin internally
generates a getter for read-only
properties using val. The getter is
optional in kotlin. Property type is
optional if it can be inferred from
the initializer.
get() = value
How Kotlin Properties,getter &
setter works?

Nullable Types and Null Safety in
Kotlin
• Kotlin supports nullability as part of its type System. That means
You have the ability to declare whether a variable can hold a null
value or not.
• By supporting nullability in the type system, the compiler can
detect possible NullPointerException errors at compile time and
reduce the possibility of having them thrown at runtime.
var greeting: String = "Hello, World"
greeting = null // Compilation Error
• To allow null values, you have to declare a variable as nullable by
appending a question mark in its type declaration -
var nullableGreeting: String? = "Hello, World“
nullableGreeting = null // Works
Safety Checks
• Adding is initialized check
if (::name.isInitialized)
• Adding a null Check
• Safe call operator: ?
val name = if(null != nullableName)
nullableName else "Guest“
• Elvis operator: ‘ ?: ’
val b = a?.length ?: -1
• Not null assertion : !! Operator
• Nullability Annotations
@NotNull

Nullability and Collections
• Kotlin’s collection API is built on top of Java’s collection API
but it fully supports nullability on Collections.
Just as regular variables are non-null by default,
a normal collection also can’t hold null values.
val regularList: List<Int> = listOf(1, 2, null, 3) // Compiler Error
• Collection of Nullable Types
val listOfNullableTypes: List<Int?>
= listOf(1, 2, null, 3) // Works
• To filter non-null values from a list of nullable types, you
can use the filterNotNull() function .
val notNullList: List<Int> =listOfNullableTypes.filterNotNull()
var listOfNullableTypes: List<Int?>
listOfNullableTypes = null // Compilation Error
var nullableList: List<Int>?
= listOf(1, 2, 3) nullableList = null // Works
var nullableListOfNullableTypes: List<Int?>?
nullableListOfNullableTypes = null // Works

Kotlin Operators
Just like other languages, Kotlin provides various
operators to perform computations on numbers.
• Arithmetic operators (+, -, *, /, %)
• Comparison operators (==, !=, <, >, <=, >=)
• Assignment operators (+=, -=, *=, /=, %=)
• Increment & Decrement operators (++, --)
Operations on Numeric Types
Expression Translates to
a + b a.plus(b)
a - b a.minus(b)
a * b a.times(b)
a / b a.div(b)
a % b a.rem(b)
a++ a.inc()
a−− a.dec()
a > b
a.compareTo(b)
> 0
a < b
a.compareTo(b)
< 0
a += b a.plusAssign(b)

Kotlin Control Flow
• If-Else Statement
• When Expression(Switch)
• For Loop
• For Each Loop
• While Loop
• do-while loop
• Break and Continue

Kotlin Functions
• Unit returning Functions
Functions which don’t return anything has a return type of Unit.
The Unit type corresponds to void in Java.
fun printAverage(a: Double, b: Double): Unit {
println("Avg of ($a, $b) = ${(a + b)/2}")
}
• Single Expression Functions
fun avg(a: Double, b: Double): Double { return (a + b)/2 }
avg(4.6, 9.0) // 6.8

Kotlin Functions
• Defining and Calling Functions
You can declare a function in Kotlin using the fun keyword.
Following is a simple function that calculates the average of
two numbers .
Syntax:
fun functionName(param1: Type1, param2: Type2,...,
paramN: TypeN): Type {
// Method Body
}
For Example:
fun avg(a: Double, b: Double): Double { return (a + b)/2 }
avg(4.6, 9.0) // 6.8

Kotlin extensions/ Utility Functions
add new function to the classes.
• Can add new function to class without declaring it.
• The new function added behaves like static
• Extensions can become part of your own classes &
predefined classes.
Example:
val firstName=“hello”
val secondName=“hello”
val thirdName=“hello”
fun String.add(firstname :String,secondName:String){
retrun this + firstName+secondName;
}

Kotlin infix Functions
Infix function can be a member function or extension function.
Properties :
• They have single parameter.
• They have prefix of infix.
For example:
infix fun Int.greaterValue(other:Int):Int {
If(this>other){
return this
}else{
return other
}}
val greaterVal= x greaterValue y

Kotlin tailRec[recursive] Functions
Uses recursion in a optimized way.
• Prevents stack over flow exception.
• Prefix of tailrec is used.
For example:
tailrec fun getFibonacciNumber(n: Int, a: BigInteger, b:
BigInteger): BigInteger {
if (n == 0)
return b
}else{
return getFibonacciNumber(n - 1, a + b, a)
}

Object Oriented Kotlin for Android
Classes
• data class User(var name:String,var age:Int)
• Compiler generate getters and setters for java
Interoperability .
• Compiler generate equal() and hashCode().
• Compiler generate copy() method –flexible clone()
replacement.

Classes
Example :
var user1= User(“name1”,10)
var user2=User=(“name1”,10)
If(user1==user2){
println(“equal”)
}else{
println(“not equal”)
}
var newUser=user1.copy()//.copy(name=“name”)

Primary Constructor
• Init block
• Primary constructor with property
• Primary constructor with parameter.
For Example :
data class User(var name:String,var age:Int)

Secondary Constructor
• Init block.
• Keyword constructor.
• Can not declare properties in secondary constructor.
For Example :
data class User(var name:String){
constructor(n:String,id :Int): this(n){
//body
}
}

• primary constructor with param
class Student1(name:String){
init{
println("name of student : ${name}")
}
}
• primary constructor
class Student(var name:String){
init{
}
}
• primary & secondary constructor
class User(var name:String){
init{
}
constructor(n:String,id :Int): this(n){
//body
}
}

Inheritance
• default classes are public .
• final
for inheritance you need to make class ‘open’ in
koltin .
Child classes or derived classes.

Inheritance
• Single level Inheritance
• Multi Level inheritance
• Hierarchical inheritance

Visibility modifier in Kotlin
Kotlin Supports
• Public
• Private
• Internal
• protected

abstract Class, Methods & Properties
Classes can be abstract in Nature.
• abstract key is by default open in nature.
• Abstract class is partially defined class
• Abstract method have no body when
declared
• Abstract property can not be initialized when
declared.
• You can not create instance of abstract class
• You need to override abstract properties &
method in derived class.

Interfaces in Kotlin
Listeners ,call back , services in koltin.
• Interface keyword Is used .
• Short or temporary service.
• Whatever you define in interface is by default abstract
in nature.
• You need to override abstract properties & method in
derived class.
• Interface can contains normal and abstract methods.

Object Declaration and companion Objects
WHAT IS SINGLETON IN KOTLIN.?
• One INSTANCE of class in whole application.
• Single object will be created internally.
• We can not declare “static” variable or objects in kotlin as
compared to java.
• Declare “object”.
• This will create a singleton object for us when programs
runs.
• We can have properties , methods, initializers
• Can not have constructor. i:e we can not create instance
manually.
• Object can have super class, supports inheritance.

Example:
Object Customer{
init{
}
var id:Int=0
fun getId():Integer{
return id;
}
}

Companion Objects.
• Same as object but declared within a particular class.
Example:
Class MyClass{
companion object {
var count:Id=1
fun voidFun(){//body}
}
}

Using the Data Binding Library
Data Binding
• automatically generates the classes required to bind the
views in the layout with your data objects.
• One way data binding.
• Two way data binding.

Using the Data Binding Library
1 way vs. two way Data Binding
• One-way data-binding means the data flows
in a single direction so that whenever the
data changes in a component, it also
updates the view with new data.
• Two-way data binding means data flows in
both directions, it means any change
happens in the view updates the data and
any change happens in the data updates the
view.

Kotlin: no more findViewById(…)
• Import kotlinx.android.synthetic.main.activity_main.*
• activity_main.xml is the name of the layout file
• var word = mainWordEditText.text
• mainWordEditText is the id from the layout file
• mainClearWordsButton.setOnClickListener { /*do something*/ }
• mainClearWordsButton is the id from the layout file

Android Development Best Practices
Here are some additional best practices you should follow when building Android apps:
• Use the recommended Android architecture.
• Always maintain the code quality.
• Create separate layouts for UI elements that will be re-used.
• Detecting and fixing memory leaks in android.
• Always include unit tests.
• Always include functional UI tests.

Android Development Best Practices
• Avoid deep levels in layouts.
• Use the Parcelable class instead of Serializable when passing data in
Intents or Bundles.
• Perform file operations off the UI thread.

Advance Kotlin for Android
• Clean Architecture using MVVM
• Design Patterns
• RXJava2
• Dagger2( Dependency Injection)
• Retrofit
• DataBinding(Google)
• Clean Architecture using MVVM/MVI
• Coroutines /Flow/LiveData
• Koin ( Dependency Injection)
• Retrofit
• DataBinding (Synthetic Kotlin)
PART 2 PART 3
To be continued.!!

Introduction to Koltin for Android Part I

Recommended

More Related Content

What's hot (20)

Similar to Introduction to Koltin for Android Part I (20)

Recently uploaded (20)

Introduction to Koltin for Android Part I