Cours Complet POO en Java : Polymorphisme, Interfaces, Classes Abstraites et Concepts Fondamentaux

🔷 Programmation Orientée Objet (Java)

7 concepts fondamentaux · exemples & détails

🔷 1️⃣

Classe & Objet

✅ Définition

Classe : modèle (template) qui définit des attributs et méthodes.
Objet : instance d’une classe créée avec new.

🔑 Mots‑clés

classnewattributméthodeinstance

💻 Code

class Personne {
    String nom;
    int age;

    void afficher() {
        System.out.println("Nom: " + nom + ", Age: " + age);
    }
}

public class Main {
    public static void main(String[] args) {
        Personne p1 = new Personne();
        p1.nom = "Ali";
        p1.age = 22;
        p1.afficher();
    }
}

🔷 2️⃣

Constructeur

✅ Définition

Méthode spéciale : même nom que la classe, pas de type retour, sert à initialiser les objets.

🔑 Mots‑clés

constructeurinitialisationthis

💻 Code

class Personne {
    String nom;
    int age;

    Personne(String nom, int age) {
        this.nom = nom;
        this.age = age;
    }

    void afficher() {
        System.out.println("Nom: " + nom + ", Age: " + age);
    }
}

public class Main {
    public static void main(String[] args) {
        Personne p1 = new Personne("Sara", 25);
        p1.afficher();
    }
}

🔷 3️⃣

Encapsulation

✅ Définition

Rendre les attributs private, utiliser des getters/setters pour protéger les données.

🔑 Mots‑clés

privatepublicgettersetterprotection

💻 Code

class Compte {
    private double solde;

    public void setSolde(double solde) {
        if (solde >= 0) this.solde = solde;
    }

    public double getSolde() {
        return solde;
    }
}

public class Main {
    public static void main(String[] args) {
        Compte c = new Compte();
        c.setSolde(1000);
        System.out.println("Solde: " + c.getSolde());
    }
}

🔷 4️⃣

Héritage

✅ Définition

Une classe enfant hérite des attributs et méthodes de la classe parent. Réutilisation.

🔑 Mots‑clés

extendssuper-classesous-classeréutilisation

💻 Code

class Animal {
    void parler() {
        System.out.println("L'animal fait un bruit");
    }
}

class Chien extends Animal {
    void aboyer() {
        System.out.println("Le chien aboie");
    }
}

public class Main {
    public static void main(String[] args) {
        Chien c = new Chien();
        c.parler();
        c.aboyer();
    }
}

🔷 5️⃣

Polymorphisme

✅ Définition

Une même méthode peut avoir plusieurs comportements selon l’objet. Redéfinition (override).

🔑 Mots‑clés

@Overrideredéfinitionsuper-classedynamique

💻 Code

class Animal {
    void parler() {
        System.out.println("L'animal fait un bruit");
    }
}

class Chat extends Animal {
    @Override
    void parler() {
        System.out.println("Le chat miaule");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal a = new Chat();
        a.parler(); // polymorphisme
    }
}

🔷 6️⃣

Classe Abstraite

✅ Définition

Classe non instanciable qui peut contenir des méthodes abstraites. Modèle incomplet.

🔑 Mots‑clés

abstractméthode abstraiteimplémentation

💻 Code

abstract class Forme {
    abstract double calculerAire();
}

class Rectangle extends Forme {
    double largeur, hauteur;
    Rectangle(double l, double h) { largeur=l; hauteur=h; }
    @Override double calculerAire() { return largeur*hauteur; }
}

public class Main {
    public static void main(String[] args) {
        Forme f = new Rectangle(4,5);
        System.out.println("Aire: " + f.calculerAire());
    }
}

🔷 7️⃣

Interface

✅ Définition

Contrat : méthodes abstraites (par défaut). Une classe implements. Abstraction totale.

🔑 Mots‑clés

interfaceimplementscontratabstraction totale

💻 Code

interface Paiement {
    void payer(double montant);
}

class CarteBancaire implements Paiement {
    @Override
    public void payer(double montant) {
        System.out.println("Paiement par carte: " + montant);
    }
}

public class Main {
    public static void main(String[] args) {
        Paiement p = new CarteBancaire();
        p.payer(500);
    }
}

📌 Résumé Global de la POO

