Initiation à la programmation orientée objet

Benoît Prieur

► To cite this version:

Benoît Prieur. Initiation à la programmation orientée objet. École thématique. Initiation à la programmation orientée objet, Lyon, France. 2020, pp.26. hal-02971380

HAL Id: hal-02971380

https://hal.science/hal-02971380v1

Submitted on 19 Oct 2020

HAL is a multi-disciplinary open access
archive for the deposit and dissemination of sci-
entific research documents, whether they are pub-
lished or not. The documents may come from
teaching and research institutions in France or
abroad, or from public or private research centers.

L'archive ouverte pluridisciplinaire HAL, est
destinée au dépôt et à la diffusion de documents
scientifiques de niveau recherche, publiés ou non,
émanant des établissements d'enseignement et de
recherche français ou étrangers, des laboratoires
publics ou privés.

<figure><img src="image_1.png" /></figure>

Distributed under a Creative Commons CC BY-SA 4.0 - Attribution - ShareAlike - International
License
<figure><img src="image_2.png" /></figure>

# Initiation à la programmation orientée objet (POO)

V 0.3 (19 octobre 2020) - IT-Akademy (Lyon, octobre 2020)

Benoît Prieur - Soarthec - CC-By-SA 4.0
# Introduction

* Paradigme de programmation.

* Permet de représenter les objets et leurs relations.

* Possibilité de représentation graphique : le diagramme de classes en particulier en modélisation UML.

* Nombreux langages objets : C++, Lua, C#, Python etc.

* On utilise ici les deux langages déjà étudiés : JavaScript et PHP.
<figure><img src="image_3.png" /></figure>

L'objet : les attributs et les méthodes

* On parle d'attributs pour désigner les propriétés, c'est-à-dire les caractéristiques de l'objet.

* On parle de méthodes pour désigner les différents comportements de l'objet.
La visibilité

* Un attribut ou une méthode a une **visibilité**. C'est-à-dire que l'on indique qui peut avoir ou non accès au dit attribut.

* La visibilité par défaut dépend du langage : en PHP, la visibilité est publique (*public*).

* Ainsi on utilisera les deux mots-clés suivants relatifs à la visibilité :

* **public** et **private** (il existe aussi **protected**)
La visibilité (2)

* **public** : un attribut public est *a priori* visible de partout (la classe peut elle-même avoir une visibilité au sein du paquetage ce qui peut moduler le "partout").

* **private** : un champ privé n'est visible que depuis la classe à laquelle elle appartient. Elle n'est visible nulle part ailleurs (même depuis les sous-classes).
<figure><img src="image_4.png" /></figure>

# Les attributs

class Personne

{ private $annee_naissance;

private $nom; }
<figure><img src="image_5.png" /></figure>

Les méthodes

* Décrit le comportement de la classe.

* Notion d'accesseur.

* Des méthodes particulières :

* Le(s) constructeur(s)

* Notion de destructeur
<figure><img src="image_6.png" /></figure>

# Les méthodes (2)

Utilisation du mot-clé **function**.

```php
public function afficher()
{
    // Implémentation de la méthode
}
```
<figure><img src="image_7.png" /></figure>

## Pointeur *this*

* Ce pointeur permet d'obtenir l'adresse de l'instance courante, c'est-à-dire de référencer l'instance courante.

* Quand on utilise *this*, on se place en quelque sorte du point de vue de l'instance courante, pour accéder directement aux attributs et aux méthodes de l'instance.
Constructeurs et destructeur

* Il existe un **constructeur par défaut**. C'est-à-dire qu'on peut instancier une classe sans avoir décrit un constructeur explicitement.

* On peut expliciter un **constructeur par recopie**. C'est-à-dire un constructeur qui prend en paramètre une instance existante pour en produire une nouvelle, semblable.
<figure><img src="image_8.png" /></figure>

# Constructeurs

En PHP, on utilise **__construct** pour définir une méthode comme constructeur. Par exemple :

```php
public function __construct($n, $a)
{
    $this->annee_naissance = $a;
    $this->nom = $n;
}
```
<figure><img src="image_9.png" /></figure>

Les méthodes-accesseurs

*   **Getter/ Setter** : typiquement on déclare un attribut en *private* et on y accède en modification et en obtention via deux méthodes publiques.

• Méthode de lecture et écriture d'un attribut

○ Les attributs sont *private* ou *protected*.

○ Les accesseurs sont *public*.
<figure><img src="image_10.png" /></figure>

## L'instanciation

La création d'une nouvelle instance se fait par appel de l'un des constructeurs.

