Herencia Kotlin

La herencia es una de las características más importantes en la programación orientada a objetos. La herencia permite la reutilización del código, permite que todas las características de una clase existente (clase base) sean heredadas por una nueva clase (clase derivada). Además, la clase derivada también puede agregar algunas características propias.

Sintaxis de herencia:

open class baseClass (x:Int ) {
      ..........
}
class derivedClass(x:Int) : baseClass(x) {
     ...........
}

En Kotlin, todas las clases son definitivas de forma predeterminada. Para permitir que la clase derivada herede de la clase base, debemos usar la palabra clave open delante de la clase base .

Kotlin Heredar propiedades y métodos de la clase base:
cuando heredamos una clase, todas las propiedades y funciones también se heredan. Podemos usar las variables y funciones de la clase base en la clase derivada y también podemos llamar a funciones usando el objeto de la clase derivada. 

//base class
open class baseClass{
    val name = "GeeksforGeeks"
    fun A(){
        println("Base Class")
    }
}
//derived class
class derivedClass: baseClass() {
    fun B() {
        println(name)           //inherit name property
        println("Derived class") 
    }
}
fun main(args: Array<String>) {
    val derived = derivedClass()
    derived.A()         // inheriting the  base class function
    derived.B()         // calling derived class function
}

Producción: 

Base Class
GeeksforGeeks
Derived class

Explicación: 
aquí tenemos una clase base y una clase derivada . Creamos un objeto mientras instanciamos la clase derivada , luego se usa para invocar la clase base y las funciones de la clase derivada . El derivado.A() se usa para llamar a la función A() que imprime «Clase base» . La derivada.B() se usa para llamar a la función B() que imprime el nombre de la variable heredado de la clase base y también imprime «Clase derivada» . 

Uso de la Herencia:

Supongamos que hay tres tipos de empleados en una empresa : webDeveloper , iOSDeveloper y androidDeveloper . Todos ellos tienen algunas características compartidas como el nombre, la edad y también tienen algún tipo especial de habilidades. 
Primero, creamos tres clases individualmente y todos los empleados tienen algunas habilidades comunes y específicas.

Aquí, todos tienen algún nombre y edad , pero la habilidad de desarrollo de los tres desarrolladores es diferente. En cada una de las clases, estaríamos copiando el mismo código de nombre y edad para cada personaje. 
Si queremos agregar una característica de salario() , entonces necesitamos copiar el mismo código en las tres clases. Esto crea una cantidad de copias duplicadas de código en nuestro programa y probablemente conducirá a un código más complejo y errático. 
Al usar la herencia, la tarea se vuelve más fácil. Podemos crear una nueva clase base Empleado,que contiene las características comunes de las 3 clases originales. Estas tres clases pueden heredar características comunes de la clase base y pueden agregar algunas características especiales propias. Podemos agregar fácilmente la función de salario sin copias duplicadas en la clase Empleado .

Aquí, para webDeveloper , heredamos todas las funciones de la clase base y su propio sitio web() de funciones en la clase. Del mismo modo, podemos hacer lo mismo con las otras dos clases androidDeveloper e iosDeveloper . Hace que nuestro código sea más comprensible y extensible.

Programa de herencia Kotlin –  

//base class
open class Employee( name: String,age: Int,salary : Int) {
    init {
        println("My name is $name, $age years old and earning $salary per month. ")
    }
}
//derived class
class webDeveloper( name: String,age: Int,salary : Int): Employee(name, age,salary) {
    fun website() {
        println("I am website developer")
        println()
    }
}
//derived class
class androidDeveloper( name: String,age: Int,salary : Int): Employee(name, age,salary) {
    fun android() {
        println("I am android app developer")
        println()
    }
}
//derived class
class iosDeveloper( name: String,age: Int,salary : Int): Employee(name, age,salary) {
    fun iosapp() {
        println("I am iOS app developer")
        println()
    }
}
//main method
fun main(args: Array<String>) {
    val wd = webDeveloper("Gennady", 25, 10000)
    wd.website()
    val ad = androidDeveloper("Gaurav", 24,12000)
    ad.android()
    val iosd = iosDeveloper("Praveen", 26,15000)
    iosd.iosapp()
}

Producción: 

My name is Gennady, 25 years old and earning 10000 per month. 
I am website developer

My name is Gaurav, 24 years old and earning 12000 per month. 
I am android app developer

My name is Praveen, 26 years old and earning 15000 per month. 
I am iOS app developer

