Clase abstracta de Kotlin

En Kotlin, la clase abstracta se declara usando la abstractpalabra clave delante de la clase. Una clase abstracta no puede instanciarse significa que no podemos crear un objeto para la clase abstracta.

Declaración de clase abstracta:

abstract class className {
    .........
} 

Puntos para recordar:

1. No podemos crear un objeto para la clase abstracta.
2. Todas las variables (propiedades) y funciones miembro de una clase abstracta son, por defecto , no abstractas . Entonces, si queremos anular estos miembros en la clase secundaria, debemos usar la openpalabra clave.
3. Si declaramos una función miembro como abstracta, no es necesario anotar con openpalabras clave porque están abiertas de forma predeterminada.
4. Una función miembro abstracta no tiene cuerpo y debe implementarse en la clase derivada.

Una clase abstracta puede contener miembros tanto abstractos como no abstractos, como se muestra a continuación:

abstract class className(val x: String) {   // Non-Abstract Property
         
    abstract var y: Int      // Abstract Property

    abstract fun method1()   // Abstract Methods

    fun method2() {          // Non-Abstract Method
        println("Non abstract function")
    }
}

Programa Kotlin de usar miembros abstractos y no abstractos en una clase abstracta.

//abstract class
abstract class Employee(val name: String,val experience: Int) {   // Non-Abstract
                                                                  // Property
    // Abstract Property (Must be overridden by Subclasses)
    abstract var salary: Double
      
    // Abstract Methods (Must be implemented by Subclasses)
    abstract fun dateOfBirth(date:String)
  
    // Non-Abstract Method
    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 = 500000.00
    override fun dateOfBirth(date:String){
        println("Date of Birth is: $date")
    }
}
fun main(args: Array<String>) {
    val eng = Engineer("Praveen",2)
    eng.employeeDetails()
    eng.dateOfBirth("02 December 1994")
}

Producción:

Name of the employee: Praveen
Experience in years: 2
Annual Salary: 500000.0
Date of Birth is: 02 December 1994

Explicación:
En el programa anterior, la clase Ingeniero se deriva de la clase Empleado . Se crea una instancia de un objeto engpara la clase Ingeniero. Hemos pasado dos parámetros al constructor principal mientras lo creamos. Esto inicializa el nombre de las propiedades no abstractas y la experiencia de la clase Empleado. los

Luego employeeDetails()se llama al método usando el engobjeto. Imprimirá los valores de nombre, experiencia y el salario invalidado del empleado.

Al final, dateOfBirth()se llama usando el engobjeto y le hemos pasado la fecha del parámetro al constructor principal. Anula la diversión abstracta de la clase Empleado e imprime el valor de pasado como parámetro a la salida estándar.

Anular un miembro abierto no abstracto con uno abstracto:

En Kotlin, podemos anular la función de miembro abierto no abstracto de la clase abierta usando la palabra clave override seguida de un resumen en la clase abstracta. En el siguiente programa lo haremos.

Programa de Kotlin para anular una función abierta no abstracta por una clase abstracta:

open class Livingthings {
    open fun breathe() {
        println("All living things breathe")
    }
}
abstract class Animal : Livingthings() {
    override abstract fun breathe()
}
class Dog: Animal(){
    override fun breathe() {
        println("Dog can also breathe")
    }
}
fun main(args: Array<String>){
    val lt = Livingthings()
    lt.breathe()
    val d = Dog()
    d.breathe()
}

Producción:

All living things breathe
Dog can also breathe

Múltiples clases derivadas –

Un miembro abstracto de una clase abstracta puede anularse en todas las clases derivadas. En el programa, anulamos la calfunción en tres clases derivadas de calculadora.

Programa Kotlin para anular la función abstracta en más de una clase derivada:

// abstract class
abstract class Calculator {
    abstract fun cal(x: Int, y: Int) : Int
}
// addition of two numbers
class Add : Calculator() {
    override fun cal(x: Int, y: Int): Int {
        return x + y
    }
}
// subtraction of two numbers
class Sub : Calculator() {
    override fun cal(x: Int, y: Int): Int {
        return x - y
    }
}
// multiplication of two numbers
class Mul : Calculator() {
    override fun cal(x: Int, y: Int): Int {
        return x * y
    }
}
fun main(args: Array<String>) {
    var add: Calculator = Add()
    var x1 = add.cal(4, 6)
    println("Addition of two numbers $x1")
    var sub: Calculator = Sub()
    var x2 = sub.cal(10,6)
    println("Subtraction of two numbers $x2")
    var mul: Calculator = Mul()
    var x3 = mul.cal(20,6)
    println("Multiplication of two numbers $x3")
}

Producción:

Addition of two numbers 10
Subtraction of two numbers 4
Multiplication of two numbers 120
Division of two numbers 3