Kotlin
Klassenvererbung

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


Einführung

Jede objektorientierte Programmiersprache hat irgendeine Form der Klassenvererbung. Lass mich überarbeiten:

Stellen Sie sich vor, Sie müssten einen Haufen Obst programmieren: Apples , Oranges und Pears . Sie unterscheiden sich alle in Größe, Form und Farbe, deshalb haben wir unterschiedliche Klassen.

Aber lassen Sie uns sagen, dass ihre Unterschiede für eine Sekunde keine Rolle spielen und Sie wollen einfach nur eine Fruit , egal welche genau? Welchen Rückgabetyp hätte getFruit() ?

Die Antwort ist Klasse Fruit . Wir erstellen eine neue Klasse und lassen alle Früchte davon erben!

Syntax

  • offen {Basisklasse}
  • Klasse {Abgeleitete Klasse}: {Basisklasse} ({Init-Argumente})
  • überschreiben {Funktionsdefinition}
  • {DC-Object} ist {Base Class} == wahr

Parameter

Parameter Einzelheiten
Basisklasse Klasse, von der vererbt wird
Abgeleitete Klasse Klasse, die von der Basisklasse erbt
Init-Argumente An den Konstruktor der Basisklasse übergebene Argumente
Funktionsdefinition Funktion in abgeleiteter Klasse, deren Code sich von der Basisklasse unterscheidet
DC-Objekt "Abgeleitetes Klassenobjekt" Objekt, das den Typ der abgeleiteten Klasse hat

Grundlagen: das Schlüsselwort 'open'

In Kotlin sind Klassen standardmäßig final, dh sie können nicht von übernommen werden.

Um die Vererbung einer Klasse zuzulassen, verwenden Sie das Schlüsselwort open . 

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

Hinweis: Abstrakte Klassen, versiegelte Klassen und Schnittstellen sind standardmäßig open .

Felder von einer Klasse übernehmen

Definieren der Basisklasse: 

open class BaseClass {
    val x = 10
}

Definieren der abgeleiteten Klasse: 

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

Verwendung der Unterklasse: 

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

Methoden von einer Klasse übernehmen

Definieren der Basisklasse: 

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

Definieren der abgeleiteten Klasse: 

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

Der Ninja hat Zugriff auf alle Methoden in Person 

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

Eigenschaften und Methoden überschreiben

Überschreibende Eigenschaften (sowohl schreibgeschützt als auch veränderbar): 

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
}

Überschreibende Methoden: 

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
Lizenziert unter CC BY-SA 3.0
Nicht angeschlossen an Stack Overflow