کاوش در کلاس های انتزاعی کاتلین و انواع کلاس های تخصصی: راهنمای مفاهیم برنامه نویسی شی گرا.

abstract class className(val x : String) //non-abstract property
 {
    abstract var y : Int //Abstract property
    abstract fun method () //Abstract property
    fun method () //non-abstract method property
                 {
    println("Non abstract function")
                  }
}

abstract class Employee (val name : String,val experience : Int){
    //abstract property
    abstract var salary : Double 
    abstract fun dateOfBirth(date : String)
    //non-abstract property
    fun employeeDetails() {
        println("Name of the employee : $name")
        println("Experience in years : $experience")
        println("Annual salary : $salary")
    }
}
//derived class
class Engineer (name: String, experience: Int): Employee(name, experience) {
    override var salary = 5000.00
    override fun dateOfBirth(date : String){
        println("Date of Birth is: $date")
    }
}
fun main () {
    val eng = Engineer("Praveen",2)
    eng.employeeDetails()
    eng.dateOfBirth("02 December 1994")
}

abstract class Calculator {
    abstract fun cal (firstNum : Int, secondNum : Int): Int
}
//Addition of two numbers
class Add : Calculator () {
    override fun cal (firstNum : Int, secondNum : Int) : Int{
        return firstNum + secondNum
    }
}
//Division of two numbers
class Divide : Calculator () {
    override fun cal (firstNum : Int, secondNum : Int) : Int{
        return firstNum / secondNum
    }
}
//Multiplication of two numbers
class Multiply : Calculator () {
    override fun cal (firstNum : Int, secondNum : Int) : Int{
        return firstNum * secondNum
    }
}
//Subtraction of two numbers
class Subtract : Calculator () {
    override fun cal (firstNum : Int, secondNum : Int) : Int{
        return firstNum - secondNum
    }
}

fun main () {
    var add : Calculator = Add()
    var add1 = add.cal(4,3)
    println("Addition of two numbers $add1")

    var subtract : Calculator = Subtract()
    var add2 = subtract.cal(4,3)
    println("Subtraction of two numbers $add2")

    var multiply : Calculator = Multiply()
    var add3 = multiply.cal(4,3)
    println("Multiplication of two numbers $add3")

    var divide : Calculator = Divide()
    var add4 = divide.cal(24,3)
    println("Division of two numbers $add4")
}

open class vertebrates {
     open fun Backbone () {
        println("All vertebrates have a backbone")
    }
}

abstract class Animal : vertebrates () {
    override abstract fun Backbone ()
}   

class Birds : Animal () {
    override fun Backbone () {
        println("Birds have a backbone")
    }
}

fun main () {
    val animals = vertebrates ()
    animals.Backbone()
    val birds = Birds()
    birds.Backbone()

}

class superCars (val name : String,val year : Int)
fun main () {
    var car1 = superCars("volvo",2020)
    var car2 = superCars("BMW" ,2021)
    var car3 = superCars("volvo",2020)
    var car4 = superCars("Benz",2019)

    println(car1 == car2)//false
    println(car1 == car1)//true
    println(car3 == car4)//false
}

class superCars (val name : String,val Modelyear : Int)
fun main () {
    var car1 = superCars("volvo",2020)
    var car2 = superCars("BMW" ,2021)
    var car3 = superCars("volvo",2020)
    var car4 = superCars("Benz",2019)

    println(car1.name)
    println(car1.Modelyear)

    println(car4.name)
    println(car4.Modelyear) 

}

class superCars (val name : String,val Modelyear : Int)
fun main () {
    var car1 = superCars("volvo",2020)
    var car2 = superCars("BMW" ,2021)
    var car3 = superCars("volvo",2020)
    var car4 = superCars("Benz",2019)

    println(car1)//superCars@37f8bb67
    println(car2)//superCars@439f5b3d
           }

data class superCars (val name : String,val Modelyear : Int)
fun main () {
    var car1 = superCars("volvo",2020)
    var car2 = superCars("BMW" ,2021)
    var car3 = superCars("volvo",2020)
    var car4 = superCars("Benz",2019)
println(car1)
println(car2)
    }

data class Person(val firstName: String, val familyName:String) {
var age = 0
}
fun main() {

val person1 = Person("John", "Doe").apply { age = 25 }
val(firstName,familyName) = person1

println(person1.copy(familyName = "Maye"))
}

fun main () {

    val fruits = Pair ("orange","Banana")

    //Using the first property 
    println(fruits.first)

     //Using the second property 
    println(fruits.second)
}

fun main () {

    val Pair = 10 to "A"

    //Using the first property 
    println(Pair.first)

     //Using the second property 
    println(Pair.second)
}

fun main () {

    val pair = Triple("Daniel",45, 'M')

    //Using the first property 
    println(pair.first)

     //Using the second property 
    println(pair.second)

    //Using the third property 
    println(pair.third)  
           }

fun main () {

    val pair = Triple("Daniel",45,'M')
    val(name,age,gender) = pair

    //Getting the first property 
    println(name)

     //Getting the second property 
    println(age)

    //Getting the third property 
    println(gender)  
    }

enum class days {
sunday,
monday,
tuesday,
wednesday,
thursday,
friday,
saturday
}

enum class bananas (val color : String) {
    ripe("yellow"),
    unripe("green")
}
fun main () {

   val colour = bananas.ripe.color
    println(colour)
}

