Kotlin
Herencia de clase

Android firebase iOS Java Language javafx JavaScript Regular Expressions Scala Language spring spring-boot
Buscar..


Introducción

Cualquier lenguaje de programación orientado a objetos tiene alguna forma de herencia de clase. Déjame revisar:

Imagina que tienes que programar un montón de frutas: Apples , Oranges y Pears . Todos ellos difieren en tamaño, forma y color, por eso tenemos diferentes clases.

Pero digamos que sus diferencias no importan por un segundo y usted solo quiere una Fruit , ¿no importa cuál exactamente? ¿Qué tipo de retorno tendría getFruit() ?

La respuesta es clase Fruit . ¡Creamos una nueva clase y hacemos que todas las frutas hereden de ella!

Sintaxis

  • abrir {clase base}
  • class {Clase derivada}: {Clase base} ({Init Arguments})
  • anular {definición de función}
  • {DC-Object} es {Clase base} == verdadero

Parámetros

Parámetro Detalles
Clase base Clase que se hereda de
Clase derivada Clase que hereda de la clase base.
Argumentos Iniciales Argumentos pasados ​​al constructor de la clase base
Definición de la función Función en la clase derivada que tiene un código diferente al mismo en la clase base
Objeto DC "Objeto de clase derivado" Objeto que tiene el tipo de la clase derivada

Conceptos básicos: la palabra clave 'abrir'

En Kotlin, las clases son finales por defecto, lo que significa que no se pueden heredar de.

Para permitir la herencia en una clase, use la palabra clave open . 

open class Thing {
    // I can now be extended!
}

Nota: las clases abstractas, las clases selladas y las interfaces estarán open de forma predeterminada.

Heredando campos de una clase

Definiendo la clase base: 

open class BaseClass {
    val x = 10
}

Definiendo la clase derivada: 

class DerivedClass: BaseClass() {
    fun foo() {
        println("x is equal to " + x)
    }
}

Usando la subclase: 

fun main(args: Array<String>) {
    val derivedClass = DerivedClass()
    derivedClass.foo() // prints: 'x is equal to 10'
}

Heredando métodos de una clase.

Definiendo la clase base: 

open class Person {
    fun jump() {
        println("Jumping...")
    }
}

Definiendo la clase derivada: 

class Ninja: Person() {
    fun sneak() {
        println("Sneaking around...")
    }
}

El Ninja tiene acceso a todos los métodos en persona 

fun main(args: Array<String>) {
    val ninja = Ninja()
    ninja.jump()  // prints: 'Jumping...'
    ninja.sneak() // prints: 'Sneaking around...'
}

Anulando propiedades y métodos

Propiedades de reemplazo (tanto de solo lectura como mutables): 

abstract class Car {
    abstract val name: String;
    open var speed: Int = 0;
}

class BrokenCar(override val name: String) : Car() {
    override var speed: Int
        get() = 0
        set(value) {
            throw UnsupportedOperationException("The car is bloken")
        }
}

fun main(args: Array<String>) {
    val car: Car = BrokenCar("Lada")
    car.speed = 10
}

Métodos de anulación: 

interface Ship {
    fun sail()
    fun sink()
}

object Titanic : Ship {

    var canSail = true

    override fun sail() {
        sink()
    }

    override fun sink() {
        canSail = false
    }
}


Modified text is an extract of the original Stack Overflow Documentation
Licenciado bajo CC BY-SA 3.0
No afiliado a Stack Overflow