Learning Kotlin.

Build command for `kotlin` code compile and Execute.

Install OpenJdk from apt
Download Kotlin compiler from github
Then add bin folder path to .bashrc

compile command

kotlinc basic-operation.kt -include-runtime -d basi-opration.jar
java -jar basi-opration.jar

Five Basic Concepts are

Variables and Types

A variable is a location in memory (storage).
To indicate the storage area, each variable should be given a unique name (Identifier).

Control Flows

Do something conditionally
To repeatedly run code conditionally.

Functions

Functions enable us to separate code.
Run code blocks when needed.

Collections

Collections enable us to store multiple elements in one place.
Iterate through multiple elements (with the help of control flows).

Classes and Objects (including inheritance)

Create our own data types
Keep the data members and methods together in one place.
Write more readable and maintainable code.
Work better in a team.

Variables and Data Types

There is two types of variables in kotlin

Mutable

	var aquarium = 1
	aquarium = 50

Immutable
```
	val fish = "Nemo"
        
```

Immutable list can not reassign new value but can be manipulate list.

val myList = mutalbleListOf("tuna", "salmon", "shark")
myList.remove("shark")

Byte
```
val myByte: Byte = 13
    
```
Short
```
val myShort: Short = 125
    
```
Int
```
val myInt: Int = 12345678
    
```

Long

val myLong: Long = 12_123_123_123_1234

Float
```
val myFloar: Float = 13.43F
    
```

Double

val myDouble: Double = 3.1233445535445

Boolean
```
val myBoolean: Boolean = true
    
```
Char
```
val myChar: Char = 'A'
    
```

String

val myString: String = "Shafiqur Rahman"

Arithmetic Operators

(+, -, /, *, %)
int divide by int returns int

float divide by float returns float

1/2 // Will return 0
1.0/20. // Will return 0.5

Arithmetic Methods

val fish = 2
fish.times(6)
fish.div(10)
fish.plus(3)
fish.minus(3)

Boxing

1.toLong()

val boxed: Number = 1
boxed.toLong()

Comparison Operators

(==, !=, <, >, <=, >=)

Null Safety

Add ? to indicate variable can contain null value

var marble: Int? = null
var lotsOfFish: List<String?> = listOf(null, null)
var evenMoreFish: List<String>? = null
var definitelyFish: List<String?>? = null

Force a null able type in kotlin
```
goldfish!!.eat()
    
```
Null check operator ?: Elvis Operator
```
return fishFoodTreats?.dec() ?: 0
    
```

Safe Call Operator ?.let

var nullableName: String? = "Pallab"

nullableName?.let { println(it.length) }

Chain Null check

val age: String? = user?.wife?.age ?: 0

Switch with When

var welcomeMessage = "Hello and welcome to Kotlin"
when (welcomeMessage.length) {
   0, 1 -> println("Nothing to say?")
   in 2..50 -> println("Perfect")
   else -> println("Too long!")
}

Array (Collections)

Typed Array

// IntArray
val numbers = intArrayOf(1, 2, 3)
// BooleanArray
// DoubleArray
// ByteArray
// LongArray
// ShortArray
// FloatArray

Non Typed Array

// arrayOf<String>
val school = arrayOf("tuna", "salmon", "shark")
println(Arrays.toString(school))
// arrayOf<Fruit>
val colects = array(1, 2, "Jhon", "Doe", 0.5, Fruit())

Arrays of arrays

var fish = 12
var plants = 5

val swam = listOf(fish, plants)

val bigSwarm = arrayOf(swam, arrayOf("Dolphin", "Whale", "orka"))


println(Arrays.toString(bigSwarm))

Array comprehension

val array = Array(5) { it * 2 }
println(array.asList())

Array of data class

   data class Fruit(val name: String, val price: Double)

   val fruits = arrayOf(Fruit("Apple", 2.5), Fruit("Grape", 3.5))

   for (fruit in fruits){
	  println("${fruit.name}")
   }

   for(index in fruits.indices){
	  println("${fruits[index].name} is in index $index")
   }

