Programmation Orientée Objet

Ce matériel couvre les bases de la Programmation Orientée Objet (POO) en Java, destiné aux étudiants de niveau Licence 2. Il présente les concepts fondamentaux tels que la définition de classes, la création d’objets, les attributs, les méthodes, l’encapsulation, ainsi que des notions pratiques comme les constructeurs, la surcharge, les accesseurs, et l’utilisation des packages.

Introduction à la Programmation Orientée Objet

La Programmation Orientée Objet (POO) est une méthode d’implémentation où les programmes sont organisés en collections coopératives d’objets. Chaque objet est une instance d’une classe, et toutes les classes appartiennent à une hiérarchie unie par des relations d’héritage.

Les notions clés de la POO sont :

• Classe et objets
• Encapsulation
• Héritage (détaillé dans un chapitre ultérieur)
• Polymorphisme (détaillé dans un chapitre ultérieur)
• Abstraction (détaillé dans un chapitre ultérieur)

Définition de la Classe

Une classe est un type complexe qui regroupe un ensemble de données (attributs) et un ensemble de méthodes permettant de traiter ces données. Elle représente un ensemble d’objets ayant la même structure mémoire et les mêmes comportements. Une classe définit cette structure et ces comportements, et peut générer des instances (objets).

Syntaxe générale en Java :

{public/private} | abstract | final | class nomClasse {
  /* Corps de la classe */
}

Les modificateurs :

• public/private : définissent la portée et la visibilité de la classe ou de ses membres.
• abstract : la classe ne peut pas être instanciée.
• final : la classe ne peut pas être dérivée.

Exemple :

public class Voiture {
  ...
}

Les Membres d’une Classe

Une classe est composée de :

• Attributs : variables représentant l’état de l’objet.
• Méthodes : fonctions ou procédures définissant le comportement.
• Constructeurs : méthodes particulières pour initialiser les objets.
• Accesseurs : getters et setters pour accéder et modifier les attributs.

Attributs

Les attributs sont des variables qui représentent l’état d’un objet. Ils peuvent être de types primitifs ou objets. Leur portée est définie par les modificateurs private, protected, ou public. Des mots-clés optionnels peuvent être utilisés :

• static : variable de classe partagée par toutes les instances.
• final : variable constante, assignée une seule fois.

Déclaration d’un attribut :

{private/protected/public} | static | final | type nomAttribut;

Exemple :

public class Voiture {
  private final String NImm; // numéro d’immatriculation constant
  private String Marque;
  private String Couleur;
  private int km;
}

La Portée (Visibilité) des Membres

La portée d’un identificateur est la zone du programme où il est visible. Les modificateurs principaux sont :

Modificateur	Visibilité
private	Seulement dans la classe
protected	Dans la classe et ses sous-classes
public	Partout
par défaut (sans modificateur)	Dans le même package

Variables de Classe (Attributs static)

Les variables static sont partagées par toutes les instances d’une classe. Elles peuvent être référencées :

• Directement par leur nom dans les méthodes de la classe.
• Par la notation pointée via la classe : Classe.nomVariable.
• Par la notation pointée via une instance : instance.nomVariable.

Exemple :

class Tunisien {
  private String nom, prenom, adresse;
  private int age;
  private static String president = "KS";
  ...
}

System.out.println("Le président des Tunisiens est : " + Tunisien.president);
Tunisien ahmed = new Tunisien();
System.out.println("Le président des Tunisiens est : " + ahmed.president);

Méthodes

Une méthode est une fonction ou procédure définie au sein d’une classe, décrivant comment une instance réagit à un message (appel de méthode). Sa signature comprend le nom, le type des paramètres et le type de retour.

Syntaxe générale :

{private/protected/public} | static | abstract | final | typeDeRetour nomMethode(type param1, type param2, ...) throws ...

Modificateurs :

• static : méthode de classe.
• abstract : méthode abstraite (sans implémentation).
• final : méthode ne pouvant être redéfinie.

