Kotlin- Basic to Advance

Indroduction
Kotlin is a new open source programming language like Java, JavaScript,
etc. It is a high level strongly statically typed language that combines
functional and technical part in a same place. Currently, Kotlin targets Java
and JavaScript. It runs on JVM.
Kotlin is influenced by other programming languages such as Java, Scala,
Groovy, Gosu, etc. The syntax of Kotlin may not be exactly similar to JAVA,
however, internally Kotlin is reliant on the existing Java Class library to produce
wonderful results for the programmers. Kotlin provides interoperability, code
safety, and clarity to the developers around the world.

Advantages & Disadvantages
Easy Language: Kotlin is a functional language and very easy to
learn. The syntax is pretty much similar to Java, hence it is very
easy to remember. Kotlin is more expressive, which makes your
code more readable and understandable.
Concise: Kotlin is based on JVM and it is a functional language.
Thus, it reduce lots of boiler plate code used in other
programming languages.
Runtime and Performance: Better performance and small
runtime.
Interoperability: Kotlin is mature enough to build an
interoperable application in a less complex manner.
Brand New: Kotlin is a brand new language that gives developers
a fresh start. It is not a replacement of Java, though it is
developed over JVM. It is accepted as the first official language of
android development. Kotlin can be defined as - Kotlin= JAVA
+extra updated new features.
Namespace declaration: Kotlin allows developers
to declare the functions at the top level. However,
whenever the same function is declared in many
places of your application, then it is hard to
understand which function is being called.
No Static Declaration: Kotlin does not have usual
static handling modifier like Java, which can cause
some problem to the conventional Java developer.

Kotlin Environment Setup (Online Compiler)

Kotlin - Architecture
Kotlin compiler creates a byte code and that byte code can run on
the JVM, which is exactly equal to the byte code generated by the
Java .class file. Whenever two byte coded file runs on the JVM,
they can communicate with each other and this is how an
interoperable feature is established in Kotlin for Java.
Whenever Kotlin targets JavaScript, the Kotlin compiler converts
the .kt file into ES5.1 and generates a compatible code for
JavaScript. Kotlin compiler is capable of creating platform basis
compatible codes via LLVM.

Kotlin - Basic Types
Numbers: The representation of numbers in Kotlin is pretty similar to
Java, however, Kotlin does not allow internal conversion of different
data types.
Type Size
Double 64
Float 32
Long 64
Int 32
Short 16
Byte 8

Characters
Kotlin represents character using char. Character should be declared in a single quote like ‘c’. Please
enter the following code in our coding ground and see how Kotlin interprets the character variable.
Character variable cannot be declared like number variables. Kotlin variable can be declared in two ways -
one using “var” and another using “val”.
Example:
fun main(args: Array<String>) {
val letter: Char // defining a variable
letter = 'A' // Assigning a value to it
println("$letter")
}
OUTPUT: A

Boolean
Boolean is very simple like other programming languages. We have only two values for
Boolean – either true or false.
Example:
val letter: Boolean // defining a variable
letter = true // Assinging a value to it
println("Your character value is "+"$letter")
}
Output: Your character value is true

Strings
Strings are character arrays. Like Java, they are immutable in
nature. We have two kinds of string available in Kotlin - one is
called raw String and another is called escaped String.

Important Properties and Functions of Kotlin String:
length : This is a property that can be accessed using the dot operator on the String. Returns the number
of characters present in a string.
Code: val str = "Hello Kotlin Strings"
println(str.length) //prints 20
get(index) : Returns the character specified at the particular index.
subSequence(startIndex, endIndex) : Returns the substring between the startIndex and the endIndex but
excluding the endIndex character.
val str = "Hello Kotlin Strings"
println(str.subSequence(0,5)) //prints Hello
a.compareTo(b) : If a is equal to b, it returns 0, if a<b it returns positive number. compareTo accepts
another argument too, namely ignoreCase.
var str = "Hello Kotlin Strings"
var s = String()
s = "Hello KOTLIN Strings"
println(s.compareTo(str)) //prints -32
println(s.compareTo(str,true)) //prints 0

