Classes & POO

class Utilisateur {
  nom: string
  email: string
  age: number

  constructor(nom: string, email: string, age: number) {
    this.nom = nom
    this.email = email
    this.age = age
  }

  sePresenter(): string {
    return `Je suis ${this.nom}, j'ai ${this.age} ans.`
  }
}

const alice = new Utilisateur("Alice", "alice@email.com", 25)
console.log(alice.sePresenter())  // "Je suis Alice, j'ai 25 ans."
console.log(alice.nom)            // "Alice"

class CompteBancaire {
  public titulaire: string       // ← Accessible partout (défaut)
  private solde: number          // ← Accessible seulement dans la classe
  protected banque: string       // ← Accessible dans la classe et ses enfants

  constructor(titulaire: string, solde: number) {
    this.titulaire = titulaire
    this.solde = solde
    this.banque = "BanqueTS"
  }

  // Méthode publique pour accéder au solde
  public consulterSolde(): string {
    return `Solde de ${this.titulaire} : ${this.solde}€`
  }

  // Méthode pour modifier le solde de façon contrôlée
  public deposer(montant: number): void {
    if (montant <= 0) throw new Error("Montant invalide")
    this.solde += montant
  }
}

const compte = new CompteBancaire("Alice", 1000)
compte.titulaire       // ✅ Public
// compte.solde         // ❌ Erreur : 'solde' est privé
compte.consulterSolde() // ✅ "Solde de Alice : 1000€"

// Version courte - les paramètres deviennent automatiquement des propriétés
class Produit {
  constructor(
    public nom: string,
    public prix: number,
    private stock: number = 0
  ) {}
  // Plus besoin de this.nom = nom, etc.

  acheter(quantite: number): boolean {
    if (quantite > this.stock) return false
    this.stock -= quantite
    return true
  }
}

const laptop = new Produit("MacBook", 2499, 10)
console.log(laptop.nom)    // ✅ "MacBook"
// console.log(laptop.stock) // ❌ Privé

class Animal {
  constructor(
    public nom: string,
    protected son: string
  ) {}

  faireDuBruit(): string {
    return `${this.nom} fait : ${this.son}`
  }
}

class Chien extends Animal {
  constructor(nom: string) {
    super(nom, "Woof !")  // Appelle le constructeur parent
  }

  rapporter(objet: string): string {
    return `${this.nom} rapporte ${objet} !`
  }
}

class Chat extends Animal {
  constructor(nom: string) {
    super(nom, "Miaou !")
  }

  ronronner(): string {
    return `${this.nom} ronronne...`
  }
}

const rex = new Chien("Rex")
rex.faireDuBruit()     // "Rex fait : Woof !"
rex.rapporter("balle") // "Rex rapporte balle !"

const minou = new Chat("Minou")
minou.faireDuBruit()   // "Minou fait : Miaou !"
minou.ronronner()      // "Minou ronronne..."

abstract class Forme {
  abstract aire(): number        // ← Les enfants DOIVENT implémenter
  abstract perimetre(): number   // ← Les enfants DOIVENT implémenter

  // Méthode concrète partagée
  description(): string {
    return `Aire: ${this.aire().toFixed(2)}, Périmètre: ${this.perimetre().toFixed(2)}`
  }
}

class Cercle extends Forme {
  constructor(private rayon: number) {
    super()
  }

  aire(): number {
    return Math.PI * this.rayon ** 2
  }

  perimetre(): number {
    return 2 * Math.PI * this.rayon
  }
}

class Rectangle extends Forme {
  constructor(
    private largeur: number,
    private hauteur: number
  ) {
    super()
  }

  aire(): number {
    return this.largeur * this.hauteur
  }

  perimetre(): number {
    return 2 * (this.largeur + this.hauteur)
  }
}

// const forme = new Forme()   // ❌ Impossible : classe abstraite
const cercle = new Cercle(5)
console.log(cercle.description())    // "Aire: 78.54, Périmètre: 31.42"

interface Serializable {
  toJSON(): string
}

interface Validable {
  estValide(): boolean
}

// Une classe peut implémenter PLUSIEURS interfaces
class Formulaire implements Serializable, Validable {
  constructor(
    private champs: Record<string, string>
  ) {}

  toJSON(): string {
    return JSON.stringify(this.champs)
  }

  estValide(): boolean {
    return Object.values(this.champs).every(v => v.length > 0)
  }
}

const form = new Formulaire({ nom: "Alice", email: "alice@email.com" })
form.estValide()  // true
form.toJSON()     // '{"nom":"Alice","email":"alice@email.com"}'

class Temperature {
  private _celsius: number

  constructor(celsius: number) {
    this._celsius = celsius
  }

  // Getter : accéder comme une propriété
  get celsius(): number {
    return this._celsius
  }

  get fahrenheit(): number {
    return this._celsius * 9/5 + 32
  }

  // Setter : modifier avec validation
  set celsius(valeur: number) {
    if (valeur < -273.15) {
      throw new Error("En dessous du zéro absolu !")
    }
    this._celsius = valeur
  }
}

const temp = new Temperature(25)
console.log(temp.celsius)      // 25 (getter)
console.log(temp.fahrenheit)   // 77 (getter calculé)

temp.celsius = 100             // setter avec validation
// temp.celsius = -300          // ❌ Erreur !