1.	// getter and setter properties

class CSE {
    var name: String = " "
        get() = field        // getter
        set(value) {         // setter
            field = value
        }
}
fun main(args: Array<String>) {
    val c = CSE()
    c.name = "WELCOME TO CSE-B"   // access setter
    println(c.name)               // access getter
}

Output:
WELCOME TO CSE-B
******************************************************************************************
2.   //DWELLINGS PROGRAM
 /**
* Program that implements classes for different kinds of dwellings.
* Shows how to:
* Create class hierarchy, variables and functions with inheritance,
* abstract class, overriding, and private vs. public variables.
*/

import kotlin.math.PI
import kotlin.math.sqrt

fun main() {
   val squareCabin = SquareCabin(6, 50.0)
   val roundHut = RoundHut(3, 10.0)
   val roundTower = RoundTower(4, 15.5)

   with(squareCabin) {
       println("\nSquare Cabin\n============")
       println("Capacity: ${capacity}")
       println("Material: ${buildingMaterial}")
       println("Floor area: ${floorArea()}")
   }

   with(roundHut) {
       println("\nRound Hut\n=========")
       println("Material: ${buildingMaterial}")
       println("Capacity: ${capacity}")
       println("Floor area: ${floorArea()}")
       println("Has room? ${hasRoom()}")
       getRoom()
       println("Has room? ${hasRoom()}")
       getRoom()
       println("Carpet size: ${calculateMaxCarpetLength()}")
   }

   with(roundTower) {
       println("\nRound Tower\n==========")
       println("Material: ${buildingMaterial}")
       println("Capacity: ${capacity}")
       println("Floor area: ${floorArea()}")
       println("Carpet Length: ${calculateMaxCarpetLength()}")
   }
}


/**
* Defines properties common to all dwellings.
* All dwellings have floorspace,
* but its calculation is specific to the subclass.
* Checking and getting a room are implemented here
* because they are the same for all Dwelling subclasses.
*
* @param residents Current number of residents
*/
abstract class Dwelling(private var residents: Int) {
   abstract val buildingMaterial: String
   abstract val capacity: Int

   /**
    * Calculates the floor area of the dwelling.
    * Implemented by subclasses where shape is determined.
    *
    * @return floor area
    */
   abstract fun floorArea(): Double

   /**
    * Checks whether there is room for another resident.
    *
    * @return true if room available, false otherwise
    */
   fun hasRoom(): Boolean {
       return residents < capacity
   }

   /**
    * Compares the capacity to the number of residents and
    * if capacity is larger than number of residents,
    * add resident by increasing the number of residents.
    * Print the result.
    */
   fun getRoom() {
       if (capacity > residents) {
           residents++
           println("You got a room!")
       } else {
           println("Sorry, at capacity and no rooms left.")
       }
   }

   }

/**
* A square cabin dwelling.
*
*  @param residents Current number of residents
*  @param length Length
*/
class SquareCabin(residents: Int, val length: Double) : Dwelling(residents) {
   override val buildingMaterial = "Wood"
   override val capacity = 6

   /**
    * Calculates floor area for a square dwelling.
    *
    * @return floor area
    */
   override fun floorArea(): Double {
       return length * length
   }

}

/**
* Dwelling with a circular floorspace
*
* @param residents Current number of residents
* @param radius Radius
*/
open class RoundHut(
       residents: Int, val radius: Double) : Dwelling(residents) {

   override val buildingMaterial = "Straw"
   override val capacity = 4

   /**
    * Calculates floor area for a round dwelling.
    *
    * @return floor area
    */
   override fun floorArea(): Double {
       return PI * radius * radius
   }

   /**
    *  Calculates the max length for a square carpet
    *  that fits the circular floor.
    *
    * @return length of square carpet
    */
    fun calculateMaxCarpetLength(): Double {
        return sqrt(2.0) * radius
    }
}

/**
* Round tower with multiple stories.
*
* @param residents Current number of residents
* @param radius Radius
* @param floors Number of stories
*/
class RoundTower(
       residents: Int,
       radius: Double,
       val floors: Int = 2) : RoundHut(residents, radius) {

   override val buildingMaterial = "Stone"

   // Capacity depends on the number of floors.
   override val capacity = floors * 4

   /**
    * Calculates the total floor area for a tower dwelling
    * with multiple stories.
    *
    * @return floor area
    */
   override fun floorArea(): Double {
       return super.floorArea() * floors
   }
}

Output:
Square Cabin
============
Capacity: 6
Material: Wood
Floor area: 2500.0

Round Hut
=========
Material: Straw
Capacity: 4
Floor area: 314.1592653589793
Has room? true
You got a room!
Has room? false
Sorry, at capacity and no rooms left.
Carpet size: 14.142135623730951

Round Tower
==========
Material: Stone
Capacity: 8
Floor area: 1509.5352700498956
Carpet Length: 21.920310216782976
******************************************************************************************
3.4.5.6.	// companion object
class CSE {
    companion object Test  {                 //companion object name Test
        fun section_b() = println("WELCOME TO CSE-B MAD LAB")
    }
}
fun main(args: Array<String>) {
    CSE.section_b()   // method accessing using class name
}
Output:
WELCOME TO CSE-B MAD LAB
******************************************************************************************
7.	// anonymous function 