Example:
var rawString :String ="I am Raw String!"
val escapedString : String ="I am escaped String!n"
println("Hello!"+escapedString)
println("Hey!!"+rawString)
}
Output: Hello!I am escaped String!
Hey!!I am Raw String!

Arrays
Arrays are a collection of homogeneous data. Like Java,
Kotlin supports arrays of different data types.

Example: fun main(args: Array<String>) {
val numbers: IntArray = intArrayOf(1, 2, 3, 4, 5)
println("Hey!! I am array Example"+numbers[2])
}
Output: Hey!! I am array Example3

Collections
Collection is a very important part of the data structure, which
makes the software development easy for engineers. Kotlin has
two types of collection - one is immutable collection (which
means lists, maps and sets that cannot be editable) and another is
mutable collection (this type of collection is editable). It is very
important to keep in mind the type of collection used in your
application, as Kotlin system does not represent any specific
difference in them.

val numbers: MutableList<Int> = mutableListOf(1, 2, 3) //mutable List
val readOnlyView: List<Int> = numbers // immutable list
println("my immutable list--"+numbers) // prints "[1, 2, 3]"
numbers.add(4)
println("my immutable list after addition --"+numbers) // prints "[1, 2, 3, 4]"
println(readOnlyView)
readOnlyView.clear() // -> does not compile
// gives error
}
Output: Error:(8, 13) Unresolved reference: clear
(The above piece of code will yield the following output in the browser. It gives an error when we try
to clear the mutable list of collection. )

In collection, Kotlin provides some useful methods such as first(),
last(), filter(), etc. All these methods are self-descriptive and easy
to implement. Moreover, Kotlin follows the same structure such as
Java while implementing collection. You are free to implement any
collection of your choice such as Map and Set.

val items = listOf(1, 2, 3, 4)
println("First Element of our list----"+items.first())
println("First Element of our list----"+items.last())
println("Even Numbers of our List----"+items.filter { it % 2 == 0 }) // returns [2, 4]
val readWriteMap = hashMapOf("foo" to 1, "bar" to 2)
println(readWriteMap["foo"]) // prints "1"
val strings = hashSetOf("a", "b", "c", "c")
println("My Set Values are"+strings)
}
Output: First Element of our list----1
First Element of our list----4
Even Numbers of our List----[2, 4]
1
My Set Values are[a, b, c]

Ranges
Ranges is another unique characteristic of Kotlin.
Like Haskell, it provides an operator that helps
you iterate through a range. Internally, it is
implemented using rangeTo() and its operator
form is (..).

val i:Int =2
for (j in 1..4)
print(j) // prints "1234"
if (i in 1..10) { // equivalent of 1 <= i && i <= 10
println("we found your number --"+i)
}
}
Output: 1234we found your number --2

If - Else
Kotlin is a functional language hence like every functional
language in Kotlin “if” is an expression, it is not a keyword.
The expression “if” will return a value whenever necessary.
Like other programming language, “if-else” block is used as
an initial conditional checking operator.

val a:Int=5
val b:Int=2
var max: Int
if (a > b) {
max = a
} else {
max = b
}
print("Maximum of"+max)
// As expression
// val max = if (a > b) a else b
}
Output: Maximum of 5

Use of When
If you are familiar with other programming languages,
then you might have heard of the term switch
statement, which is basically a conditional operator
when multiple conditions can be applied on a particular
variable. “when” operator matches the variable value
against the branch conditions. If it is satisfying the
branch condition then it will execute the statement
inside that scope.

val x:Int=5
when (x) {
1 -> print("x == 1")
2 -> print("x == 2")
else -> { // Note the block
print("x is neither 1 nor 2")
}
}
}
Output: x is neither 1 nor 2

