Object Oriented Programming

What is object-oriented programming?

La programmation orientée objet (OOP) est un modèle de programmation informatique qui organise la conception de logiciels autour de classes et d’objets, plutôt que de fonctions et de logique. Un objet peut être défini comme un champ de données ayant des attributs et un comportement uniques.

La POO se concentre sur les objets que les développeurs veulent manipuler plutôt que sur la logique requise pour les manipuler. Cette approche de la programmation est bien adaptée aux programmes qui sont importants, complexes et activement mis à jour ou maintenus.

What is the structure of object-oriented programming?

Classes : vont nous permettre de créer des objets plus spécifiques et concrets. Elles représentent en général une catégorie assez large, on design les classes parents de manière la moins spécifique possible. ( ex une classe ANIMAL qui va contenir les propriétés et méthodes de base d’un mammifère - manger - se reproduire - ). Les classes définissent quelles méthodes et attributs vont posséder leurs instances MAIS PAS LEUR VALEUR, sauf si bien évidemment on déclare des valeurs par défaut dans la classe.
- Constructeur : le constructeur est une fonction permettent de définir un moule et de créer plusieurs instances à partir de ce moule.
- Attributs : propriétés qui sont définies dans la classe et dont les instances de la classe vont hériter. ( ex ANIMAL.poils , ANIMAL.nombrePattes )
- Méthodes : fonction qui sont définies dans une classe et dont les instances de la classe vont hériter. (ex ANIMAL.seNourrir() , ANIMAL.chasser() )
```
class Voiture {
	// ATTRIBUTS
	public marque: string;
	public couleur: string;
	public poids: number;
	public prix: number;
	constructor(_marque: string,_couleur: string, _poids: number, _prix: number) {
		this.marque=_marque;
		this.couleur=_couleur;
		this.poids=_poids;
		this.prix=_prix;
	}
	// METHODES
	public function rouler() {
		// do something
		console.log(this.marque + " Vroum")
	}
	public function seGarer() {
		console.log('Garée');
	}
	
 }
```
Objets : représentent les INSTANCES d’une classe crées / initialisés avec des VALEURS. Ils représentent des instances SPECIFIQUES d’une classe (ex : Chien instance de la classe ANIMAL ). Chaque objet peux avoir des valeurs spécifiques concernant les propriétés de la classe (chien = 4 pattes, Poule = 2 pattes etc..). On va pouvoir donc définir des valeurs spécifiques pour les instances d’une classe sans affecter les autres instances.
```
// Create a new Voiture instance
const bmw = new Voiture("BMW", "Bleue", 1750, 35000);
const ferrari = new Voiture("Ferrari", "Rouge", 1350, 350000);
// Access property
bmw.couleur ==> "Bleue"
ferrari.couleur ==> "Rouge"
// use methods
bmw.rouler()  ==> "BMW Vroum"
ferrari.rouler() ==> "Ferrari Vroum"
```
Pour tester si un objet contient une propriété on peux utiliser :
```
ferrari.hasOwnProperty('couleur');
==> true;
```

LE THIS :

C'est le mot clef utilisé pour accéder à l'objet créer par un contexte d'exécution

Si la function est exécutée par la méthode d'un objet, alors le THIS pointera vers cet objet ! Sinon le this pointe vers l'objet GLOBAL window.

Une fonction fléchée capture le THIS du scope parent dans lequel elle est DECLAREE.

const classicFunction = function () {
	console.log(this)
}

const arrowFunction = () => console.log(this);

const cyril = {
	name: "Cyril",
	presentClassic : classicFunction, 
	presentArrow : arrowFunction
}

cyril.presentClassic();
⇒ Objet cyril , car c'est l'objet cyril qui exécute la fonction
cyril.presentArrow();
⇒ Objet GLOBAL window car la fonction fléchée est déclarée dans window

Principes de la POO

La programmation orientée objet est basée sur les principes suivants :

Notion de Classe Abstraite

Notion d’interface