Par exemple :

```perl
$instance = new Personne("Charles de Gaulle", 1890);
```
<figure><img src="image_11.png" /></figure>

## L'encapsulation

L'encapsulation désigne le fait d'unifier les caractéristiques et les comportements d'un objet, réel ou non, dans une classe.

Les diverses visibilités participent à l'encapsulation : ce que l'on expose à l'extérieur, ou non.
<figure><img src="image_12.png" /></figure>

## L'héritage (et surcharge de méthodes)

L'héritage consiste à spécialiser une classe A en une classe B. Ainsi la classe B n'a pas besoin de redéfinir attributs et méthodes issues de la **classe-mère** A. B est une **classe-fille**.

Il est également possible de redéfinir une méthode héritée d'une classe-mère. On parle de surcharge.
<figure><img src="image_13.png" /></figure>

# L'héritage (2)

En PHP, on utilise le mot-clé **extends**.

```php
<?php
```

```php
class Animal
```

```php
{
    public $nom;
    public function Fairedubruit()
    {
        echo 'je fais du bruit';
    }
}
```

```php
}
```

```php
class Chat extends Animal
```

```php
{
    public function Fairedubruit()
    {
        echo 'je miaule';
    }
}
```
<figure><img src="image_14.png" /></figure>

## Membres statiques

Un membre statique est un attribut ou une méthode statique ; c'est-à-dire qu'il n'est pas nécessaire d'avoir une instance pour l'utiliser. On peut ainsi appeler une méthode statique directement depuis la classe elle-même, sans recourir à une instance (qui n'existe d'ailleurs pas forcément).
<figure><img src="image_15.png" /></figure>

Un mot sur le polymorphisme

Le **polymorphisme** désigne la possibilité qu'une classe-mère ait “plusieurs formes”. Ainsi une classe *FormeGeometrique* peut avoir une classe-fille *Cercle*, une autre *Triangle*, etc.
## Un mot sur l'héritage multiple

Il est possible dans certains langages de faire hériter une classe de plusieurs classes (en C++ en particulier).

Plus généralement il est possible de faire hériter une classe d'une autre classe et par ailleurs de la faire implémenter différentes interfaces (voir slide suivant pour définition).
## Un mot au sujet des interfaces

* Une **interface** définit un contrat entre une classe et ladite interface qu'elle implémente.

* Une interface ne contient que des prototypes de méthodes non-implémentées.

* La classe qui implémente l'interface doit fournir une implémentation pour chacune des méthodes de l'interface.

* On parle d'implémenter une interface (et non hériter d'une interface).
<figure><img src="image_16.png" /></figure>

## Un mot au sujet des classes abstraites

Une classe abstraite est une classe qui est non-instantanciable et qui en général n'a pas vocation à l'être.

Soit une classe Véhicule et deux classes-filles Bateau et Avion. Il est judicieux de définir la classe Véhicule en classe abstraite.
# Le diagramme de classes UML

Une représentation graphique d'un ensemble de classes peut être le diagramme de classes UML, l'un des diagrammes du langage de modélisation UML.

<figure><img src="image_17.png" /><figcaption>Diagrama de Clases</figcaption></figure>

Crédit : Wilfredor / CC BY-SA
(https://creativecommons.org/licenses/by-sa/3.0)
<figure><img src="image_18.png" /></figure>

# Troisième jour : sujet (1)

* Créer une classe **Combattant**

* Il existe trois types de combattants :

* Junior

* Confirmé

* Vétéran
<figure><img src="image_19.png" /></figure>

# Troisième jour : sujet (2)

* Créer une classe **Arme**

* Une instance de Combattant peut avoir une ou plusieurs armes.

* Chaque arme a des caractéristiques de combat (dégâts infligés au combattant adverse)

* Chaque combattant a une jauge d'énergie ou de vie.
<figure><img src="image_20.png" /></figure>

Troisième jour : sujet (3)

* Mettre en place la possibilité de faire un combat entre deux combattants.

* L'interface HTML est encouragée mais facultative.

* Versionner le projet sur Git.

* Commenter et prévoir une documentation succincte (README.txt).
Une solution possible

* Pas de classe Arme pour simplifier l'ensemble.

* Solution impliquant abstract, static, extends, _construct. Noter le passage par référence (par opposition à un passage par valeur).

* Utilisation d'un bac à sable en ligne pour tester le code :
  https://sandbox.onlinephpfunctions.com/

* Code disponible ici :

https://github.com/benprieur/IT-Ak-PHP/blob/main/app.php