enum class HalfYear {
    January,
    February,
    March,
    April,
    May,
    June
}
fun main () {
    for(month in HalfYear.values()){
        println("${month.ordinal} = ${month.name}")
        }
    }

enum class Planets {
    Mercury,
    Venus,
    Earth,
    Mars,
    Jupiter,
    Saturn,
    Uranus
}

fun main() {
    for (planet in Planets.values()) {
        when (planet) {
            Planets.Mercury -> println("The Swift Planet")
            Planets.Venus -> println("The Morning and evening star")
            Planets.Earth -> println("The Goldilocks Planet")
            Planets.Mars -> println("The Red Planet")
            Planets.Jupiter -> println("The Gas giant Planet")
            Planets.Saturn -> println("The Ringed Planet")
            Planets.Uranus -> println("The Ice giant Planet")
        }
    }
}

enum class seasons (var weather : String) {

    Summer ("hot") {
        override fun foo () {
            println("Hot days of the year")
        }
    },

     Winter ("cold") {
        override fun foo (){
            println("Cold days of the year")
        }
    },

     Rainny ("rain") {
        override fun foo (){
            println("Rainny days of the year")
        }
    };

 abstract fun foo ()
}

fun main () {
    seasons.Winter.foo()
}

enum class DAYS(val isWeekend: Boolean = false){
    SUNDAY(true),
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY(true);

    companion object{
        fun today(obj: DAYS): Boolean {
            return obj.name.compareTo("SATURDAY") == 0 || obj.name.compareTo("SUNDAY") == 0
        }
    }
}

fun main(){
    for(day in DAYS.values()) {
        println("${day.ordinal} = ${day.name} and is weekend ${day.isWeekend}")
    }
    val today = DAYS.MONDAY;
    println("Is today a weekend ${DAYS.today(today)}")
}

try {
    // your code
    // may throw an exception
}
catch (ex : ExceptionName)
{
    // Exception handle code
}
finally
{
    //This will execute everytime
    //It will execute whether we find an exceptiion or not
}

fun main () {

 try {

 divide (10,0)

    }
catch (ex : Exception)
{
    println(ex.message)
  }
}

fun divide (a : Int, b : Int){

    if(b == 0)
    throw Exception("Divide by Zero")
    println("Division is :" +a /b)
} 

 fun main()
   {
    try
    {
    divide(20, 10)
    }
    catch (ex : Exception)
    {
    println(ex.message)
    }
    finally
    {
    println("I'm executed")
    }

    // 2nd try block
    try
    {
    // throw an exception
    divide(10, 0)
    }
    catch (ex : Exception)
    {
    println(ex.message)
    }
    finally
    {
    println("I'm executed")
    }
}

fun divide(a : Int, b : Int)
{
    if (b == 0)
        throw Exception("Divide by zero")
    println("Division is :" + a / b)
}

sealed class DemoClass
    fun main () {
        var InstanceDemo = Demo ()
    }

sealed class School {
    class Public:School(){
        fun display(){
            println("They are funded by the government")
        }
    }
    class Private:School(){
        fun display(){
            println("They are funded by individuals")
        }
    }
}

fun main(){
    val obj = School.Public()
    obj.display()
    val obj1= School.Private()
    obj1.display()
}

// A sealed class with a string property
sealed class Fruit(val x : String)
{
    // Two subclasses of sealed class defined within
    class Apple : Fruit("Apple")
    class Mango : Fruit("Mango")
}

// A subclass defined outside the sealed class
class Pomegranate: Fruit("Pomegranate")

// A function to take in an object of type Fruit
// And to display an appropriate message depending on the type of Fruit
fun display(fruit: Fruit)
{
    when(fruit)
    {
        is Fruit.Apple -> println("${fruit.x} is good for iron")
        is Fruit.Mango -> println("${fruit.x} is delicious")
        is Pomegranate -> println("${fruit.x} is good for vitamin d")
    }
}
fun main()
{
    // Objects of different subclasses created
    val obj = Fruit.Apple()
    val obj1 = Fruit.Mango()
    val obj2 = Pomegranate()

    // Function called with different objects
    display(obj)
    display(obj1)
    display(obj2)
}

 `@Positive val i : Int`

 `@Allowedlanguage("Kotlin")`

` @Deprecated("This function is deprecated, use === instead", ReplaceWith("this === other"))`

@Throws(IOException::class) 

class MyClass@Inject constructor(dependency: MyDependency) {  
//. . .   
}

class Lang (
    @Allowedlanguages(["Java","Kotlin"]) val name: String)
}

@Target(AnnotationTarget.CONSTRUCTOR, AnnotationTarget.LOCAL_VARIABLE)
annotation class AnnotationDemo2

class ABC @AnnotationDemo2 constructor(val count:Int){
    fun display(){
        println("Constructor annotated")
        println("Count is $count")
    }
}
fun main(){
    val obj =  ABC(5)
    obj.display()
    @AnnotationDemo2 val message: String
    message = "Hello"
    println("Local parameter annotated")
    println(message)
}

//Specifying an annotation with runtime policy
@Retention(AnnotationRetention.RUNTIME)
annotation class AnnotationDemo3

@AnnotationDemo3 fun main(){
    println("Main function annotated")
}

@Repeatable
@Retention(AnnotationRetention.SOURCE)
annotation class AnnotationDemo4 (val value: Int)

@AnnotationDemo4(4)
@AnnotationDemo4(5)
fun main(){
    println("Repeatable Annotation applied on main")
}