Java: Classes et Objets

Chapitre 3 : Les Classes et Objets en Java

• Ce chapitre traite des classes et des objets en Java, des concepts clés de la programmation orientée objet.

Concepts des Langages Objet

• Un objet est une entité qui contient des données (état) et des fonctions associées (comportement).
• Les objets possèdent une identité unique et invariable.
• Pour interagir avec un objet, on lui envoie des messages qui déclenchent l'exécution de méthodes.
• Une méthode peut envoyer des messages à d'autres objets.
• Un système est constitué d'objets qui communiquent entre eux.
• Une classe est un moule pour fabriquer des objets de même structure et de même comportement.
• Un objet est une instance d'une classe.
• Une classe C définit un type C.
• Une variable de type C peut faire référence à un objet de la classe C.

Déclaration d'une Classe en Java

• Exemple de déclaration d'une classe Rectangle en Java, avec des variables d'instance (largeur, hauteur), un constructeur, et des méthodes (périmètre, surface, retaille).

class Rectangle {
    int largeur, hauteur;
    Rectangle(int initialL, int initialH) {
        largeur = initialL;
        hauteur = initialH;
    }
    int perimetre() {
        return 2 * (largeur+hauteur);
    }
    int surface() {
        return largeur*hauteur;
    }
    void retaille(double facteur) {
        largeur=(int)(largeur*facteur);
        hauteur=(int)(hauteur*facteur);
    }
}

Utilisation d'une Classe Java

• Déclaration de variables de type Rectangle : Rectangle r1, r2;
• Création d'objets (instantiation) : r1 = new Rectangle(50, 100);
• Envoi de messages (utilisation) : r2.retaille(1.25);. System.out.println(r2.perimetre() );
• Les variables rl et r2 contiennent l'adresse des zones mémoire allouées par l'opérateur new pour stocker les informations relatives à ces objets et ce sont des références.
• La référence d'un objet est utilisée pour accéder aux données et fonctions membres (méthodes) de l'objet.
• Un objet peut accéder à sa propre référence grâce à la valeur this (variable en lecture seule).
• Une référence contenant la valeur null ne désigne aucun objet.
• Un objet qui n'est plus utilisé est automatiquement détruit et la mémoire est récupérée par le garbage collector.

Concepts de Base de la Programmation Orientée Objet

• Le concept de base de la programmation orientée objet est la classe.
• Une classe modélise la structure statique (données) et le comportement dynamique (méthodes) des objets associés à cette classe.
• Un objet d'une classe est appelé une instance.
• Une classe est la description d'un objet, et chaque objet est créé à partir d'une classe avec l'opérateur new.

Constructeur de Classe

• Un constructeur est une méthode appelée au moment de la création de l'objet.
• Il est utile pour procéder à toutes les initialisations nécessaires lors de la création de la classe.
• Toute classe possède un constructeur par défaut, implicite, qui peut être redéfini.
• Le constructeur porte le même nom que le nom de la classe et n'a pas de valeur de retour.
• Une classe peut avoir plusieurs constructeurs qui diffèrent par le nombre et la nature de leurs paramètres (surcharge des constructeurs).
• Exemples de constructeurs:

class Compte {
    private int numero;
    private float solde;

    public Compte(int num, float s) {
        numero = num;
        solde = s;
    }
}

class Rectangle {
    private int largeur, hauteur;

    public Rectangle(int L, int H) {
        largeur = L;
        hauteur = H;
    }
}

Destructeur de Classe

• Un destructeur peut être appelé lorsqu'un objet est détruit.
• Il doit être utilisé pour libérer les ressources qui ne peuvent être récupérées par le garbage collector.
• En Java, le destructeur est une méthode appelée finalize().

Déclaration d'une Classe

• La syntaxe générale de déclaration d'une classe est la suivante : modificateurs class nom_classe [extends classe_mere] [implements Interface] { // corps de la classe }
• Les modificateurs de classe (ClassModifiers) sont : abstract, final, private, et public.
  • abstract: La classe contient des méthodes abstraites, ne peut pas être instanciée directement.
  • final: La classe ne peut pas être modifiée ou héritée.
  • private: La classe n'est accessible qu'à partir du fichier où elle est définie.
  • public: La classe est accessible partout.
• Les modificateurs abstract et final, ainsi que public et private, sont mutuellement exclusifs.
• Le mot-clé extends permet de spécifier une superclasse (classe mère) dans une relation d'héritage.
• Le mot-clé implements permet de spécifier une ou des interfaces que la classe implémente.

Objet : Durée de Vie et Identité

• La durée de vie d'un objet ne correspond pas forcément à la durée d'exécution du programme.
• La durée de vie d'un objet passe par trois étapes : déclaration et instanciation, utilisation, et suppression.
• Exemple d'instanciation : nom_classe nom_objet = new nom_classe(...);
• La suppression d'un objet est automatique en Java, gérée par le garbage collector.
• Il y a deux façons de créer des objets identiques:
  • Copie de surface : Les deux objets contiennent la même référence et pointent vers le même emplacement mémoire.
  • Copie profonde: on utilise la methode clone() qui créé un deuxième objet indépendant.
• Les variables de type objet ne contiennent pas l'objet lui-même, mais une référence vers cet objet.
• L'opérateur == compare les références, pas le contenu des objets.
• Pour comparer le contenu de deux objets, il faut utiliser la méthode equals.
• Pour comparer deux objets, on doit utiliser la méthode getClass() pour s'assurer qu'ils proviennent de la même classe.

L'Objet Null

• L'objet null est utilisable partout.
• Il n'appartient à aucune classe mais peut être utilisé à la place d'un objet de n'importe quelle classe ou comme paramètre.
• Il ne peut pas être utilisé comme un objet normal (pas d'appel de méthodes).
• Initialiser une variable avec null permet au ramasse miette de libérer la mémoire allouée à l'objet.

La Variable This

• La variable this sert à référencer l'instance de l'objet en cours d'utilisation à l'intérieur d'une méthode.
• Exemple:

private int nombre;
public maclasse(int nombre) {
  this.nombre = nombre;
}

Les Données

• Une classe est un ensemble de données et de fonctions regroupées.
• Elle comporte une déclaration, des variables (données) et la définition de ses méthodes et se compose d'un entête et un corps.
• Le corps peut être divisé en 2 sections: la déclaration des données et des constantes et la définition des méthodes.
• Les données d'une classe sont contenues dans des variables appelées propriétés/attributs, qui peuvent être des variables d'instance, de classe ou des constantes.
• Les attributs de visibilité (public, private, protected) gèrent l'accessibilité des données par les composants hors de la classe.

Les Variables d'Instances

• Exemple :

public class MaClasse {
           public int valeurl;
           int valeur2;
           protected int valeur3;
           private int valeur4 ;
}

Les Variables de Classe

• Les variables de classe sont définies avec le mot clé static.
• Une instance de la classe partage la même variable de classe.
• Exemple :

public class MaClasse {
    static int compteur;
}    

Les Constantes

• Les constantes sont définies avec le mot clé final.
• Leur valeur ne peut pas être modifiée une fois qu'elles sont initialisées.
• Exemple :

public class MaClasse {
    final double pi=3.14;
}

Les Modificateurs d'Accès

• Ils se placent avant ou après le type de l'objet.
• Ils ne peuvent pas être utilisés pour qualifier des variables locales.
• Ils assurent le contrôle des conditions d'héritage et de l'accès aux éléments.
• Résumé des modificateurs d'accès :
  • public : Visible par tous les autres objets.
  • (par défaut) : Visible par toutes les classes dans le même package.
  • protected : Visible par les méthodes dans le même package et dans les sous-classes.
  • private : Visible uniquement à l'intérieur de la classe.

La Méthode Main()

• La méthode main est la première méthode exécutée lors du lancement d'une application Java.
• Elle est déclarée de la façon suivante : public static void main (String args[]) { ... }
• Une application Java peut recevoir des arguments passés en ligne de commande, accessibles via le tableau de String args[].
• La longueur du tableau args.length permet de connaître le nombre d'arguments.
• Si la déclaration de la méthode Main() diffère, une exception sera levée.

Les Méthodes

• Les méthodes sont les fonctions en Java.
• Une méthode est caractérisée par une déclaration et un corps.
• Syntaxe : modificateurs type_retourné nom_méthode (arg1, ...) { ... }
• Les modificateurs de méthodes sont : private, public, protected, final, static et synchronized.
  • public: La méthode est accessible depuis d'autres classes.
  • private: L'accès à la méthode est limité à la classe elle-même.
  • protected: Semblable à private, mais accessible aussi aux sous-classes (héritage).
  • final: La méthode ne peut pas être surchargée ou redéfinie dans les classes dérivées.
  • static: La méthode appartient à la classe plutôt qu'à une instance spécifique.
  • synchronized: Utilisée pour contrôler l'accès concurrentiel à la méthode.
• Les arguments sont passés par valeur (une copie est faite):
  • si c'est un type primitive, on travaille avec une copie donc impossible de modifier l'original
  • si c'est un objet, on peut modifier l'objet passé en paramètre

La Surcharge de Méthodes

• Elle permet de définir plusieurs méthodes avec le même nom mais avec des signatures différentes (différents types ou nombres de paramètres).
• Le compilateur choisit la bonne méthode en fonction des arguments utilisés lors de l'appel.
• La signature d'une méthode comprend le nom de la classe, le nom de la méthode, et les types de ses paramètres.
• Exemple:

class affiche {
    public void afficheValeur(int i) {
        System.out.println(" nombre entier = " + i);
    }
    public void afficheValeur(float f) {
        System.out.println(" nombre flottant = " + f);
    }
}

Le Type Retourné

• Il peut être élémentaire ou un objet.
• Si la méthode ne retourne rien, on utilise void.
• La valeur de retour est transmise par l'instruction return