// anonymous function  with body as an expression
val anonymous1 = fun(x: Int, y: Int): Int = x + y
// anonymous function with body as a block
val anonymous2 = fun(a: Int, b: Int): Int 
{
			val mul = a * b
			return mul
}
fun main(args: Array<String>) 
{
	//invoking functions
	val sum = anonymous1(3,5)
	val mul = anonymous2(3,5)
	println("The sum of two numbers is: $sum")
	println("The multiply of two numbers is: $mul")
}

Output:
The sum of two numbers is: 8
The multiply of two numbers is: 15
******************************************************************************************
8.   //WHEN DEMONSTRATION
fun main() {  
  val day = 4
  val result = when (day) {
  1 -> "Monday"
  2 -> "Tuesday"
  3 -> "Wednesday"
  4 -> "Thursday"
  5 -> "Friday"
  6 -> "Saturday"
  7 -> "Sunday"
  else -> "Invalid day."
}
println(result)         // DISPLAYS OUTPUT AS "Thursday"
}

Output:
Thursday
******************************************************************************************
9.//DICE ROLLER PROGRAM USING CLASSES
// Random() is an abstract class which generates random numbers with the given conditions. It can be accessed after importing Kotlin.random.Random.
//IntRange is another data type, and it represents a range of integer numbers from a starting point to an endpoint. 
//IntRange is a suitable data type for representing the possible values a dice roll can produce.
class Dice {
    var sides = 6
    fun roll(): Int {
        //random() function to generate random numbers. 
        //random() takes a series of numbers as an input and it returns a random Int as an output.
        val randomNumber = (1..sides).random()  
        return randomNumber
    }
}
fun main() {
    val myFirstDice = Dice()
    val diceRoll = myFirstDice.roll()
    println("Your ${myFirstDice.sides} sided dice rolled ${diceRoll}!")

    myFirstDice.sides = 20
    println("Your ${myFirstDice.sides} sided dice rolled ${myFirstDice.roll()}!")
}

Output:
Your 6 sided dice rolled 4!
Your 20 sided dice rolled 1!
 ******************************************************************************************
10.   //  DATA TYPE demonstration
fun main()
{
    val a: Int = 5                // Int
    val b: Double = 5.99        // Double
    val c: Char = 'v'          // Char
    val d: Boolean = true     // Boolean
    val e: String = "CSE B"      // String
    val f: Float = 100.00f      // float
    println("a value is:" +a)
    println("b value is:" +b)
    println("c value is:" +c)
    println("d value is:" +d)
    println("e value is:" +e) 
    println("f value is:" +f)
}

Output:
a value is:5
b value is:5.99
c value is:v
d value is:true
e value is:CSE B
f value is:100.0
******************************************************************************************
11.loops and arrays of
// WHILE Loop demonstration
fun main() {  
  var i = 0
while (i < 5) {
  println(i)
  i++
} 
}
16.	// DO WHILE LOOP  demonstration
fun main() { 
    var i=0
 do {
  println(i)
  i++
  }
while (i < 5) 
}



17.	// FOR  LOOP  demonstration
fun main() { 
    val cse = arrayOf("CSE A", "CSE B", "CSE C", "CSE D")
for (x in cse) {
  println(x)
} 
}


18.	// BREAK  demonstration
fun main() { 
   var i = 0
while (i < 10) {
  println(i)
  i++
  if (i == 4) {
    break
  }
}



19.	//CONTINUE  demonstration
fun main() { 
  var i = 0
while (i < 10) 
    {
  if (i == 4) 
    {
    i++
    continue   
  }
  println(i)
  i++
}  
}



20.	//RANGE  demonstration
fun main() { 
for (n in 5..15) {
  println(n)
} 
}



21.	//ARRAY  demonstration
 fun main() { 
val  cse = arrayOf("CSE A", "CSE B", "CSE C", "CSE D")
println(cse.size)  // check array length or size
for (x in cse) 
{
  println(x)          
 }
println(cse[0])    // You can access an array element by referring to the index number, inside square brackets

if ("CSE B" in cse) 
{
  println("It exists!") 
} 
    else 
{
  println("It does not exist.")  
 }    
 }
******************************************************************************************
12.	//  ARTHIMETIC OPERATOR demonstration
fun main()
{
    var sum1 = 100 + 50       // 150 (100 + 50)
var sum2 = sum1 + 250     // 400 (150 + 250)
var sum3 = sum2 + sum2    // 800 (400 + 400)
println(sum3)
}

  Output:
  800
 ******************************************************************************************
13.8.	//primary constructor
fun main(args: Array<String>)
{
	val add = Add(5, 6)
	println("The Sum of numbers 5 and 6 is: ${add.c}")
}
class Add constructor(a: Int,b:Int)
{
	var c = a+b;
}

Output:
The Sum of numbers 5 and 6 is 11


******************************************************************************************
15.arrayOf() functoin , android app using intent 
 
fun main() 
{ 
  val  n:IntArray = intArrayOf(1, 2, 3, 4, 5) 
 println("Value at 3rd position : " + n[2]) 
}