Kotlin
Héritage de classe

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


Introduction

Tout langage de programmation orienté objet possède une forme d'héritage de classe. Laissez moi réviser:

Imaginez que vous deviez programmer une grappe de fruits: Apples , Oranges et Pears . Ils diffèrent tous par la taille, la forme et la couleur, c'est pourquoi nous avons différentes classes.

Mais disons que leurs différences ne comptent pas pour une seconde et que vous voulez juste un Fruit , peu importe exactement? Quel type de retour getFruit() aurait-il?

La réponse est classe Fruit . Nous créons une nouvelle classe et en faisons hériter tous les fruits!

Syntaxe

  • ouvrir {Classe de base}
  • class {Classe dérivée}: {Classe de base} ({Arguments d'initialisation})
  • override {Définition de fonction}
  • {DC-Object} est {Classe de base} == true

Paramètres

Paramètre Détails
Classe de base Classe héritée de
Classe dérivée Classe qui hérite de la classe de base
Init Arguments Arguments passés au constructeur de la classe de base
Définition de fonction Fonction dans la classe dérivée dont le code est différent de celui de la classe de base
DC-Objet ”Objet de classe dérivé” Objet du type de la classe dérivée

Basics: le mot clé 'open'

Dans Kotlin, les classes sont finales par défaut, ce qui signifie qu'elles ne peuvent pas être héritées.

Pour autoriser l'héritage sur une classe, utilisez le mot clé open . 

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

Remarque: les classes abstraites, les classes scellées et les interfaces seront open par défaut.

Héritage de champs d'une classe

Définir la classe de base: 

open class BaseClass {
    val x = 10
}

Définir la classe dérivée: 

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

En utilisant la sous-classe: 

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

Méthodes d'héritage d'une classe

Définir la classe de base: 

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

Définir la classe dérivée: 

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

Le Ninja a accès à toutes les méthodes en personne 

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

Propriétés et méthodes dominantes

Propriétés de substitution (à la fois en lecture seule et mutable): 

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éthodes primordiales: 

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
Sous licence CC BY-SA 3.0
Non affilié à Stack Overflow