Méthodes de classe (static)

Une méthode static définit une propriété fonctionnelle de la classe elle-même, pas de ses instances.

Exemple :

Integer.MaxValue(val1, val2);

Appel de méthode (Envoi de message)

Syntaxe :

receveur.selecteur(arg1, ..., argn);

Exemples :

voit.rouler();
int c = voit.rouler(10000);

Constructeurs

Un constructeur est une méthode particulière portant le même nom que la classe, automatiquement appelée lors de la création d’une instance. Il ne retourne aucune valeur et peut avoir plusieurs paramètres. Il sert à initialiser les données membres et à effectuer des actions lors de l’instanciation.

Exemples de constructeurs

Constructeur simple :

public class Voiture {
  private String NImm;
  private String Marque;
  private String Couleur;
  private int km;

  Voiture() { }
}

Constructeur avec initialisation fixe :

Voiture() {
  NImm = "1234TU195";
  Marque = "Fiat";
  Couleur = "Rouge";
  km = 95000;
}

Constructeur avec initialisation variable :

Voiture(String n, String m, String c, int k) {
  NImm = n;
  Marque = m;
  Couleur = c;
  km = k;
}

Exemple complet de classe Voiture avec méthode

public class Voiture {
  private String NImm;
  private String Marque;
  private String Couleur;
  private int km;

  public Voiture(String n, int k) {
    NImm = n;
    km = k;
  }

  public void rouler(int k) { // k : km additionnel
    km = km + k;
  }
}

Instantiation et appel de méthode

Pour créer un objet, on appelle le constructeur avec l’opérateur new. L’opérateur réserve l’espace mémoire nécessaire.

Exemple :

public static void main(String[] args) {
  Voiture voit = new Voiture("1234TU195", 90000);
  voit.rouler(10000);
}

Accesseurs (Getters et Setters)

Pour respecter l’encapsulation, les attributs sont généralement déclarés private. Pour accéder ou modifier ces attributs, on définit des méthodes appelées getters (pour lire) et setters (pour écrire).

Convention de nommage :

• Getter : commence par get suivi du nom de l’attribut avec une majuscule.
• Setter : commence par set suivi du nom de l’attribut.

Exemple :

public String getNom() {
  return Nom;
}

public void setCIN(int i) {
  CIN = i;
}

Surcharge de Méthodes

La surcharge permet d’utiliser plusieurs méthodes portant le même nom mais avec des signatures différentes (types ou nombre de paramètres) dans une même classe.

Exemple :

public class Voiture {
  private String NImm, Marque, Couleur;
  private int km;

  public Voiture(String n, int k) {
    NImm = n;
    km = k;
  }

  public void rouler(int k) {
    km = km + k;
  }

  public int rouler(int k) {
    rouler(k);
    return km;
  }
}

Surcharge de constructeurs

public class Voiture {
  private String NImm;
  private String Marque;
  private String Couleur;
  private int km;

  Voiture() { }

  Voiture(String n) {
    NImm = n;
  }

  Voiture(String n, String m, String c, int k) {
    NImm = n;
    Marque = m;
    Couleur = c;
    km = k;
  }
}

Mot-clé this

Le mot-clé this fait référence à l’instance courante de l’objet dans une méthode. Il est utile lorsque les noms des paramètres ou variables locales sont identiques aux noms des attributs.

Exemple :

public class Voiture {
  private String NImm;
  private int km;

  public Voiture(String NImm, int km) {
    this.NImm = NImm;
    this.km = km;
  }
}

Opérateur instanceof

L’opérateur instanceof teste si un objet est une instance d’une classe donnée. Il retourne true si c’est le cas, sinon false. Il est souvent utilisé dans une condition if.

Exemple :

Voiture voit = new Voiture("1234TU195", 90000);
if (voit instanceof Voiture) {
  System.out.println("C’est une voiture");
} else {
  System.out.println("Ce n’est pas une voiture");
}

Packages

