Kotlin
Eredità di classe

Android firebase iOS Java Language javafx JavaScript Regular Expressions Scala Language spring spring-boot
Ricerca…


introduzione

Qualsiasi linguaggio di programmazione orientato agli oggetti ha una qualche forma di ereditarietà di classe. Fammi rivedere:

Immagina di dover programmare un mucchio di frutta: Apples , Oranges e Pears . Differiscono per dimensioni, forma e colore, ecco perché abbiamo classi diverse.

Ma diciamo che le loro differenze non contano per un secondo e tu vuoi solo un Fruit , non importa quale sia esattamente? Quale tipo di getFruit() avrebbe getFruit() ?

La risposta è classe Fruit . Creiamo una nuova classe e ne ereditiamo tutti i frutti!

Sintassi

  • apri {Base Class}
  • class {Derived Class}: {Base Class} ({Init Arguments})
  • override {Definizione funzione}
  • {DC-Object} è {Base Class} == true

Parametri

Parametro Dettagli
Classe Base Classe ereditata da
Classe derivata Classe che eredita dalla classe base
Argomenti di init Argomenti passati al costruttore di Base Class
Definizione della funzione Funzione nella classe derivata con codice diverso da quello della classe base
DC-Object Oggetto "Derivato oggetto di classe" con il tipo di Classe derivata

Nozioni di base: la parola chiave 'aperta'

In Kotlin, le classi sono definitive di default, il che significa che non possono essere ereditate da.

Per consentire l'ereditarietà su una classe, usa la parola chiave open . 

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

Nota: le classi astratte, le classi sigillate e le interfacce saranno open per impostazione predefinita.

Ereditare i campi da una classe

Definire la classe base: 

open class BaseClass {
    val x = 10
}

Definizione della classe derivata: 

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

Utilizzando la sottoclasse: 

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

Ereditare metodi da una classe

Definire la classe base: 

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

Definizione della classe derivata: 

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

Il Ninja ha accesso a tutti i metodi in Persona 

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

Sovrascrittura di proprietà e metodi

Proprietà di override (sia di sola lettura che mutabili): 

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
}

Metodi di sovrascrittura: 

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
Autorizzato sotto CC BY-SA 3.0
Non affiliato con Stack Overflow