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

Classes i Objectes

Següent ►
►

En aquest mòdul, explorarem com F# maneja la programació orientada a objectes (OOP). Tot i que F# és principalment un llenguatge funcional, també ofereix suport per a OOP, permetent la creació de classes, objectes, herència i interfícies. Aquest enfocament híbrid permet als desenvolupadors utilitzar el millor de tots dos mons.

Continguts

  1. Introducció a les Classes i Objectes
  2. Definició de Classes
  3. Creació d'Objectes
  4. Mètodes i Propietats
  5. Constructors
  6. Herència
  7. Interfícies
  8. Exercicis Pràctics

Introducció a les Classes i Objectes

Les classes són plantilles per crear objectes, que encapsulen dades i comportaments relacionats. Els objectes són instàncies de classes que poden tenir estats i comportaments propis.

Definició de Classes

En F#, les classes es defineixen utilitzant la paraula clau type seguida del nom de la classe i el cos de la classe.

type Person(name: string, age: int) =
    member this.Name = name
    member this.Age = age

Explicació

  • type Person(name: string, age: int) =: Defineix una classe anomenada Person amb dos paràmetres de constructor: name i age.
  • member this.Name = name: Defineix una propietat Name que retorna el valor de name.
  • member this.Age = age: Defineix una propietat Age que retorna el valor de age.

Creació d'Objectes

Per crear una instància d'una classe, simplement cridem el constructor de la classe amb els arguments necessaris.

let person1 = Person("Alice", 30)
printfn "Name: %s, Age: %d" person1.Name person1.Age

Explicació

  • let person1 = Person("Alice", 30): Crea un objecte person1 de la classe Person amb el nom "Alice" i l'edat 30.
  • printfn "Name: %s, Age: %d" person1.Name person1.Age: Imprimeix les propietats Name i Age de l'objecte person1.

Mètodes i Propietats

Les classes poden tenir mètodes (funcions) i propietats (valors associats a l'objecte).

type Person(name: string, age: int) =
    member this.Name = name
    member this.Age = age
    member this.Greet() = printfn "Hello, my name is %s." this.Name

Explicació

  • member this.Greet() = printfn "Hello, my name is %s." this.Name: Defineix un mètode Greet que imprimeix un missatge de salutació utilitzant la propietat Name.

Constructors

Els constructors inicialitzen els objectes quan es creen. F# permet definir constructors primaris i secundaris.

Constructor Primari

El constructor primari es defineix a la mateixa línia que el nom de la classe.

type Person(name: string, age: int) =
    member this.Name = name
    member this.Age = age

Constructor Secundari

Els constructors secundaris es defineixen dins del cos de la classe utilitzant la paraula clau new.

type Person(name: string, age: int) =
    member this.Name = name
    member this.Age = age
    new() = Person("Unknown", 0)

Explicació

  • new() = Person("Unknown", 0): Defineix un constructor secundari que crea una instància de Person amb valors per defecte.

Herència

F# permet que una classe hereti d'una altra classe utilitzant la paraula clau inherit.

type Person(name: string, age: int) =
    member this.Name = name
    member this.Age = age

type Student(name: string, age: int, studentId: string) =
    inherit Person(name, age)
    member this.StudentId = studentId

Explicació

  • inherit Person(name, age): La classe Student hereta de Person i passa els paràmetres name i age al constructor de Person.
  • member this.StudentId = studentId: Defineix una propietat StudentId específica de la classe Student.

Interfícies

Les interfícies defineixen contractes que les classes poden implementar. En F#, les interfícies es defineixen amb la paraula clau interface.

type IGreet =
    abstract member Greet: unit -> unit

type Person(name: string) =
    interface IGreet with
        member this.Greet() = printfn "Hello, my name is %s." name

Explicació

  • type IGreet = abstract member Greet: unit -> unit: Defineix una interfície IGreet amb un mètode abstracte Greet.
  • interface IGreet with member this.Greet() = printfn "Hello, my name is %s." name: La classe Person implementa la interfície IGreet.

Exercicis Pràctics

Exercici 1: Definir una Classe

Defineix una classe Car amb les propietats Make, Model i Year. Afegeix un mètode DisplayInfo que imprimeixi la informació del cotxe.

type Car(make: string, model: string, year: int) =
    member this.Make = make
    member this.Model = model
    member this.Year = year
    member this.DisplayInfo() = printfn "Make: %s, Model: %s, Year: %d" this.Make this.Model this.Year

Exercici 2: Crear una Instància i Utilitzar Mètodes

Crea una instància de la classe Car i crida el mètode DisplayInfo.

let car1 = Car("Toyota", "Corolla", 2020)
car1.DisplayInfo()

Exercici 3: Herència

Defineix una classe ElectricCar que hereti de Car i afegeixi una propietat BatteryLife.

type ElectricCar(make: string, model: string, year: int, batteryLife: int) =
    inherit Car(make, model, year)
    member this.BatteryLife = batteryLife
    member this.DisplayBatteryLife() = printfn "Battery Life: %d hours" this.BatteryLife

Solucions

Solució Exercici 1

type Car(make: string, model: string, year: int) =
    member this.Make = make
    member this.Model = model
    member this.Year = year
    member this.DisplayInfo() = printfn "Make: %s, Model: %s, Year: %d" this.Make this.Model this.Year

Solució Exercici 2

let car1 = Car("Toyota", "Corolla", 2020)
car1.DisplayInfo()

Solució Exercici 3

type ElectricCar(make: string, model: string, year: int, batteryLife: int) =
    inherit Car(make, model, year)
    member this.BatteryLife = batteryLife
    member this.DisplayBatteryLife() = printfn "Battery Life: %d hours" this.BatteryLife

Conclusió

En aquest tema, hem après com definir classes i objectes en F#, com crear instàncies, definir mètodes i propietats, utilitzar constructors, implementar herència i interfícies. Aquestes habilitats són fonamentals per treballar amb la programació orientada a objectes en F#. En el proper tema, explorarem com combinar la programació funcional i orientada a objectes en F#.

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