Array List

Array List are used to create a dynamic array. Which means the size of an array can be increased or decreased according to requirement.
The Array List class provide both read and write functionality
The Array List follows the sequence of insertion order.
An array is non synchronized and it may contain duplicate element.
ArrayList<E>(): Is used to create an empty Array List.
ArrayList(capacity: Int): Is used to create an Array List of specified capacity.
ArrayList(elements: Collection<E>): Is used to create an Array List filled with the elements of a collection.
open fun add(element: E): Boolean -> used to add the specific element into the collection.
open fun clear() -> used to remove all elements from the collection.
open fun get(index: Int): E -> used to return the element at specific index in the list.
open fun remove(element: E): Boolean -> used to remove a single instance of the specific element from current collection, if it is available.

Empty Array List

   fun main() {
	  val arrayList = ArrayList<String>()

	  arrayList.add("One")
	  arrayList.add("Two")

	  for(i in arrayList){
	      println(i)
	  }
   }

Array List using collection

   fun main() {
	  val arrayList: ArrayList<String> = ArrayList<String>(5)
	  var list: MutableList<String> = mutableListOf<String>()

	  list.add("One")
	  list.add("Two")

	  arrayList.addAll(list)

	  val itr = arrayList.iterator()

	  while (itr.hasNext()) {
	      println(itr.next())
	  }

	  println("Size of array list = ${arrayList.size}")
 
   }

Array List get

   fun main() {
	  val arrayList: ArrayList<String> = ArrayList<String>()

	  arrayList.add("One")
	  arrayList.add("Two")

	  for (i in arrayList) {
	      println(i)
	  }

	  println(arrayList.get(1))
   }

List (Collections)

   // List of Strings
   val stringList: List<String> = listOf(
	"Denish", "Frank", "Michael", "Greater"
   )
   // List of Mixed Type
   val mixedTypeList: List<Any> = listOf(
	"Denish", 31, 5, "Bday", 70.5, "KG"
   )

   val months = listOf("January", "February", "March")


   val additionalMonths = months.toMutableList()
   val newMonths = arrayOf("April", "May", "June")
   additionalMonths.addAll(newMonths)
   additionalMonths.add("July")

   print(additionalMonths)


   val days = mutableListOf<String>("Saturday", "Sunday", "Monday")

   print(day)

Map (Collections)

   val fruits = setOf("Orange", "Apple", "Mango", "Apple", "Grape", "Orange")
   print(fruits.size)

   // mapOf key, value

   val daysOfTheWeek = mapOf(1 to "Monday", 2 to "Tuesday", 3 to "Wednesday")

   for(key in daysOfTheWeek.keys){
	println("$key is to ${daysOfTheWeek[key]}")
   }

   data class Fruit(val name: String, val price: Double)

   val fruitsMap = mapOf(
	"Favorite" to Fruit("Mango", 2.5),
	"Okay" to Fruit("Apple", 1.0)
   )

For Loop

looping without index

for (element in swarm) println(element)

looping with index

   for ((index, element) in swarm.withIndex()){
	  println("Fish at $index is $element")
   }

Ranges print

for (i in 'b'..'g') println(i)

for (i in 1..120) println(i)

for (i in 5 downTo 1) println(i)

for (i in 5 downTo 1 step 2) println(i)

for (i in 3..6 step 2) println(i)

for (i in 1 until 10) println(i)

For Each

While Loop

   var x = 1
   while(x <= 10) {
	println("$x")
	x++
   }
   println("While loop is done.")

Do While Loop

   x = 15

   do {
	print("$x")
	x++
   } while(x <= 10)

Repeat Loop

Filter

Eager Filter (Create a new list)

   val decorations = listOf(
	  "rock", "pagoda", "plastic plant", "alligator", "flowerpot"
   )
   val eager = decorations.filter { it[0] == 'p'}
   println(eager)

