Kotlin
Dziedziczenie klas

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


Wprowadzenie

Każdy obiektowy język programowania ma jakąś formę dziedziczenia klas. Pozwól, że poprawię:

Wyobraź sobie, że musiałeś zaprogramować wiązkę owoców: Apples , Oranges i Pears . Wszystkie różnią się rozmiarem, kształtem i kolorem, dlatego mamy różne klasy.

Ale powiedzmy, że ich różnice nie mają znaczenia przez sekundę, a ty po prostu chcesz Fruit , bez względu na to, który dokładnie? Jaki typ zwrotu miałby getFruit() ?

Odpowiedzią jest klasa Fruit . Tworzymy nową klasę i dziedziczymy z niej wszystkie owoce!

Składnia

  • otwórz {klasa podstawowa}
  • class {Derived Class}: {Base Class} ({Init Arguments})
  • nadpisanie {Definicja funkcji}
  • {Obiekt DC} ma wartość {Klasa bazowa} == true

Parametry

Parametr Detale
Klasa podstawowa Klasa, która jest dziedziczona
Klasy pochodnej Klasa dziedziczy po klasie podstawowej
Początkowe argumenty Argumenty przekazane do konstruktora klasy bazowej
Definicja funkcji Funkcja w klasie pochodnej, która ma inny kod niż ten sam w klasie bazowej
Obiekt DC „Derived Class-Object” Obiekt, który ma typ klasy pochodnej

Podstawy: słowo kluczowe „otwarte”

W Kotlinie klasy są domyślnie ostateczne, co oznacza, że nie można ich odziedziczyć.

Aby umożliwić dziedziczenie w klasie, użyj słowa kluczowego open . 

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

Uwaga: klasy abstrakcyjne, klasy zapieczętowane i interfejsy będą domyślnie open .

Dziedziczenie pól z klasy

Definiowanie klasy podstawowej: 

open class BaseClass {
    val x = 10
}

Definiowanie klasy pochodnej: 

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

Korzystanie z podklasy: 

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

Dziedziczenie metod z klasy

Definiowanie klasy podstawowej: 

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

Definiowanie klasy pochodnej: 

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

Ninja ma dostęp do wszystkich metod w Person 

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

Przesłanianie właściwości i metod

Przesłaniające właściwości (zarówno tylko do odczytu, jak i zmienne): 

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
}

Nadrzędne metody: 

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
Licencjonowany na podstawie CC BY-SA 3.0
Nie związany z Stack Overflow