Concept	Objectif	Mot-clé principal
Classe	Définir un modèle	class
Objet	Instance de classe	new
Encapsulation	Protéger les données	private
Héritage	Réutiliser du code	extends
Polymorphisme	Plusieurs comportements	@Override
Abstraite	Modèle incomplet	abstract
Interface	Contrat	implements

🎯 Conclusion : les 4 piliers

Abstraction Encapsulation Héritage Polymorphisme

Ces piliers permettent :

✔ Organisation ✔ Réutilisation ✔ Sécurité ✔ Modularité ✔ Maintenance facile

📋 QCM – Testez vos connaissances (POO)

20 questions · Choisissez une réponse et cliquez sur Vérifier

1 Qu'est-ce qu'une classe en POO ?

Un objet en mémoire

Un modèle ou plan pour créer des objets

Une méthode spéciale

Un type primitif

2 Quel mot-clé utilise-t-on pour créer une instance de classe en Java ?

class

this

new

static

3 Quel est le rôle principal d'un constructeur ?

Détruire un objet

Initialiser un objet

Définir une constante

Hériter des méthodes

4 L'encapsulation consiste à :

Rendre tous les attributs publics

Protéger les données en les rendant privées et en fournissant des getters/setters

Utiliser l'héritage multiple

Définir des méthodes abstraites

5 Quel mot-clé permet l'héritage en Java ?

implements

inherit

extends

super

6 Le polymorphisme permet :

De cacher des données

D'avoir plusieurs méthodes avec le même nom mais des comportements différents

D'interdire l'héritage

De créer une classe sans attributs

7 Quelle annotation indique une redéfinition de méthode ?

@Override

@Inherit

@Polymorph

@Redefine

8 Une classe abstraite peut être instanciée ?

Oui, comme une classe normale

Non, jamais

Seulement si elle a des méthodes concrètes

Oui, mais sans constructeur

9 Que doit faire une classe qui implémente une interface ?

Fournir une implémentation pour toutes les méthodes abstraites de l'interface

Déclarer les mêmes attributs

Être déclarée abstract

Utiliser le mot-clé extends

10 À quoi sert le mot-clé 'this' en Java ?

À faire référence à l'objet courant

À appeler le constructeur parent

À déclarer une constante

À importer une classe

11 En Java, une classe peut-elle hériter de plusieurs classes ?

Oui, grâce au mot-clé extends multiple

Non, l'héritage multiple de classes est interdit

Oui, si elles sont abstraites

Oui, avec le mot-clé implements

12 Quel est un avantage clé de l'encapsulation ?

Augmenter la vitesse d'exécution

Contrôler l'accès aux données et protéger l'intégrité

Rendre le code plus long

Permettre l'héritage multiple

13 Une méthode abstraite doit obligatoirement être dans :

Une interface seulement

Une classe abstraite ou une interface

Une classe concrète

Une classe finale

14 Quelle est la principale différence entre une classe abstraite et une interface (Java 8+) ?

Une interface ne peut pas avoir de méthodes concrètes (sauf static/default)

Une classe abstraite ne peut pas avoir d'attributs

Une interface peut être instanciée

Une classe abstraite permet l'héritage multiple

15 Que signifie @Override ?

On surcharge une méthode (même classe)

On redéfinit une méthode héritée

On appelle le constructeur parent

On déclare une méthode abstraite

16 Quel mot-clé rend un attribut accessible uniquement dans la classe elle-même ?

public

protected

private

static

17 Le polymorphisme permet de :

Choisir la méthode à exécuter à l'exécution selon le type réel de l'objet

Masquer les attributs privés

Définir plusieurs classes dans un fichier

Interdire la redéfinition

18 Une classe fille peut-elle accéder directement aux membres privés (private) de son parent ?

Oui, toujours

Non, sauf via des getters/setters publics ou protégés

Oui, en utilisant super

Seulement si la classe est dans le même package

19 Qu'est-ce qu'une interface fonctionnelle ?

Une interface avec une seule méthode abstraite

Une interface sans méthode

Une interface qui ne peut être implémentée

Une interface avec des méthodes par défaut

20 Quel principe de la POO permet de regrouper données et méthodes au sein d'une même entité ?

Encapsulation

Abstraction

Héritage

Polymorphisme

---

⚡ code prêt à être copié · clarté & détails · Blogger friendly