Java permet de regrouper les classes en ensembles appelés packages pour faciliter la modularité. Chaque package porte un nom, simple ou composé (identificateurs séparés par des points). L’instruction package doit être la première ligne du fichier source.

Exemple :

package nomtest;

public class Exemple {
  // code
}

Si l’instruction package est absente, la classe appartient au package par défaut.

Pour utiliser une classe d’un autre package, on peut :

• Utiliser le chemin complet : NomPackage.UneAutreClasse obj = new NomPackage.UneAutreClasse();
• Importer la classe : import NomPackage.UneAutreClasse;
• Importer tout le package : import NomPackage.*;

Exemples de packages standards :

• java.applet
• java.awt
• java.io
• java.lang
• java.math
• java.net
• java.rmi
• java.security
• java.sql
• java.util
• javax.swing
• java.text

Associations entre Classes

Une relation d’association spécifie qu’un objet est sémantiquement connecté à un autre objet indépendant. Cette relation peut être représentée par :

• Une classe intermédiaire (exemple : Emploi) avec des attributs dans les classes associées.
• Deux attributs dans chaque classe, attention à la gestion de la relation inverse.
• Un seul attribut dans une des classes, ce qui simplifie la gestion mais limite la navigabilité.

Exemple :

• Classe Personne : employeur : Compagnie
• Classe Compagnie : employés : collection de Personnes

Encapsulation

L’encapsulation est le principe de regrouper les données et le code qui les manipule dans une même unité (classe). Elle protège les données des interférences extérieures en forçant l’utilisation des méthodes pour accéder ou modifier les données.

Elle consiste à ce qu’un objet renferme ses propres attributs et méthodes, masquant les détails d’implémentation aux autres objets du système. L’encapsulation empêche que certaines propriétés soient manipulées directement depuis l’extérieur de la classe.

Glossaire des Termes Clés

• Classe : Type complexe regroupant données (attributs) et comportements (méthodes), servant de modèle pour créer des objets.
• Objet : Instance d’une classe, possédant une identité, un état (valeurs des attributs) et un comportement (méthodes).
• Attribut : Variable membre d’une classe représentant une caractéristique ou un état d’un objet.
• Méthode : Fonction ou procédure définie dans une classe, décrivant un comportement.
• Constructeur : Méthode spéciale pour initialiser un objet lors de sa création.
• Encapsulation : Principe de protection des données en regroupant attributs et méthodes dans une classe et en limitant l’accès direct aux données.
• Portée (Visibilité) : Zone du programme où un identificateur est accessible, définie par les modificateurs private, protected, public.
• static : Mot-clé indiquant que l’attribut ou la méthode appartient à la classe et non à ses instances.
• final : Mot-clé indiquant qu’une variable est constante ou qu’une méthode/classe ne peut être redéfinie.
• this : Référence à l’instance courante d’un objet dans une méthode.
• instanceof : Opérateur testant si un objet est une instance d’une classe donnée.
• Package : Regroupement de classes facilitant la modularité et l’organisation du code.
• Surcharge : Possibilité d’avoir plusieurs méthodes avec le même nom mais des signatures différentes dans une même classe.
• Getter : Méthode permettant d’accéder à la valeur d’un attribut privé.
• Setter : Méthode permettant de modifier la valeur d’un attribut privé.

Points Clés à Retenir

• Une classe définit la structure et le comportement des objets qu’elle génère.
• Les objets sont des instances de classes, avec identité, état et comportement.
• L’encapsulation protège les données en limitant leur accès direct et en imposant l’utilisation de méthodes.
• Les constructeurs permettent d’initialiser les objets lors de leur création.
• Les méthodes static appartiennent à la classe et non aux instances.
• La surcharge permet d’utiliser un même nom de méthode avec différentes signatures.
• Le mot-clé this référence l’objet courant et évite les ambiguïtés.
• L’opérateur instanceof permet de vérifier le type d’un objet.
• Les packages organisent les classes en modules pour une meilleure gestion du code.