Lazy Filter

   val decorations = listOf(
	  "rock", "pagoda", "plastic plant", "alligator", "flowerpot"
   )
   val filtered = decorations.asSequence().filter() { it[0] == 'p' }
   println(filtered)
   println(filtered.toList())

`lambda`

Lambda (Expression) is a function which has no name.
Lambda expression and anonymous functions are ‘function literals’ i.e. functions that are not declared, but passed immediately as an expression.
Lambda is defined with curly braces {} which takes variables as a parameter (if any) and a body of a function.
The body of a function is written after the variable (if any) followed by -> operator.
Syntax : {variable(s) -> body_of_lambda}
A value assigned at compile time, and the value never changes when the variable is accessed.
a lambda assigned at compile time, and the lambda is executed every time the variable is referenced, returning a different value.

Example:

val sum: (Int, Int) -> Int = { a: Int, b: Int -> a + b }
pritln(sum(10, 5))

// Even Shorter
val sum = { a: Int, b: Int -> println(a + b) }
sum(10, 15)

Classes

Simple way to create a class

   class Person constructor(_firstName: String, _lastName: String) {
	  // Member Variable (Properties) of the class
	  var firstName: String
	  var lastName: String
 
	  // Initializer Blocks
	  init {
	      this.firstName = _firstName
	      this.lastName = _lastName
	      println("First Name: $firstName")
	      println("Last Name: $lastName")
	  }
   }

   fun main() {
	  val pallab = Person("Pallab", "pal")
	  println(pallab)
   }

More Simple way to create a class

   class Person(_firstName: String, _lastName: String){
	   // Member Variables (Properties) of the class
	  var firstName: String = _firstName
	  var lastName: String = _lastName
 
	  // Initializer Block
	  init {
	      println("FirstName = $firstName and LastName = $lastName")
	  }
   }

   fun main() {
	  val pallab = Person("Pallab", "pal")
	  println(pallab)
   }

Even more simple way to create a class

   class Person(var firstName: String = "Jhon", var lastName: String = "Doe"){
	  // Initializer Blocks
	  init {
	      println("First Name: $firstName")
	      println("Last Name: $lastName")
	  }
   }

   fun main() {
	  val pallab = Person("Pallab", "pal")
	  println(pallab)
   }

With Secondary Constructor

   class Person (var firstName: String = "Shafiqur", var lastName: String = "Rahman"){
	  var hobby: String = "Fishing"
	  // This property is import for Secondary Constructor
	  var age: Int? = null
	  // This property is import for Secondary Overload Constructor
	  var eyeColor: String? = null

	  // Secondary Constructor
	  constructor(firstName: String, lastName: String, age: Int): this(firstName, lastName){
	      this.age = if (age > 0) age else throw IllegalArgumentException("Age must be greater than zero")
	  }

	  // Secondary Constructor Overloaded
	  constructor(firstName: String, lastName: String, age: Int, eyeColor: String): 
		  this(firstName, lastName, age)  {
	      this.eyeColor = eyeColor
	  }

	  // Method
	  fun sayHobby(){
	      println("$firstName\'s Hobby is $hobby.")
	  }
   }


   fun main() {
	  var shafiq = Person()
	  shafiq.sayHobby()
	  var pallab = Person("Shafiq", "Pallab")
	  pallab.sayHobby()
	  var dia = Person("Habiba", "Akter", 20)
	  dia.hobby = "Planting"
	  dia.sayHobby()
   }

Class Example

   class Aquarium (
	var width: Int = 20,
	var height: Int = 40,
	var length: Int = 100
   ) {
	var volume: Int 
	    get() = width * height * length / 1000
	    set(value) { height = (value * 1000) / (width  * length) }

	var water = volume * 0.9

	// Member Secondary Constructor
	constructor(numberOfFish: Int): this() {
	    val water: Int = numberOfFish * 2000
	    val tank: Double = water + (water * 0.1)
	    height = (tank / (length * width)).toInt()
	}

	init {
	    println("Length: $length")
	    println("Width: $width")
	    println("Height: $height")
	}
   }


   fun main() {
	val smallAquarium = Aquarium(numberOfFish = 9)
	println("Volume: ${smallAquarium.volume}")
   }

SETTERS AND `GETTERS`

Kotlin internally generates a default getter and setter for mutable properties,
Getter (only) for read-only properties.

Example

   class Car(_brand: String, _model: String, _maxSpeed: Int){
	  val _brand: String = _brand
	      get() = field

	  var _model: String = _model
	      get() = field
	      set(value) {field = value}

	  var _maxSpeed: Int = _maxSpeed
	      get() = field
	      set(value) {field = value}
   }

Backing Field (field)

   class Car {
	  lateinit var owner: String
	  val myBrand: String = "BMW"
	  // Custom Getter
	      get() { return field.lowercase() }

	  var myModel: String = "M5"
	  // Default Setter and Getter
	      private set


	  var myMaxSpeed: Int = 40
	      get() = field
	  // Custom Setter
	      set(value) {
		  field = if(value > 0) value
		  else throw IllegalArgumentException("_maxSpeed must be greater than zero")
	      }

	  init {
	      this.owner = "Shafiq"
	  }
   }

   fun main() {
	  val myCar = Car()
	  println(myCar.myBrand)
	  println(myCar.myModel)
	  myCar.myMaxSpeed = 100
	  println(myCar.myMaxSpeed)
   }

Package Visibility

public - Default Everywhere.
private - File
internal - Module

Class Visibility

public - Default. Class and public member
private - Inside class. Sub classes can't see.
protected - Inside class. Sub classes can see.
internal - Module
In kotlin all classes are final by default, so they can’t be inherited by default.

Inheritance

We have to add open to class to make sub class from it.

We have to add override to sub class to override properties or methods.

   import kotlin.math.PI

   open class BaseAquarium (
	  var lenght: Int = 100,
	  var width: Int = 20,
	  var height: Int = 40
   ){
	  open var volume: Int
	      get() = (width * height * lenght) / 1000
	      set(value) { height = (value * 1000) / (width * lenght) }

	  open var water = volume * 0.9

	  constructor(numberOfFish: Int): this(){
	      val water: Int = numberOfFish * 2000
	      val tank: Double = water + (water * 0.1)
	      height = (tank / (lenght * width)).toInt()
	  }
   }


   class TowerTank(): BaseAquarium() {
	  override var water = volume * 0.8

	  override var volume: Int
	      get() = ((width * height * lenght) / 1000 * PI).toInt() 
	      set(value) { height = (value * 1000) / (width * lenght) }
   }


   fun main() {
	  var myTowerTank = TowerTank()

	  println("Volume of new tower tank aquarium ${myTowerTank.volume}")
 
   }

Abstract Class, Interface, Singleton Object

   fun main() {
	delegate()
   }

   fun delegate(){
	val pleco = Plecostomus()
	println("Fish has color ${pleco.color}")
	pleco.eat()
   }

   interface FishAction{
	fun eat()
   }

   interface FishColor {
	val color: String
   }

   class Plecostomus(fishColor: FishColor = GoldColor):
	FishAction by PrintingFishAction("a lot of Food"),
	FishColor by fishColor

   
   object GoldColor: FishColor {
	override val color = "gold" 
   }


   object RedColor: FishColor {
	override val color = "red" 
   }


   class PrintingFishAction(val food: String): FishAction {
	override fun eat() {
	    println(food)
	}
   }

Nested Class

Nested class is such which is created inside another class.
In kotlin, a nested class is by default static, so its data members and member functions can be accessed without creating an object of the class.
Nested class can’t access the data members of the outer classes.

Example

   class OuterClass {
	  private var name: String = "Mr. X"

	  class NestedClass {
	      var description: String = "Code inside the nested class"
	      private var id: Int = 101

	      fun foo(){
		  println("Id is $id")
	      }
	  }
   }

   fun main() {
	  println(OuterClass.NestedClass().description)

	  var obj = OuterClass.NestedClass()

	  obj.foo()
   }