In the above example, Kotlin compiler
matches the value of x with the given
branches. If it is not matching any of the
branches, then it will execute the else part.
Practically, when is equivalent to multiple if
block. Kotlin provides another flexibility to
the developer, where the developer can
provide multiple checks in the same line by
providing “,” inside the checks.

val x:Int=5
when (x) {
1,2 -> print(" Value of X either 1,2")
else -> { // Note the block
print("x is neither 1 nor 2")
}
}
}
Output: x is neither 1 nor 2

For Loop
Loop is such an invention that provides the
flexibility to iterate through any kind of data
structure. Like other programming languages,
Kotlin also provides many kinds of Looping
methodology, however, among them “For” is the
most successful one. The implementation and use
of For loop is conceptually similar to Java for loop.

val items = listOf(1, 2, 3, 4)
for (i in items) println("values of the array"+i)
}
Output:
values of the array1

While Loop and Do-While Loop
While and Do-While work exactly in a similar way like they do in
other programming languages. The only difference between these
two loops is, in case of Do-while loop the condition will be tested at
the end of the loop.

var x:Int=0
println("Example of While Loop--")
while(x<=10){
println(x)
x++
}
}
Output: Example of While Loop-- 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10

Kotlin also has another loop called Do-While
loop, where the loop body will be executed once,
only then the condition will be checked.

var x:Int=0
do{
x=x+10
println("I am inside Do block---"+x)
}while(x<=50)
}
Output:
I am inside Do block---10

Use of Return, Break, Continue
If you are familiar with any programming
language, then you must have an idea of different
keywords that help us implement good control
flow in the application. Following are the different
keywords that can be used to control the loops or
any other types of control flow.

Return:
Return is a keyword that returns some value to the calling function from the called function.
Input:
var x:Int=10
println("The value of X is--"+doubleMe(x))
}
fun doubleMe(x:Int):Int{
return 2*x;
}
Output: The value of X is--20

Continue & Break:
Continue and break are the most vital part of a
logical problem. The “break” keyword terminates the
controller flow if some condition has failed and
“continue” does the opposite. All this operation
happens with immediate visibility. Kotlin is smarter
than other programming languages, wherein the
developer can apply more than one label as visibility.

println("Example of Break and Continue")
myLabel@ for(x in 1..10){ // appling the custom label
if(x==5){
println("I am inside if block with value"+x+"n-- hence it will close the operation")
break@myLabel //specifing the label
}else{
println("I am inside else block with value"+x)
continue@myLabel
}
}
}

Output:
Example of Break and Continue
I am inside else block with value1
I am inside if block with value5
-- hence it will close the operation

As you can see, the controller continues the loop, until and unless
the value of x is 5. Once the value of x reaches 5, it starts
executing the if block and once the break statement is reached, the
entire control flow terminates the program execution.

Class & Object
By definition of OOP, a class is a blueprint of a runtime entity
and object is its state, which includes both its behavior and
state. In Kotlin, class declaration consists of a class header
and a class body surrounded by curly braces, similar to Java.
Ex: Class myClass {// class Header
// class Body
}

class myClass {
// property (data member)
private var name: String = "Coder Tech"
// member function
fun printMe() {
print("You are at the best Learning website Named:-"+name)
}
}
val obj = myClass() // create obj object of myClass class
obj.printMe()
}
Output: You are at the best Learning website Named:-Coder Tech

Nested Class
When a class has been created inside another
class, then it is called as a nested class. In Kotlin,
nested class is by default static, hence, it can be
accessed without creating any object of that class.

val demo = Outer.Nested().foo() // caling nested class method
print(demo)
}
class Outer {
class Nested {
fun foo() = "Welcome to The Coder Tech.in"
}
}
Output: Welcome to The Coder Tech.in

Inner Class
When a nested class is marked as a “inner”, then
it will be called as an Inner class. An inner class
can be accessed by the data member of the outer
class.

