Kotlin
Klasse-overerving
Zoeken…
Invoering
Elke objectgeoriënteerde programmeertaal heeft een vorm van klasse-overerving. Laat me herzien:
Stel je voor dat je een bos fruit moest programmeren: Apples , Oranges en Pears . Ze verschillen allemaal in grootte, vorm en kleur, daarom hebben we verschillende klassen.
Maar laten we zeggen dat hun verschillen er geen seconde toe doen en je wilt gewoon een Fruit , ongeacht welke precies? Welk getFruit() zou getFruit() hebben?
Het antwoord is klasse Fruit . We creëren een nieuwe klasse en laten alle vruchten ervan erven!
Syntaxis
- open {Base Class}
- class {Derived Class}: {Base Class} ({Init Argumenten})
- overschrijven {Functiedefinitie}
- {DC-Object} is {Base Class} == waar
parameters
| Parameter | Details |
|---|---|
| Basisklasse | Klasse die is geërfd van |
| Afgeleide klasse | Klasse die erft van Basisklasse |
| Eerste argumenten | Argumenten werden doorgegeven aan constructeur van Base Class |
| Functie definitie | Functie in afgeleide klasse die een andere code heeft dan dezelfde in de basisklasse |
| DC-Object | "Afgeleide klasse-object" Object dat het type van de afgeleide klasse heeft |
Basisprincipes: het 'open' trefwoord
In Kotlin zijn klassen standaard definitief, wat betekent dat ze niet kunnen worden geërfd.
Gebruik het open trefwoord om overname van een klasse toe te staan.
open class Thing {
// I can now be extended!
}
Opmerking: abstracte klassen, verzegeld klassen en interfaces zal worden
opendoor gebrek.
Velden overnemen van een klasse
De basisklasse definiëren:
open class BaseClass {
val x = 10
}
De afgeleide klasse definiëren:
class DerivedClass: BaseClass() {
fun foo() {
println("x is equal to " + x)
}
}
Met behulp van de subklasse:
fun main(args: Array<String>) {
val derivedClass = DerivedClass()
derivedClass.foo() // prints: 'x is equal to 10'
}
Erfmethoden van een klas
De basisklasse definiëren:
open class Person {
fun jump() {
println("Jumping...")
}
}
De afgeleide klasse definiëren:
class Ninja: Person() {
fun sneak() {
println("Sneaking around...")
}
}
De Ninja heeft toegang tot alle methoden in Persoon
fun main(args: Array<String>) {
val ninja = Ninja()
ninja.jump() // prints: 'Jumping...'
ninja.sneak() // prints: 'Sneaking around...'
}
Overheersende eigenschappen en methoden
Overheersende eigenschappen (zowel alleen-lezen als veranderlijk):
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
}
Negatieve methoden:
interface Ship {
fun sail()
fun sink()
}
object Titanic : Ship {
var canSail = true
override fun sail() {
sink()
}
override fun sink() {
canSail = false
}
}