Explicación: 
aquí tenemos una clase base Employee, precedida de la palabra clave open , que contiene las propiedades comunes de las clases derivadas . La clase Empleado tiene un constructor primario con tres variables ‘ nombre, edad y salario’ . También hay tres clases derivadas webDeveloper , androidDeveloper e iosDeveloper que también contienen constructores primarios y todos tienen tres variables.
Primero, instanciamos un objetopara la clase webDeveloper y pase el nombre, la edad y el salario como parámetros a la clase derivada . Inicializará las variables locales y pasará estos valores a la clase base . Luego, llamamos a la función miembro website() usando el objeto ‘ wd’ que imprime la string en la salida estándar.
De manera similar, creamos objetos para las otras dos clases e invocamos sus respectivas funciones miembro. 

Constructor primario de herencia de Kotlin:

Si la clase derivada contiene un constructor primario, entonces necesitamos inicializar el constructor de la clase base usando los parámetros de la clase derivada . En el siguiente programa, tenemos dos parámetros en el constructor principal de la clase base y tres parámetros en la clase derivada.

programa kotlin-  

//base class
open class Employee(name: String,age: Int) {
    init{
        println("Name of the Employee is $name")
        println("Age of the Employee is $age")
    }
}
// derived class
class CEO( name: String, age: Int, salary: Double): Employee(name,age) {
    init {
        println("Salary per annum is $salary crore rupees")
    }
}
fun main(args: Array<String>) {
    CEO("Sunder Pichai", 42, 450.00)
}

Producción: 

Name of the Employee is Sunder Pichai
Age of the Employee is 42
Salary per annum is 450.0 crore rupees

Explicación: 
Aquí, instanciamos la clase derivada CEO y pasamos los valores de los parámetros nombre, edad y salario. Las variables locales de la clase derivada se inicializan con los valores respectivos y pasan el nombre de la variable y la edad como parámetros a la clase Empleado. 
La clase de empleado imprime los nombres y valores de la variable en la salida estándar y transfiere el control a la clase derivada. Luego, la clase derivada ejecuta la instrucción println() y sale. 

Constructor secundario de herencia de Kotlin:

Si la clase derivada no contiene un constructor primario, debemos llamar al constructor secundario de la clase base desde el constructor secundario de la clase derivada usando la palabra clave super . También necesitamos inicializar el constructor secundario de la clase base usando los parámetros de la clase derivada. 

Programa Kotlin: 

//base class
open class Employee {
    constructor(name: String,age: Int){
            println("Name of the Employee is $name")
            println("Age of the Employee is $age")
    }
}
// derived class
class CEO : Employee{
    constructor( name: String,age: Int, salary: Double): super(name,age) {
        println("Salary per annum is $salary million dollars")
    }
}
fun main(args: Array<String>) {
    CEO("Satya Nadela", 48, 250.00)
}

Producción: 

Name of the Employee is Satya Nadela
Age of the Employee is 48
Salary per annum is 250.0 million dollars

Explicación: 
Aquí, instanciamos la clase CEO y pasamos los valores de los parámetros al constructor secundario. Inicializará las variables locales y las pasará a la clase base Empleado usando super(nombre,edad). 

Sustitución de las funciones y propiedades de los miembros:

Si la clase base y la clase derivada contienen una función miembro con el mismo nombre, podemos anular la función miembro base en la clase derivada usando la palabra clave override y también debemos marcar la función miembro de la clase base con la palabra clave abierta .

Programa Kotlin para anular la función miembro:

// base class
open class Animal {
    open fun run() {
        println("Animals can run")
    }
}
// derived class
class Tiger: Animal() {
    override fun run() {       // overrides the run method of base class
        println("Tiger can run very fast")
    }
}
fun main(args: Array<String>) {
    val t = Tiger()
    t.run()
}

Producción: 

Tiger can run very fast

De manera similar, podemos anular la propiedad de la clase base en la clase derivada.

Programa Kotlin para anular la propiedad del miembro:

// base class
open class Animal {
    open var name: String = "Dog"
    open var speed = "40 km/hr"
 
}
// derived class
class Tiger: Animal() {
    override var name = "Tiger"
    override var speed = "100 km/hr"
}
fun main(args: Array<String>) {
    val t = Tiger()
    println(t.name+" can run at speed "+t.speed)
}

Producción: 

Tiger can run at speed 100 km/hr

Llamando a la implementación de la superclase:

También podemos llamar a las funciones o propiedades de los miembros de la clase base desde la clase derivada usando la palabra clave super . En el siguiente programa, hemos llamado a la propiedad de la clase base color y a la función displayCompany() en la clase derivada usando la palabra clave super. 

// base class
open class Phone() {
    var color = "Rose Gold"
    fun displayCompany(name:String) {
        println("Company is: $name")
    }
}
// derived class
class iphone: Phone() {
    fun displayColor(){
       
        // calling the base class property color
        println("Color is: "+super.color)
           
        // calling the base class member function
        super.displayCompany("Apple")
    }
}
fun main(args: Array<String>) {
    val p = iphone()
    p.displayColor()
}

Producción: 

Color is: Rose Gold
Company is: Apple