Introduction to kotlin and OOP in Kotlin

Compiler to Run Kotlin Programs

Hello World!
fun main() { // main function
//code starts here
println("Hello World!")
}

Data Types
● Int
● Char
● String
● Float
● Double
● Long
● Short
● Byte
● Boolean

Variables
● Mutable
Starts with ‘var’ and can be reassigned.
For ex:) var age = 20
● Immutable(Read only)
Starts with ‘val’ and cannot be reassigned.
For ex:) var name = “Jack”

Functions
Syntax:
fun func_name(){
//your code
}
fun sayHello() {
println("Hello")
}
fun main() { // main function
//code starts here
sayHello()
}

Examples
fun sayHello() {
println("Hello")
}
fun sayHelloWithName(name:String) {
println("Hello $name")
}
fun addTwoNumbers(x:Int, y:Int) {
print("The sum of the two numbers is ${x + y}")
}

Conditionals in Kotlin
(stuff you would use a lot while making apps)

if , else if, else
Basic Structure :
if( condition1 ){
// This stuff runs when Condition 1 holds
} else if( condition2 ){
// This runs when Condition 2 holds
} else if( condition3 ){
// This runs when Condition 3 holds
} else{
// If none of the condition holds, this runs
}

if , else if, else
Let’s Try One Example….

if , else if, else as Expression
Example dekhte hai direct…

when statement
//// Similar to switch in C++
//// Used instead of long if else ladder
fun main() {
val x = 2;
when(x) {
1 -> println("One")
2 -> println("Two")
3 -> println("Three")
else -> println("Number not recognized")
}
}

ranges
//// Collection of values from a START point to an END point
//// Similar to ranges in python
A range of number from 1 to 10 : 1..10
val x = 1..10;
A range of number from 10 to 1 : 10 downTo 1
val x = 10 downTo 1

for loop
//// Not like for loops in languages like C++ or Java
//// Used to iterate through a collection
Basic Structure :
for( item in collection ) {
// You could do something with item
}
Let’s look at few Examples…
-> with Ranges
-> with List
-> break, continue with labels

Quiz Time!!!
//// What will be the output of this?
a)
fun main() {
val x = 1..5
val y = 1..10
for( i in x ){
print("$i : ")
for( j in y ){
print("$j ")
if( i == 3 && j == 7 ) break
}
println()
}
}
b)

while Loop
//// Similar to the while loop in C++
//// Used for condition based looping
Basic Structure :
Let’s look at an Example…
while( condition ){
// Execute something
}

do while Loop
//// Runs the body of the loop at least ones even if the
condition doesn’t satisfies
Basic Structure :
Let’s look at an Example…
do{
// Body of the loop
}while ( condition )

repeat
//// Quite not found in any other languages
Basic Structure :
repeat(3) {
println("Hello")
}

Classes
Class is template of object
A class is a user defined blueprint or prototype
from which objects are created.
It represents the set of properties or methods that
are common to all objects of one type

Name : Eshan
Age : 20
Gender: Male
Occupation : Android Developer
Name : Priya
Age : 25
Gender : Female
Occupation : Doctor

Classes
Class : Car
Class is template of object

To Create a class ,
We use class Keyword
Properties of Car

Objects : Instance of Class
Object 1 of Class Car
Jaguar I-PACE Black
0 cc
Object 2 of Class Car
Tata Nano Yellow
624 cc

Create an Object
Constructor
objectName.DataMember

There is faster way of doing this
By using a CONSTRUCTOR
A constructor is like a special function, and it is defined by using two parantheses ()
after the class name. You can specify the properties inside of the parantheses (like
passing parameters into a regular function).
Constructor

Without Constructor
By Using Constructor
Properties
Note:
Remember to specify the type of the property/variable

Creating Object by using Constructor

Inheritance
In Kotlin, it is possible to inherit class
properties and functions from one class to
another
SubClass
Child
SuperClass
Parent

Parent
Use the open keyword in front of the superclass/parent, to make this the class other
classes should inherit properties and functions from.
Child
To inherit from a class, specify the name of the subclass, followed by a colon :, and then
the name of the superclass.
In Similar fashion we can inherit functions and other properties from parent to child

Polymorphism
Poly means many and morph means forms
i.e. the same method behaves differently based on the object

we have different forms of the
method that exhibits different
behavior based on the object.

Here we can see polymorphism of
area() Function
https://pl.kotl.in/_ebphwnyK

Abstraction
Abstraction is used to hide background details or any unnecessary
implementation about the data so that users only see the required
information.
It is one of the most important and essential features of object-oriented
programming.

Encapsulation
It is a protective shield that prevents the data from
being accessed by the code outside this shield.

Here we can’t access private properties of
class from outside the class
Abstraction
Encapsulation
Main function don’t know how these
setters getters work

Introduction to kotlin and OOP in Kotlin

Introduction to kotlin and OOP in Kotlin

More Related Content

What's hot

Similar to Introduction to kotlin and OOP in Kotlin

Recently uploaded

In this document

Introduction to kotlin and OOP in Kotlin