• 20 heures
  • Moyenne

Ce cours est visible gratuitement en ligne.

Ce cours est en vidéo.

Vous pouvez obtenir un certificat de réussite à l'issue de ce cours.

J'ai tout compris !

Mis à jour le 12/10/2018

Concevez visuellement votre programme

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

Dans le cours sur les bases de Java, vous avez eu l'occasion de découvrir différentes notions liées aux variables de type objet :

  • les classes ;

  • les méthodes ;

  • les attributs.

Volontairement, j'ai laissé quelques imprécisions autour de ces concepts. Dans ce cours, nous allons revoir ces notions en profondeur.

Un objet, c'est quoi ?

Quand on parle d'objet, il faut le voir comme un objet du quotidien. Chaque objet qui nous entoure a des fonctionnalités et des caractéristiques.

Si vous prenez un four, par exemple, il possède avant tout une fonctionnalité : faire cuire des aliments.

Pour mener à bien cette fonctionnalité, il possède des caractéristiques  :

  • Puissance : quantité en watts,

  • Capacité :  quantité en litres.

Avec une représentation UML, comme vu dans le premier cours, on peut représenter ce four de cette manière :

UML d'un Four
UML d'un Four

On a, dans l'ordre :

  • Four : le nom du type de l'objet → la classe ;

  • puissance et capacite : les caractéristiques de l'objet  → les attributs ;

  • cuire : les fonctionnalités de l'objet → les méthodes.

Dans le code, vous le savez maintenant, cela correspondrait à un fichier nommé  Four  contenant une classe nommée elle aussi  Four  :

package com.cursan.miam;

public class Four {
    int puissance;
    int capacite;

    public void cuire() {
        System.out.println("Je cuis un aliment");
        System.out.println("avec ma capacité de " + capacite + " litres");
        System.out.println("et ma puissance de " + puissance + " degrés.");
    }
}

Cette classe n'est pas un four, mais la description d'un four. C'est lorsque l'on va créer une variable de type  Four  que l'on va réellement créer un four.

package com.cursan.miam;

public class Main {

    public static void main(String[] args) {
        Four petitFour = new Four();
        petitFour.capacite = 30;
        petitFour.puissance = 180;
        
        Four grandFour = new Four();
        grandFour.capacite = 55;
        grandFour.puissance = 260;

        petitFour.cuire();
        System.out.println("");
        grandFour.cuire();
    }
}

Dans ce code, j'ai créé 2 fours, un petit et un grand. Si je lance mon programme, le résultat suivant s'affiche :

Je cuis un aliment
avec ma capacité de 30 litres
et ma puissance de 180 degrés.

Je cuis un aliment
avec ma capacité de 55 litres
et ma puissance de 260 degrés.

Process finished with exit code 0

Notre four sert à faire cuire quoi ? Des aliments bien sûr ! Nous allons procéder de la même façon que pour notre  Four .

Quelles sont les fonctionnalités d'un  Aliment  ? On peut le manger ! 

De quelles caractéristiques a besoin un aliment pour qu'on puisse le manger ? Pour faire simple, nous allons dire : son nom et s'il est cuit ou cru.

Voici son UML :

UML d'un Aliment
UML d'un Aliment

Et voici son code :

package com.cursan.miam;

public class Aliment {
    String nom;
    boolean estCuit;

    public void manger() {
        if (estCuit) {
            System.out.println("Miam miam cet aliment : " + nom + " est bien cuit");
        } else {
            System.out.println("Beeerk cet aliment : " + nom + " est cru !");
        }
    }
}

 On va modifier  Four.cuire  pour faire interagir nos 2 classes  Four  et  Aliment  entre elles :

public void cuire(Aliment aliment) {
    System.out.println("Je cuis un aliment : " + aliment.nom);
    System.out.println("avec ma capacité de " + capacite + " litres");
    System.out.println("et ma puissance de " + puissance + " degrés.");
    aliment.estCuit = true;
}

Logique, non ? On prend simplement l'aliment en paramètre, on affiche qu'on est en train de le cuire et on le met à l'état cuit !

Amusons-nous avec cela dans le  main  :

public static void main(String[] args) {
    Four grandFour = new Four();
    grandFour.capacite = 55;
    grandFour.puissance = 260;

    Aliment cake = new Aliment();
    cake.nom = "cake aux fruits";
    cake.estCuit = false;
    cake.manger();
    System.out.println("");
    grandFour.cuire(cake);
    System.out.println("");
    cake.manger();
}

À votre avis, quel va être le résultat ?

Beeerk cet aliment : cake aux fruits est cru !

Je cuis un aliment : cake aux fruits
avec ma capacité de 55 litres
et ma puissance de 260 degrés.

Miam miam cet aliment : cake aux fruits est bien cuit

Process finished with exit code 0

Surpris ? J'espère que non :soleil: ! Le processus que l'on vient de voir ici est celui qu'il faut toujours utiliser dans la programmation orientée objet.

Il faut toujours réfléchir à :

  • Quel objet je souhaite représenter ?

  • Quelles fonctionnalités possède cet objet ?

  • De quelles caractéristiques a besoin cet objet pour assurer ses fonctionnalités ?

On va utiliser cette méthode pour concevoir notre projet.

Utilisez un UML complet

Le but de ce cours n'est pas de vous donner la démarche pour concevoir de A à Z un diagramme de classe UML. Le but est que vous compreniez cette façon de schématiser. Avec l'experience, vous serez capable un jour d'élaborer des diagrammes très complexes.

Nous allons ici élaborer une première version de notre schéma UML et celui-ci va évoluer au fur et à mesure des chapitres.

Notre projet est une application de gestion de facture dans un magasin en ligne.

La base de notre projet, c'est la facture. De quoi est composée une facture ?

  • de produits ;

  • d'un client.

Commençons par représenter ces 2 concepts :

Le produit

UML d'un produit
UML d'un produit

Pour pouvoir regarder ou acheter un produit, nous avons besoin de son nom, de sa description et de son prix.

Le Client

UML d'un client
UML d'un client

En nous limitant au strict minimum, pour pouvoir vendre à un client en ligne, il nous faut son nom complet et son adresse.

La facture

UML d'une facture
UML d'une facture

Vous comprenez facilement à quoi servent les flèches →, non ? Une facture est composée de produits et d'un client. On représente cela avec deux flèches. 

Dans le prochain chapitre, on attaque le code ! On va implémenter cet UML.

Exemple de certificat de réussite
Exemple de certificat de réussite