val demo = Outer().Nested().foo() // caling nested class method
print(demo)
}
class Outer {
private val welcomeMessage: String = "Welcome to the codertech.in"
inner class Nested {
fun foo() = welcomeMessage
}
}
Output: Welcome to the codertech.in

Anonymous Inner Class
Anonymous inner class is a pretty good concept
that makes the life of a programmer very easy.
Whenever we are implementing an interface, the
concept of anonymous inner block comes into
picture. The concept of creating an object of
interface using runtime object reference is known
as anonymous class.

var programmer :Human = object:Human // creating an instance of the interface
{
override fun think(){ // overiding the think method
print("I am an example of Anonymous Inner Class ")
}
}
programmer.think()
}
interface Human{
fun think()
}
Output: I am an example of Anonymous Inner Class

Type Aliases
It provides the flexibility of creating a new name of an existing
type, it does not create a new type. If the type name is too long,
you can easily introduce a shorter name and use the same for
future usage. Type aliases is really helpful for complex type.
Ex:
typealias NodeSet = Set<Network.Node>
typealias FileTable<K> = MutableMap<K, MutableList<File>>

Constructors
Kotlin has two types of constructor - one is the primary
constructor and the other is the secondary constructor.
One Kotlin class can have one primary constructor, and one
or more secondary constructor.
Java constructor initializes the member variables, however, in
Kotlin the primary constructor initializes the class, whereas the
secondary constructor helps to include some extra logic while
initializing the same.

The primary constructor can be declared at class header level as shown in the following example:
Ex:
class Person(val firstName: String, var age: Int) {
// class body
}
In the above example, we have declared the primary constructor inside
the parenthesis. Among the two fields, first name is read-only as it is
declared as “val”, while the field age can be edited.

val person1 = Person("punit pandey", 25)
println("First Name = ${person1.firstName}")
println("Age = ${person1.age}")
}
class Person(val firstName: String, var age: Int) {
}
Output:
First Name = punit pandey
Age = 25

Kotlin allows to create one or more secondary
constructors for your class. This secondary
constructor is created using the “constructor”
keyword. It is required whenever you want to
create more than one constructor in Kotlin or
whenever you want to include more logic in
the primary constructor and you cannot do that
because the primary constructor may be
called by some other class.

val HUman = HUman("codertech.in", 25)
print("${HUman.message}"+"${HUman.firstName}"+"Welcome to the example of
Secondary constructor, Your Age is-${HUman.age}")
}
class HUman(val firstName: String, var age: Int) {
val message:String ="Hey!!!"
constructor(name : String , age :Int ,message :String):this(name,age){
}
}
Output:
Hey!!!codertech.inWelcome to the example of Secondary constructor, Your Age is-25

Note: Any number of secondary
constructors can be created,
however, all of those constructors
should call the primary constructor
directly or indirectly.

Inheritance
we all know that inheritance means accruing some properties of
the mother class into the child class. In Kotlin, the base class is
named as “Any”, which is the super class of the ‘any’ default
class declared in Kotlin. Like all other OOPS, Kotlin also
provides this functionality using one keyword known as “:”.
Everything in Kotlin is by default final, hence, we need to use
the keyword “open” in front of the class declaration to make it
allowable to inherit.

import java.util.Arrays
open class ABC{
fun think (){
print("Hey!! i am thiking ")
}
}
class BCD: ABC(){ // inheritence happend using default constructor
}
var a=BCD()
a.think()
}
Output:
Hey!! i am thiking

Now, what if we want to override the think()
method in the child class. Then, we need to
consider the following example where we are
creating two classes and override one of its
function into the child class.

import java.util.Arrays
open class ABC{
open fun think (){
print("Hey!! i am thinking ")
}
}
class BCD: ABC(){ // inheritance happens using default constructor
override fun think(){
print("I Am from Child")
}
}
var a=BCD()
a.think()
}
Output: I Am from Child

