Concepts OOP en Java

La programmation orientée objet (POO) est une façon d'organiser le code autour des choses de votre programme plutôt que des étapes. Au lieu d'un long script qui manipule des variables brutes, vous décrivez les types d'objets de votre domaine — un User, un Order, un BankAccount — et vous donnez à chacun les données et le comportement dont il a besoin. Le reste du programme demande ensuite à ces objets d'agir, plutôt que de triturer leurs entrailles.

Java a été conçu autour de cette idée. Chaque ligne de code Java que vous écrivez vit à l'intérieur d'une classe, et une classe est le modèle à partir duquel les objets sont créés. Jusqu'ici, vous avez surtout écrit du code procédural dans main et quelques assistants statiques ; à partir de cette partie du livre, vous commencez à concevoir vos propres classes.

Classes et objets en une phrase

Une classe décrit un type de chose — quelles données elle contient et ce qu'elle peut faire. Un objet est une instance spécifique de cette chose.

public class Dog {
  String name;
  int age;

  void bark() {
    System.out.println(name + " says woof");
  }
}

Dog d = new Dog();   // d is an object — one specific dog
d.name = "Rex";
d.bark();            // Rex says woof

Dog est la classe. d est un objet. Le changement clé par rapport au code procédural : un objet regroupe l'état (les champs name et age) et le comportement (la méthode bark()) en une seule unité. Vous pouvez créer autant d'objets Dog que vous le souhaitez ; chacun obtient sa propre copie de name et age, et chacun peut bark() de manière indépendante. Le chapitre classes & objets examine cela en détail.

Les quatre piliers

La POO est généralement enseignée autour de quatre idées. Chacune fait l'objet d'un chapitre complet plus loin dans cette partie du livre — ce qui suit est un tour d'horizon de trente secondes pour que vous sachiez où le chemin mène.

Encapsulation

Garder les données d'un objet privées ; exposer le comportement à la place. Le code extérieur appelle account.deposit(50), pas account.balance += 50. L'avantage est que la classe contrôle ses propres invariants — personne d'autre ne peut la mettre dans un état incohérent.

public class Account {
  private int balance;                          // hidden

  public void deposit(int amount) {             // public behavior
    if (amount <= 0) throw new IllegalArgumentException();
    balance += amount;
  }
}

Voir le chapitre sur l'encapsulation.

Héritage

Une classe peut en étendre une autre, récupérant ses champs et méthodes tout en les enrichissant. Cat extends Animal réutilise tout ce qu'Animal fait déjà et ne précise que ce qui est particulier aux chats.

public class Animal {
  void breathe() { System.out.println("inhale, exhale"); }
}
public class Cat extends Animal {
  void purr()   { System.out.println("rrr"); }
}

Cat c = new Cat();
c.breathe();   // inherited
c.purr();      // own

Voir le chapitre sur l'héritage.

Polymorphisme

Le même appel peut faire des choses différentes selon l'objet réel qui le reçoit. Une variable de type Animal peut pointer vers un Cat, un Dog ou une Cow — appeler speak() dessus choisit le bon comportement à l'exécution.

Animal a = new Cat();
a.speak();   // calls Cat's speak, even though a is typed as Animal

Voir le chapitre sur le polymorphisme.

Abstraction

Définir ce que quelque chose fait sans s'engager sur comment. Une interface Shape indique que chaque forme possède une méthode area() ; chaque forme concrète — Circle, Square — fournit sa propre formule. Le code qui travaille avec des formes n'a pas besoin de savoir de quel type il s'agit.

public interface Shape {
  double area();
}

Voir le chapitre sur l'abstraction.

Les piliers en un coup d'œil

Les piliers se chevauchent intentionnellement : le polymorphisme s'appuie sur l'héritage, l'abstraction est imposée par l'encapsulation, etc. Considérez-les comme quatre angles sur une seule idée — modéliser votre programme comme des objets qui coopèrent — plutôt que quatre fonctionnalités distinctes à mémoriser.

Pourquoi se donner cette peine ?

Pour un script de 20 lignes, la POO est excessive. Le bénéfice apparaît à mesure que les programmes grandissent :

• Raisonnement local. Une classe BankAccount possède ses propres règles. Pour comprendre ou modifier les dépôts, vous lisez la méthode deposit — vous ne cherchez pas balance += dans toute la base de code.
• Réutilisation sans copier-coller. L'héritage et la composition permettent à SavingsAccount de s'appuyer sur Account au lieu de le dupliquer.
• Substituabilité. Une fonction qui prend une Shape fonctionne pour toutes les formes qui existent aujourd'hui et pour toutes celles que vous ajouterez demain.
• Testabilité. Les petits objets aux responsabilités claires sont faciles à instancier, à piloter et à vérifier.

Java est loin d'être le seul langage orienté objet — Python, C#, Kotlin, Ruby et bien d'autres partagent les mêmes idées avec une syntaxe différente. Ce que vous apprenez dans cette partie est transférable.

La POO n'est pas le seul paradigme

Même en Java, vous avez déjà écrit du code qui n'est pas strictement orienté objet : méthodes utilitaires statiques, calculs sur des primitives, flux de contrôle simples. Le Java moderne mélange les paradigmes — pipelines fonctionnels avec les streams et les lambdas, données immuables avec les records, travail déclaratif avec les annotations. La POO est l'épine dorsale du langage, pas une cage. Utilisez une classe pour modéliser une chose avec un état et un comportement ; recourez à une méthode statique quand vous avez juste besoin d'un calcul.

Un exemple concret

L'intégralité du code des extraits ci-dessus, réunie pour que vous puissiez l'exécuter :

La suite

Maintenant que vous connaissez la forme de la POO, le chapitre suivant fixe ses fondamentaux : comment une définition de classe devient un objet en mémoire, ce que new fait réellement, et en quoi les références d'objets diffèrent des primitives. Continuez vers Classes et objets Java.

Entraînement