El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia

HOME

En este módulo, exploraremos dos conceptos fundamentales en la programación orientada a objetos (OOP) en F#: la herencia y las interfaces. Estos conceptos permiten la reutilización de código y la creación de sistemas más flexibles y extensibles.

Herencia

La herencia es un mecanismo que permite a una clase derivar de otra clase, heredando sus miembros (propiedades, métodos, etc.). En F#, la herencia se utiliza para crear jerarquías de clases y compartir funcionalidad común.

1.1. Definición de una Clase Base

Primero, definamos una clase base simple:

type Animal(name: string) =
    member this.Name = name
    member this.Speak() = printfn "%s makes a sound" name

1.2. Definición de una Clase Derivada

Ahora, definamos una clase derivada que hereda de Animal:

type Dog(name: string) =
    inherit Animal(name)
    member this.Bark() = printfn "%s barks" this.Name

1.3. Uso de la Herencia

Veamos cómo podemos usar estas clases:

let myDog = Dog("Rex")
myDog.Speak()  // Output: Rex makes a sound
myDog.Bark()   // Output: Rex barks

1.4. Sobrescritura de Métodos

Podemos sobrescribir métodos de la clase base en la clase derivada:

type Cat(name: string) =
    inherit Animal(name)
    override this.Speak() = printfn "%s meows" this.Name

let myCat = Cat("Whiskers")
myCat.Speak()  // Output: Whiskers meows

Interfaces

Las interfaces definen un contrato que las clases pueden implementar. En F#, las interfaces se utilizan para definir comportamientos que pueden ser compartidos por diferentes clases.

2.1. Definición de una Interfaz

Definamos una interfaz simple:

type IAnimal =
    abstract member Speak: unit -> unit

2.2. Implementación de una Interfaz

Ahora, implementemos esta interfaz en una clase:

type Bird(name: string) =
    interface IAnimal with
        member this.Speak() = printfn "%s chirps" name

2.3. Uso de la Interfaz

Podemos usar la interfaz para trabajar con objetos de diferentes clases de manera uniforme:

let myBird = Bird("Tweety") :> IAnimal
myBird.Speak()  // Output: Tweety chirps

2.4. Implementación Múltiple

Una clase puede implementar múltiples interfaces:

type IFlyable =
    abstract member Fly: unit -> unit

type FlyingBird(name: string) =
    interface IAnimal with
        member this.Speak() = printfn "%s chirps" name
    interface IFlyable with
        member this.Fly() = printfn "%s flies" name

let myFlyingBird = FlyingBird("Eagle") :> IAnimal
(myFlyingBird :?> IFlyable).Fly()  // Output: Eagle flies

Ejercicios Prácticos

Ejercicio 1: Crear una Jerarquía de Clases

Define una clase base Vehicle con una propiedad Speed y un método Move.
Crea una clase derivada Car que herede de Vehicle y añada un método Honk.
Instancia un objeto de Car y llama a sus métodos.

Solución:

type Vehicle(speed: int) =
    member this.Speed = speed
    member this.Move() = printfn "The vehicle moves at %d km/h" speed

type Car(speed: int) =
    inherit Vehicle(speed)
    member this.Honk() = printfn "The car honks"

let myCar = Car(100)
myCar.Move()  // Output: The vehicle moves at 100 km/h
myCar.Honk()  // Output: The car honks

Ejercicio 2: Implementar una Interfaz

Define una interfaz IDriveable con un método Drive.
Implementa esta interfaz en una clase Bicycle.
Instancia un objeto de Bicycle y llama al método Drive.

Solución:

type IDriveable =
    abstract member Drive: unit -> unit

type Bicycle() =
    interface IDriveable with
        member this.Drive() = printfn "The bicycle is driven"

let myBicycle = Bicycle() :> IDriveable
myBicycle.Drive()  // Output: The bicycle is driven

Conclusión

En esta sección, hemos aprendido sobre la herencia y las interfaces en F#. La herencia nos permite crear jerarquías de clases y reutilizar código, mientras que las interfaces nos permiten definir contratos que las clases pueden implementar. Estos conceptos son fundamentales para la programación orientada a objetos y nos ayudan a crear sistemas más flexibles y mantenibles.

En el próximo módulo, exploraremos cómo mezclar la programación funcional y orientada a objetos en F#.

Herencia e Interfaces

Herencia

1.1. Definición de una Clase Base

1.2. Definición de una Clase Derivada

1.3. Uso de la Herencia

1.4. Sobrescritura de Métodos

Interfaces

2.1. Definición de una Interfaz

2.2. Implementación de una Interfaz

2.3. Uso de la Interfaz

2.4. Implementación Múltiple

Ejercicios Prácticos

Ejercicio 1: Crear una Jerarquía de Clases

Solución:

Ejercicio 2: Implementar una Interfaz

Solución:

Conclusión

Curso de Programación en F#

Módulo 1: Introducción a F#

Módulo 2: Conceptos Básicos

Módulo 3: Programación Funcional

Módulo 4: Estructuras de Datos Avanzadas

Módulo 5: Programación Orientada a Objetos en F#

Módulo 6: Programación Asíncrona y Paralela

Módulo 7: Acceso y Manipulación de Datos

Módulo 8: Pruebas y Depuración

Módulo 9: Temas Avanzados

Módulo 10: Aplicaciones Prácticas