Interface
In Kotlin, the interface works exactly similar to Java 8, which
means they can contain method implementation as well as
abstract methods declaration. An interface can be
implemented by a class in order to use its defined functionality.
We have already introduced an example with an interface in
Chapter 6 - section “anonymous inner class”. In this chapter,
we will learn more about it. The keyword “interface” is used to
define an interface in Kotlin

interface ExampleInterface {
var myVar: String // abstract property
fun absMethod() // abstract method
fun sayHello() = "Hello there" // method with default implementation
}
In the above example, we have created one interface named as
“ExampleInterface” and inside that we have a couple of abstract
properties and methods all together. Look at the function named
“sayHello()”, which is an implemented method.

interface ExampleInterface {
var myVar: Int // abstract property
fun absMethod():String // abstract method
fun hello() {
println("Hello there, Welcome to codertech.in!")
}
}
class InterfaceImp : ExampleInterface {
override var myVar: Int = 25
override fun absMethod() = "Happy Learning "
}

val obj = InterfaceImp()
println("My Variable Value is = ${obj.myVar}")
print("Calling hello(): ")
obj.hello()
print("Message from the Website-- ")
println(obj.absMethod())
}
Output:
My Variable Value is = 25
Calling hello(): Hello there, Welcome to codertech.in!
Message from the Website-- Happy Learning

As mentioned earlier, Kotlin doesn’t support
multiple inheritances, however, the same thing
can be achieved by implementing more than two
interfaces at a time.
In the following example, we will create two
interfaces and later we will implement both the
interfaces into a class.

interface A {
fun printMe() {
println(" method of interface A")
}
}
interface B {
fun printMeToo() {
println("I am another Method from interface B")
}
}

// implements two interfaces A and B
class multipleInterfaceExample: A, B
val obj = multipleInterfaceExample()
obj.printMe()
obj.printMeToo()
}
Output:
method of interface A
I am another Method from interface B

Visibility Control
Access modifier is used to restrict the usage of
the variables, methods and class used in the
application. Like other OOP programming
language, this modifier is applicable at multiple
places such as in the class header or method
declaration. There are four access modifiers
available in Kotlin.

Private
The classes, methods, and packages can be
declared with a private modifier. Once anything is
declared as private, then it will be accessible
within its immediate scope. For instance, a private
package can be accessible within that specific file.
A private class or interface can be accessible only
by its data members, etc.

private class privateExample {
private val i = 1
private val doSomething() {
}
}
In the above example, the class “privateExample” and the
variable i both can be accessible only in the same Kotlin file, where
its mentioned as they all are declared as private in the declaration
block.

Protected
Protected is another access modifier for Kotlin,
which is currently not available for top level
declaration like any package cannot be protected.
A protected class or interface is visible to its
subclass only.

class A {
protected val i = 1
}
class B : A() {
fun getValue() : Int {
return i
}
}
In the above example, the variable “i” is declared as protected, hence, it is
only visible to its subclass.

Internal
Internal is a newly added modifier introduced in
Kotlin. If anything is marked as internal, then that
specific field will be in the internal field. An Internal
package is visible only inside the module under
which it is implemented. An internal class
interface is visible only by other class present
inside the same package or the module.

class internalExample{
internal val i=1
internal fun doSomething(){
}
}
In the above example, the method named “doSomething” and the
variable is mentioned as internal, hence, these two fields can be
accessible only inside the package under which it is declared.

Public
Public modifier is accessible from anywhere in the
project workspace. If no access modifier is
specified, then by default it will be in the public
scope. In all our previous examples, we have not
mentioned any modifier, hence, all of them are in
the public scope.

class publicExample {
val i = 1
fun doSomething() {
}
}
In the above example, we have not mentioned any modifier, thus all
these methods and variables are by default public.

Extension
Extensions are resolved statistically. It does not actually
modify the existing class, but it creates a callable function
that can be called with a dot operation.
Function Extension
In function extension, Kotlin allows to define a
method outside of the main class.

class Alien{
var skills: String="null"
fun printMySkills(){
print(skills)
}
}
fun main(args: Array<String>){
var a1=Alien()
a1.skills="java"
//a1.printMySkills()
var a2=Alien()
a2.skills="SQL"
//a2.printMySkills()

var a3=Alien()
a3.skills=a1.addMySkills(a2)
a3.printMySkills()
}
fun Alien.addMySkills(a:Alien):String{
var a4=Alien()
a4.skills=this.skills+""+a.skills
return a4.skills
}
Output:
Java SQL

In the above example, we don’t have any method
inside “Alien” class named as “addMySkills()”,
however, we still are implementing the same
method somewhere else outside of the class, This
is the magic of extension.

Object Extension
Kotlin provides another mechanism to implement
static functionality of Java. This can be achieved
using the keyword “companion object”. Using this
mechanism, we can create an object of a class
inside a factory method and later we can just call
that method using the reference of the class
name.

println("Heyyy!!!"+A.show())
}
class A{
companion object{
fun show():String{
return("You are learning Kotlin from codertech.in")
}
}
}
Output:
Heyyy!!!You are learning Kotlin from codertech.in

The above example seems like static in Java,
however, in real-time we are creating an object as
a member variable of that same class. This is why
it is also included under extension property and
can be alternatively called as an object extension.

Data Classes
●
A class can be marked as a Data class whenever it is marked as
”data”. This type of class can be used to hold the basic data
apart. Other than this, it does not provide any other functionality.
●
All the data classes need to have one primary constructor and all
the primary constructor should have at least one parameter.
Whenever a class is marked as data, we can use some of the
inbuilt function of that data class such as “toString()”,”hasCode()”,
etc. Any data class cannot have a modifier like abstract and open
or internal. Data class can be extended to other classes too.

val book: Book = Book("Kotlin", "codertech.in", 5)
println("Name of the Book is--"+book.name) // "Kotlin"
println("Puclisher Name--"+book.publisher) // "codertech.in"
println("Review of the book is--"+book.reviewScore) // 5
book.reviewScore = 7
println("Printing all the info all together--"+book.toString()) //using inbuilt function of the data class
println("Example of the HasCode function--"+book.hashCode())
}
data class Book(val name: String, val publisher: String, var reviewScore: Int)
Output:
Name of the Book is--Kotlin
Puclisher Name--codertech.in
Review of the book is--5
Printing all the info all together--Book(name=Kotlin, publisher=codertech.in, reviewScore=7)
Example of the HasCode function---302390224

The above piece of code will yield the following
output in the browser, where we have created one
data class to hold some of the data, and from the
main function we have accessed all of its data
members.

Sealed Class
This type of class is used to represent a restricted class
hierarchy. Sealed allows the developers to maintain a
data type of a predefined type. To make a sealed class,
we need to use the keyword “sealed” as a modifier of
that class. A sealed class can have its own subclass but
all those subclasses need to be declared inside the
same Kotlin file along with the sealed class.

sealed class MyExample{
class OP1: MyExample()// MyExample class can be of two types only
class OP2: MyExample()
}
fun main(args: Array<String>){
val obj:MyExample= MyExample.OP1()
val output=when(obj){
is MyExample.OP1->"option one has been chosen"
is MyExample.OP2->"option two has been chosen"
}
println(output)
}
Output:
option one has been chosen

In the above example, we have one sealed class
named “MyExample”, which can be of two types
only - one is “OP1” and another one is “OP2”. In the
main class, we are creating an object in our class
and assigning its type at runtime. Now, as this
“MyExample” class is sealed, we can apply the
“when ” clause at runtime to implement the final
output.
In sealed class, we need not use any unnecessary
“else” statement to complex out the code.