Inner Class

An Inner Class is a class which is created inside another class with key word inner
Inner class can’t be declared inside interface or non-inner nested class
It is able to access members of its outer class even it is private.

Example

   class OuterClass {
	  private var name: String = "Mr. X"

	  class NestedClass {
	      var description: String = "Code inside the nested class"
	      private var id: Int = 101

	      fun foo(){
		  println("name is $name")
		  println("Id is $id")
	      }
	  }
   }

   fun main() {
	  println(OuterClass.NestedClass().description)

	  var obj = OuterClass.NestedClass()

	  obj.foo()
   }

Safe cast operator `as?`

   fun main() {
	val location: Any = "Kotlin"
	val safeString: String? = location as? String
	val safeInt: Int? = location as? Int

	println(safeString)
	println(safeInt)
   }

Unchecked Exceptions

This exception type extends the RuntimeException class.
The unchecked exception is checked at run time.
Example of unchecked exception
- ArithmeticException: thrown when we divide a number by zero.
- ArrayIndexOutOfBoundException: thrown when an array has been tried to access with incorrect index value.
- SecurityException: thrown by the security manager to indicate a security violation.
- NullPointerException: thrown when invoking a method or property on a null object.

Exception Handling

Throwable Class

throw MyExeption ("this throws an Exception")

There are four different keywords used in exception handling. These are:
- try : the try block contain a set of statements which might generate an exception. It must be followed by either catch or finally or both.
- catch : the catch block is used to catch the exception thrown from try block.
- finally: finally block always execute whether exception is handled or not. So it is used to execute important code statements.
- throw: throw an exception explicitly.

Exception Example:

   fun main() {
	  try{
	
	  } catch(e: Exception){

	  } finally {
	
	  }
   }

Name		Name	Last commit message	Last commit date
Latest commit History 22 Commits
.gitignore		.gitignore
Generics.kt		Generics.kt
README.org		README.org
README.pdf		README.pdf
README.tex		README.tex
android.org		android.org
array-list.kt		array-list.kt
array.kt		array.kt
basic-abstract-interface.kt		basic-abstract-interface.kt
basic-class.kt		basic-class.kt
basic-foreach.kt		basic-foreach.kt
basic-operation.kt		basic-operation.kt
class-constructor.kt		class-constructor.kt
class-inheritance.kt		class-inheritance.kt
class-with-second-construtor.kt		class-with-second-construtor.kt
fish-food.kt		fish-food.kt
kotlin-android.org		kotlin-android.org
pair-triple.kt		pair-triple.kt
phone-class.kt		phone-class.kt
setter-getter.kt		setter-getter.kt
simple-class.kt		simple-class.kt
simple-simple-class.kt		simple-simple-class.kt
simple-simple-simple-class.kt		simple-simple-simple-class.kt

Folders and files

Latest commit

History

Repository files navigation

Learning Kotlin.

Build command for kotlin code compile and Execute.

Five Basic Concepts are

Variables and Types

Control Flows

Functions

Collections

Classes and Objects (including inheritance)

Variables and Data Types

Arithmetic Operators

Comparison Operators

Null Safety

Switch with When

Array (Collections)

Array List

List (Collections)

Map (Collections)

For Loop

For Each

While Loop

Do While Loop

Repeat Loop

Filter

lambda

Classes

Class Example

SETTERS AND GETTERS

Package Visibility

Class Visibility

Inheritance

Abstract Class, Interface, Singleton Object

Nested Class

Inner Class

Safe cast operator as?

Unchecked Exceptions

Exception Handling

About

Resources

Uh oh!

Stars

Watchers

Forks

Releases

Packages 0

Uh oh!

Contributors

Uh oh!

Languages

Build command for `kotlin` code compile and Execute.

`lambda`

SETTERS AND `GETTERS`

Safe cast operator `as?`

Packages