Kotlin
Klass ärft

Android firebase iOS Java Language javafx JavaScript Regular Expressions Scala Language spring spring-boot
Sök…


Introduktion

Alla objektorienterade programmeringsspråk har någon form av klassarv. Låt mig se över:

Föreställ dig att du var tvungen att programmera ett gäng frukt: Apples , Oranges och Pears . De har alla olika storlek, form och färg, det är därför vi har olika klasser.

Men låt oss säga att deras skillnader inte betyder någon sekund och att du bara vill ha en Fruit , oavsett vilken exakt? Vilken getFruit() skulle getFruit() ha?

Svaret är klass Fruit . Vi skapar en ny klass och får alla frukter att ärva från den!

Syntax

  • öppna {Base Class}
  • klass {Derived Class}: {Base Class} ({Init Arguments})
  • åsidosätta {Funktionsdefinition}
  • {DC-Object} är {Base Class} == true

parametrar

Parameter detaljer
Basklass Klass som ärvs från
Deriverad klass Klass som ärver från basklassen
Init-argument Argument överförda till konstruktören av basklassen
Funktionsdefinition Funktion i deriverad klass som har annan kod än samma i basklassen
DC-Object ”Derived Class-Object” Objekt som har typen av Derived Class

Grunder: det "öppna" nyckelordet

I Kotlin är klasser som standard slutliga vilket innebär att de inte kan ärvas från.

Använd det open nyckelordet för att tillåta arv på en klass. 

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

Obs: abstrakta klasser, förseglade klasser och gränssnitt kommer att vara open standard.

Arv fält från en klass

Definiera basklassen: 

open class BaseClass {
    val x = 10
}

Definiera den härledda klassen: 

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

Använda underklassen: 

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

Arvande metoder från en klass

Definiera basklassen: 

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

Definiera den härledda klassen: 

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

Ninja har tillgång till alla metoder i Person 

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

Övervägande egenskaper och metoder

Överträffande egenskaper (både skrivskyddad och muterbar): 

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
}

Övervägande metoder: 

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
Licensierat under CC BY-SA 3.0
Inte anslutet till Stack Overflow