El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Herència i Interfícies

Següent ►
►

En aquest tema, explorarem dos conceptes fonamentals de la programació orientada a objectes (OOP) en Kotlin: l'herència i les interfícies. Aquests conceptes permeten crear jerarquies de classes i definir contractes que les classes poden implementar, respectivament.

Herència

L'herència és un mecanisme que permet a una classe derivar-se d'una altra classe, heretant-ne les propietats i els mètodes. La classe de la qual es deriva s'anomena "classe base" o "superclasse", mentre que la classe que hereta s'anomena "classe derivada" o "subclasse".

Definició d'una Classe Base

open class Animal(val name: String) {
    fun eat() {
        println("$name is eating.")
    }
}

En aquest exemple, Animal és una classe base. La paraula clau open indica que aquesta classe pot ser heretada.

Definició d'una Subclasse

class Dog(name: String) : Animal(name) {
    fun bark() {
        println("$name is barking.")
    }
}

Aquí, Dog és una subclasse que hereta de Animal. La subclasse pot accedir als mètodes i propietats de la classe base.

Exemple Pràctic

fun main() {
    val dog = Dog("Buddy")
    dog.eat()  // Output: Buddy is eating.
    dog.bark() // Output: Buddy is barking.
}

Sobreescriptura de Mètodes

Les subclasses poden sobreescriure els mètodes de la classe base utilitzant la paraula clau override.

open class Animal(val name: String) {
    open fun sound() {
        println("$name makes a sound.")
    }
}

class Dog(name: String) : Animal(name) {
    override fun sound() {
        println("$name barks.")
    }
}

Interfícies

Les interfícies defineixen un conjunt de mètodes i propietats que una classe pot implementar. A diferència de les classes, les interfícies no poden tenir estat (no poden tenir camps amb valors).

Definició d'una Interfície

interface Drivable {
    fun drive()
}

Implementació d'una Interfície

class Car : Drivable {
    override fun drive() {
        println("The car is driving.")
    }
}

Exemple Pràctic

fun main() {
    val car = Car()
    car.drive() // Output: The car is driving.
}

Interfícies amb Propietats

Les interfícies poden declarar propietats, però aquestes no poden tenir valors inicials.

interface Identifiable {
    val id: String
}

class User(override val id: String) : Identifiable

Exercicis Pràctics

Exercici 1: Herència

Crea una classe base Vehicle amb una propietat brand i un mètode start(). Després, crea una subclasse Car que hereti de Vehicle i afegeixi un mètode drive().

Solució

open class Vehicle(val brand: String) {
    fun start() {
        println("$brand is starting.")
    }
}

class Car(brand: String) : Vehicle(brand) {
    fun drive() {
        println("$brand is driving.")
    }
}

fun main() {
    val car = Car("Toyota")
    car.start()  // Output: Toyota is starting.
    car.drive()  // Output: Toyota is driving.
}

Exercici 2: Interfícies

Defineix una interfície Flyable amb un mètode fly(). Implementa aquesta interfície en una classe Bird.

Solució

interface Flyable {
    fun fly()
}

class Bird : Flyable {
    override fun fly() {
        println("The bird is flying.")
    }
}

fun main() {
    val bird = Bird()
    bird.fly() // Output: The bird is flying.
}

Resum

En aquesta secció, hem après sobre l'herència i les interfícies en Kotlin. L'herència permet a les classes derivar-se d'altres classes, heretant-ne les propietats i els mètodes. Les interfícies defineixen contractes que les classes poden implementar, proporcionant una manera de garantir que certes funcionalitats estiguin presents en les classes que implementen aquestes interfícies. Aquests conceptes són fonamentals per a la programació orientada a objectes i permeten crear codi més modular i reutilitzable.

◄ Anterior
◄
Següent ►
►
El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats