En programation orientée objet, tout est considéré comme un objet. Un objet se compose de deux éléments fondamentaux : les attributs (caractéristiques descriptives) et les comportements (actions ou méthodes). Les relations entre objets s'expriment principalement par trois types d'interactions : l'héritage, l'association et la dépendance. Classes

Une classe représente une abstraction d'objets similaires. Elle agit également comme un modèle pour créer des instances d'objets, tandis qu'un objet est une concrétisation spécifique d'une classe. Les trois caractéristiques fondamentales de la programmation orientée objet sont : l'encapsulation, l'héritage et le polymorphisme. La syntaxe de base d'une classe en Java est : ``` class NomClasse { modificateurAcces typeAttribut nomAttribut; modificateurAcces typeRetour nomMethode(parametres) { // corps de la méthode } }

Modificateurs d'Accès
---------------------

1. `private` : Privé. Uniquement accessible depuis l'intérieur de la classe. 2. `public` : Public. Accessible depuis n'importe où dans le programme. 3. Par défaut (aucun modificateur) : Accessible dans le package courant. Méthodes d'Accesseurs (Getters) et de Mutateurs (Setters)
---------------------------------------------------------

- Les getters permettent de récupérer la valeur d'un attribut privé. - Les setters permettent de modifier la valeur d'un attribut privé. Instanciation de Classes
------------------------

La création d'un objet à partir d'une classe s'appelle l'instanciation : ```
NomClasse nomReference = new NomClasse();

Constructeurs

Un constructeur présente les caractéristiques suivantes : 1. Il porte le même nom que la classe. 2. Il ne possède pas de type de retour explicite. 3. Il est exécuté automatiquement lors de la création d'un objet. 4. Il est généralemetn déclaré public. 5. L'initialisation des attributs est effectuée avant l'exécution des méthodes. 6. Si non défini, le compilateur fournit un constructeur par défaut. Exemple de Classe

public class Chien {
    // Attributs privés
    private String nom = "Médor";
    private String proprietaire;
    
    // Constructeur
    public Chien() {
        this.nom = "Inconnu";
    }
    
    // Méthode d'accesseur pour le nom
    public String getNom() {
        return nom;
    }
    
    // Méthode mutateur pour le nom
    public void setNom(String nouveauNom) {
        if(!nouveauNom.equals(this.proprietaire)) {
            this.nom = nouveauNom;
        }
    }
    
    // Méthode de comportement
    public void aboyer() {
        System.out.println(nom + " : Ouaf! Ouaf! Ouaf!");
    }
    
    // Autre méthode de comportement
    public void manger(String nourriture) {
        System.out.println(nom + " mange " + nourriture);
    }
}

Utilisation de la Classe

public class ExempleUtilisation {

    public static void main(String[] args) {
        Chien premierChien = new Chien();
        premierChien.setNom("Buddy");
        System.out.println("Le nom du chien est : " + premierChien.getNom());
        premierChien.aboyer();
        
        Chien deuxiemeChien = new Chien();
        deuxiemeChien.setNom("Max");
        deuxiemeChien.manger("des croquettes");
    }
}

Surcharge de Méthodes

La surcharge de méthodes se produit lorsque plusieurs méthodes partagent le même nom mais diffèrent par leurs paramètres (nombre ou type). Le type de retour n'influence pas la surcharge, seule la signature (nom et paramètres) est déterminante. Lors de l'appel, la méthode appropriée est sélectionnée automatiquement en fonction des arguments fournis. Toutes les méthodes, y compris les constructeurs, peuvent être surchargées. Exemple de surcharge : ``` public class Calculatrice { public int additionner(int a, int b) { return a + b; }

public double additionner(double a, double b) {
    return a + b;
}

public int additionner(int a, int b, int c) {
    return a + b + c;
}

}

</div>