Paradigme Orienté Objet vs Orienté Procédure

L'orientation objet (POO) est un paradigme de conception logicielle qui structure les programmes autour de données et de comportements regroupés. Bien que d'autres paradigmes comme la programmation fonctionnelle ou impérative existent, la POO et la programmation orientée procédure (POP) restent les plus couramment contrastées dans le développement d'applications d'entreprise.

Avec l'augmentation de la complexité des systèmes modernes, l'approche procédurale montre ses limites en termes de maintenabilité et d'extensibilité, ce qui explique la domination actuelle de la POO.

Analyse comparative : Le système de café

Pour illustrer la différence fondamentale entre ces deux approches, prenons l'exemple de la préparation du café.

Approche Orientée Procédure :
L'accent est mis sur la séquence d'actions. Pour faire du café, on définit un algorithme étape par étape : 1. Faire bouillir l'eau, 2. Moudre les grains, 3. Verser l'eau sur le café, 4. Filtrer. Si ce processus doit être répété, on l'encapsule dans une fonction. Cette approche est simple pour des tâches linéaires, mais devient rapidement ingérable lorsque le système évolue (ex: ajouter un système de lait, de sucre, ou gérer plusieurs machines).

Approche Orientée Objet :
L'accent est mis sur les entités qui composent le système. Au lieu de penser "étapes", on pense "composants". Pour concevoir une machine à café, on identifie ses structures fondamentales : le réservoir d'eau, l'élément chauffant, le broyeur, et le filtre. Chaque composant est modélisé comme une entité indépendante possédant ses propres attributs (ex: température, niveau) et comportements (ex: chauffer, broyer). L'assemblage de ces entités permet de résoudre des problèmes complexes de manière modulaire.

En réalité, les deux paradigmes sont complémentaires : la POO fournit l'architecture macroscopique et la modularité, tandis que la POP gère la logique microscopique à l'intérieur des méthodes.

Anatomie d'une Classe et d'un Objet

Les concepts de classe et d'objet sont les piliers de la POO.

• Classe : Un plan de construction ou un modèle abstrait. Elle définit les propriétés et les comportements communs à un ensemble d'entités.
• Objet : Une instance concrète et tangible de cette classe, créée en mémoire pendant l'exécution du programme.

Par exemple, la classe représente le concept abstrait de "Smartphone", tandis qu'un objet spécifique est le smartphone physique que vous tenez dans votre main.

Déclaration et Structure

Une classe en Java est définie avec le mot-clé class. Elle contient des variables d'instance (attributs) et des méthodes (comportements).

public class Smartphone {
    // Attributs (état de l'objet)
    String marque;
    String modele;
    double niveauBatterie;
    boolean estConnecte;

    // Comportement (action de l'objet)
    public void passerAppel(String numero) {
        System.out.println("Initiation de l'appel vers le " + numero);
    }
    
    public void charger() {
        if (niveauBatterie < 100.0) {
            niveauBatterie += 10.0;
            System.out.println("Batterie en charge...");
        }
    }
}

Instanciation

Pour utiliser les fonctionnalités définies par la classe, il faut créer un objet en mémoire à l'aide de l'opérateur new.

// Création d'une instance de Smartphone
Smartphone monAppareil = new Smartphone();

// Accès et modification de l'état
monAppareil.marque = "TechCorp";
monAppareil.niveauBatterie = 85.0;

// Invocation d'un comportement
monAppareil.passerAppel("+33123456789");

Les Constructeurs

Un constructeur est un bloc de code spécial utilisé pour initialiser un objet nouvellement créé. Il porte exactement le même nom que la classe et ne possède aucun type de retour (pas même void).

Si aucun constructeur n'est explicitement défini, le compilateur Java fournit un constructeur par défaut sans paramètres. Cependant, dès qu'un constructeur personnalisé est ajouté, le constructeur par défaut implicite n'est plus généré.

public class Smartphone {
    String marque;
    String modele;
    double niveauBatterie;

    // Constructeur par défaut (explicite)
    public Smartphone() {
        this.marque = "Inconnu";
        this.modele = "Générique";
        this.niveauBatterie = 100.0;
    }

    // Constructeur paramétré
    public Smartphone(String marque, String modele) {
        this.marque = marque;
        this.modele = modele;
        this.niveauBatterie = 100.0;
    }
}

// Utilisation
Smartphone tel1 = new Smartphone(); // Utilise le constructeur par défaut
Smartphone tel2 = new Smartphone("TechCorp", "X-200"); // Utilise le constructeur paramétré

Surcharge des Méthodes (Overloading)

La surcharge permet à une classe de posséder plusieurs méthodes portant le même nom, mais avec des signatures différentes. Cela améliore la lisibilité et la réutilisabilité du code.

Les différences de signature peuvent porter sur :

1. Le nombre de paramètres.
2. Le type des paramètres.
3. L'ordre des paramètres.

Note : Le type de retour ne fait pas partie de la signature et ne peut pas être utilisé pour différencier des méthodes surchargées.

public class Smartphone {
    // ... attributs ...

    // Surcharge 1 : Un seul paramètre
    public void envoyerMessage(String numero) {
        System.out.println("SMS envoyé au " + numero);
    }

    // Surcharge 2 : Deux paramètres de types différents
    public void envoyerMessage(String numero, String contenu) {
        System.out.println("SMS envoyé au " + numero + " : " + contenu);
    }

    // Surcharge 3 : Ordre des paramètres inversé
    public void envoyerMessage(String contenu, int priorite) {
        System.out.println("Message prioritaire (" + priorite + ") : " + contenu);
    }
}

Gestion des Objets et des Références en Mémoire

Lorsqu'une instruction comme Smartphone tel = new Smartphone(); est exécutée, deux entités distinctes sont créées en mémoire :

1. L'objet réel : L'opérateur new alloue de la mémoire dans le Tas (Heap) pour créer l'instance de la classe. Cet objet n'a pas de nom propre et n'est pas accessible directement.
2. La variable de référence : La déclaration Smartphone tel crée une variable dans la Pile (Stack). Cette varible ne contient pas l'objet lui-même, mais une adresse mémoire (un pointeur) endiquant où l'objet se trouve dans le Tas.

Métaphore de la maison et de l'adresse :
Imaginez que l'objet est une maison physique construite dans un grand terrain (le Tas). Vous ne pouvez pas déplacer la maison. La variable de référence est l'adresse postale de cette maison (stockée dans la Pile). Pour interagir avec la maison, vous devez utiliser son adresse.

Smartphone tel1 = new Smartphone(); 
// 1. La maison est construite dans le Tas.
// 2. L'adresse postale 'tel1' est créée dans la Pile et pointe vers la maison.

Smartphone tel2 = tel1; 
// 3. Une nouvelle adresse postale 'tel2' est créée dans la Pile.
// 4. Le contenu de 'tel1' (l'adresse) est copié dans 'tel2'.
// Résultat : 'tel1' et 'tel2' pointent vers la même maison dans le Tas. 
// Aucune nouvelle maison n'a été construite.

Si vous modifiez l'état de l'objet via tel1, le changement sera égallement visible via tel2, car les deux références pointent vers la même instance en mémoire.