Generics
Like Java, Kotlin provides higher order of variable typing called as
Generics. In this chapter, we will learn how Kotlin implements Generics
and how as a developer we can use those functionalities provided inside
the generics library. Implementation wise, generics is pretty similar to
Java but Kotlin developer has introduced two new keywords “out” and
“in” to make Kotlin codes more readable and easy for the developer.
In Kotlin, a class and a type are totally different concepts. As per the
example, List is a class in Kotlin, whereas List<String> is a type in Kotlin.

val integer: Int = 1
val number: Number = integer
print(number)
}
Output: 1
In the above code, we have declared one “integer” and later we have
assigned that variable to a number variable. This is possible because
“Int” is a subclass of Number class, hence the type conversion happens
automatically at runtime and produces the output as “1”.

It is better to go for generic data type whenever
we are not sure about the data type we are going
to use in the application. Generally, in Kotlin
generics is defined by <T> where “T” stands for
template, which can be determined dynamically
by Kotlin complier.

var objet=genericsExample<String>("JAVA")
var objet1=genericsExample<Int>(10)
}
class genericsExample<T>(input:T){
init{
println("I am getting called with the value "+input)
}
}
Output:
I am getting called with the value JAVA
I am getting called with the value 10

●
In the above piece of code, we are creating one class
with generic return type, which is represented as <T>.
Take a look at the main method, where we have
dynamically defined its value at the run by proving the
value type, while creating the object of this class. This
is how generics is interpreted by Kotlin compiler.
●
When we want to assign the generic type to any of its
super type, then we need to use “out” keyword, and
when we want to assign the generic type to any of its
sub-type, then we need to use “in” keyword.

var objet1=genericsExample<Int>(10)
var object2=genericsExample<Double>(10.00)
println(objet1)
println(objet2)
}
class genericsExample<out T>(input:T){
init{
println("I am getting called with the value "+input)
}
}
Output:
I am getting called with the value 10
I am getting called with the value 10.0
genericsExample@2ff4acd0
genericsExample@54bedef2

Delegation
Kotlin supports “delegation” design pattern by
introducing a new keyword “by”. Using this
keyword or delegation methodology, Kotlin allows
the derived class to access all the implemented
public methods of an interface through a specific
object.

interface Base {
fun printMe() //abstract method
}
class BaseImpl(val x: Int) : Base {
override fun printMe() { println(x) } //implementation of the method
}
class Derived(b: Base) : Base by b // delegating the public method on the object b
val b = BaseImpl(10)
Derived(b).printMe() // prints 10 :: accessing the printMe() method
}
Output: 10

In the example, we have one interface “Base” with
its abstract method named “printme()”. In the
BaseImpl class, we are implementing this
“printme()” and later from another class we are
using this implementation using “by” keyword.

Property Delegation
Delegation means passing the responsibility to another class
or method. When a property is already declared in some
places, then we should reuse the same code to initialize them.
Using Lazy()
Lazy is a lambda function which takes a property as an input
and in return gives an instance of Lazy<T>, where <T> is
basically the type of the properties it is using.

val myVar: String by lazy {
"Hello"
}
println(myVar +" My dear friend")
}
Output: Hello My dear friend
In the above piece of code, we are passing a variable “myVar” to the Lazy
function, which in return assigns the value to its object and returns the same to
the main function.

Delegetion.Observable()
Observable() takes two arguments to initialize the
object and returns the same to the called function.

import kotlin.properties.Delegates
class User {
var name: String by Delegates.observable("Welcome to codertech.in") {
prop, old, new ->
println("$old -> $new")
}
}
val user = User()
user.name = "first"
user.name = "second"
}
Output:
Welcome to codertech.in -> first
first -> second

●
In general, the syntax is the expression after the “by” keyword
is delegated. The get() and set() methods of the variable p will
be delegated to its getValue() and setValue() methods
defined in the Delegate class.
class Example {
var p: String by Delegate()
}
●
For the above piece of code, following is the delegate class
that we need to generate in order to assign the value in the
variable p.

class Delegate {
operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
return "$thisRef, thank you for delegating '${property.name}' to me!"
}
operator fun setValue(thisRef: Any?, property: KProperty<*>, value:
String) {
println("$value has been assigned to '${property.name} in $thisRef.'")
}
}
While reading, getValue() method will be called and while setting the
variable setValue() method will be called.

Functions
We are pretty familiar with function, as we are using
function throughout the examples. Function is declared
with the keyword “fun”. Like any other OOP, it also needs
a return type and an option argument list.

println(MyFunction("codertech.in"))
}
fun MyFunction(x: String): String {
var c:String ="Hey!! Welcome To ---"
return (c+x)
}
Output: Hey!! Welcome To ---codertech.in

The function should be declared as follows -
fun <nameOfFunction>(<argument>:<argumentType>):<ReturnType>
Lambda Function
Lambda is a high level function that drastically
reduces the boiler plate code while declaring a
function and defining the same. Kotlin allows you
to define your own lambda. In Kotlin, you can
declare your lambda and pass that lambda to a
function.

val mylambda :(String)->Unit ={s:String->print(s)}
val v:String="codertech.in"
mylambda(v)
}
Output: codertech.in
In the above code, we have created our own lambda known as “mylambda”
and we have passed one variable to this lambda, which is of type String and
contains a value “codertech.in”.

Inline Function
The above example shows the basic of the lambda
expression that we can use in Kotlin application. Now, we
can pass a lambda to another function to get our output
which makes the calling function an inline function.

val mylambda:(String)->Unit ={s:String->print(s)}
val v:String="codertech.in"
myFun(v,mylambda) //passing lambda as a parameter of another function
}
fun myFun(a :String, action: (String)->Unit){ //passing lambda
print("Heyyy!!!")
action(a)// call to lambda function
}
Output: Heyyy!!!codertech.in
The above piece of code will yield the following output in the browser. Using inline
function, we have passed a lambda as a parameter. Any other function can be made an
inline function using the “inline” keyword.

Destructuring Declarations
Kotlin contains many features of other programming languages. It allows you to
declare multiple variables at once. This technique is called Destructuring declaration.
Following is the basic syntax of the destructuring declaration.
val (name, age) = person
In the above syntax, we have created an object and defined all of them together in a
single statement. Later, we can use them as follows.
println(name)
println(age)
Now, let us see how we can use the same in our real-life application.

val s=Student("codertech.in","Kotlin")
val (name,subject)=s
println("You are learning "+subject+" from "+name)
}
data class Student( val a :String,val b: String ){
var name:String=a
var subject:String=b
}
Output: You are learning Kotlin from codertech.in

Exception Handling
Exception handling is a very important part of a
programming language. This technique restricts our
application from generating the wrong output at
runtime. In this chapter, we will learn how to handle
runtime exception in Kotlin. The exceptions in Kotlin is
pretty similar to the exceptions in Java. All the
exceptions are descendants of the “Throwable” class.

try{
val myVar:Int=12 val v:String="codertech.in"
v.toInt()
}catch(e:Exception){
e.printStackTrace()
}finally{
println("Exception Handeling in Kotlin")
}
}
Output:
Warning:(3, 4) Variable 'myVar' is never used
Error:(3, 15) Unexpected tokens (use ';' to separate expressions on the same line)

In the above piece of code, we have declared a String and later
tied that string into the integer, which is actually a runtime
exception. Hence, we will get the following output in the browser.
Note: Like Java, Kotlin also executes the finally block after
executing the catch block.

Kotlin- Basic to Advance

More Related Content

What's hot (20)

Similar to Kotlin- Basic to Advance (20)

More from Coder Tech (9)

Recently uploaded (20)

Kotlin- Basic to Advance