UNIVERSITE PROTESTANT UNIVERSITY

PROTESTANTE D’AFRIQUE OF CENTRAL AFRICA

CENTRALE (PUCA)
(UPAC)

ORIENTÉ OBJET :
JAVA
Proposé par Ing. Fabrice Pegoffa
 PROGRAMME
• Partie 0 : Programmation Orienter Objet
• Vue D’ensemble
• Différents types de méthodes
• Visibilité

• Partie 1 : Java 2 Standard Edition (J2SE)

• Préparation de l’environnement
• Les Bases du langage (variable, boucle, opérateur, etc.)
• Package, Héritage et Exception
• Classes Abstraites et Interfaces
• Flux D’entrée Sortie
• Communication avec une Base de Données
 PROGRAMME
• Partie 2 : Interfaces graphiques
• Swing et AWT
• Widgets Swing
• Layout (Gestionnaire de positionnement)
• Les évènements
 LA PROGRAMMATION
PROCÉDURALE
• La programmation procédurale est un paradigme basé sur le concept
d'appel procédural.
• Une procédure, aussi appelée routine, sous-routine ou fonction contient
simplement une série d'étapes à réaliser.
• La programmation procédurale est un meilleur choix qu'une simple
programmation séquentielle. Les avantages sont en effet les suivants :
• la possibilité de réutiliser le même code à différents emplacements dans le
programme sans avoir à le retaper (factorisation), ce qui a pour effet la
réduction de la taille du code source
• une façon plus simple de suivre l'exécution du programme : la
programmation procédurale permet de se passer d'instructions telles que
GOTO et JUMP évitant ainsi bien souvent de se retrouver avec un
programme compliqué qui part dans toutes les directions
 LA PROGRAMMATION
PROCÉDURALE (LIMITES)
• Dans les années 80, la méthodologie de programmation logicielle
consistait essentiellement en l’abstraction procédurale
• Principaux problèmes
• Réutilisation limitée
• Critères de qualité facilement violés : modularité, lisibilité, …
• Danger du « Code spaghetti »
• Difficulté de la maintenance de grandes applications
• Le concept central de la programmation orientée-objets est
l’objet : celui-ci contient ses propres données ainsi que les
traitements relatifs à ses données (encapsulation)
 UN PEU D’HISTOIRE

• La programmation orientée objet (POO), ou programmation

par objet, est un paradigme de programmation informatique
élaboré par les Norvégiens Ole-Johan Dahl et Kristen Nygaard
au début des années 1960 et poursuivi par les travaux d'Alan
Kay dans les années 1970. Il consiste en la définition et
l'interaction de briques logicielles appelées objets ; un objet
représente un concept, une idée ou toute entité du monde
physique, comme une voiture, une personne ou encore une
page d'un livre.
LA PROGRAMMATION
ORIENTÉ OBJET
Vue d’ensemble
 LE MODÈLE OBJET

• Le monde est composé d’objet

• Un objet est identifiable individuellement
• Les objets sont en relations avec d’autres objets
• Les objets sont organisés de manière hiérarchique
• Penser en terme d’abstraction conceptuel
• Penser en termes d’entités relativement autonomes
• Penser en termes de cadre (Frameworks) et de composants
réutilisables
 OBJECTIFS DE LA POO

• Faciliter la réutilisation du code

• Faciliter l’évolution et l’extension du code

• Améliorer la conception et la maintenance des grands systèmes

• Permettre la conception d’un système par module

 CLASSE ET OBJET

• La classe représente la déclaration de l'ensemble des attributs

qui composeront un objet (données + méthodes)

• L’objet est l’instance (ou « exemplaire ») d’une classe

• La classe sera appelé type complexe

• Et les variables qui sont déclarées avec ce type seront

appelées objet
 CONCEPTS

• Concepts :
• Concept de modélisation à travers les notions de
classe et d’instanciation
• Concept d’action à traver la notion d’envoi de
messages entre objets
• Concept de construction par la réutilisation et
amélioration par l’utilisation de la notion
d’héritage
 LES PARADIGMES DE LA POO

• 3 paradigmes fondamentaux :
• L‘encapsulation
• L’héritage
• Le Polymorphisme
 L’ENCAPSULATION
• Derrière ce terme se cache le concept même de l'objet : réunir sous la
même entité les données et les moyens de les gérer, à savoir les champs
et les méthodes.
• L'encapsulation introduit donc une nouvelle manière de gérer des
données. Il ne s'agit plus de déclarer des données générales puis un
ensemble de procédures et fonctions destinées à les gérer de manière
séparée, mais bien de réunir le tout sous le couvert d'une seule et même
entité.
 L’HÉRITAGE
• Objectif : construire de nouvelles classes en réutilisant les
attributs et les méthodes de classes existences
• Les attributs peuvent être modifiés au niveau de la sous-
classe
• La sous-classe peut ajouter des attributs à ceux de sa classe
mère; dans ce cas ses attributs sont prioritaires sur les
attributs qu’il hérite.
• Une classe hérite d’une autre si elle répond à la relation « is
a » ou « est un »
• L'héritage successif de classes permet de définir une
hiérarchie de classe qui se compose de super classes et de
sous-classes
L’HÉRITAGE
 L’HÉRITAGE (EXEMPLE)
• Considérons un objet Bâtiment. Cet objet est pour le moins
générique, et sa définition reste assez vague. On peut toutefois lui
associer divers champs, dont par exemple :
• les murs ;
• le toit ;
• une porte ;
• l'adresse ;
• la superficie.
• On peut supposer que cet objet Bâtiment dispose d'un ensemble de
méthodes destinées à sa gestion
• ouvrir le Bâtiment ;
• fermer le Bâtiment ;
• agrandir le Bâtiment.
• Grâce au concept d'héritage, cet objet Bâtiment va pouvoir donner
naissance à un ou des descendants.
 L’HÉRITAGE (EXEMPLE)
• Ainsi, si l'on poursuit notre exemple, nous allons pouvoir
créer un objet Maison. Ce nouvel objet est toujours
considéré comme un Bâtiment
• Toutefois, si notre nouvel objet est toujours un Bâtiment, il
n'en reste pas moins qu'il s'agit d'une Maison. On peut donc
lui adjoindre d'autres champs et méthodes
• nombre de fenêtres ;
• nombre d'étages ;
• nombre de pièces ;
• possède ou non un jardin ;
• possède une cave.
 LE POLYMORPHISME
• Afin de mieux cerner ce paradigme, il suffit d'analyser la structure du
mot : poly comme plusieurs et morphisme (ou Morphe) comme forme
• Il traite ainsi la capacité d’un objet à prendre plusieurs forme
• Cette capacité dérive du principe d'héritage vu précédemment
• Toute fois, il est possible d’utiliser ce paradigme sans pour autant passé
par l’héritage, mais au sein de la même classe
• Ainsi la possibilité à un objet d’avoir plusieurs méthodes de même nom.
• L’objet garde toujours la capacité de redéfinir une méthode afin de la
réécrire, ou de la compléter.
• Le polymorphisme, en d'autres termes, est donc la capacité du système
à choisir dynamiquement la méthode qui correspond au type réel de
l'objet en cours
LA PROGRAMMATION
ORIENTÉ OBJET
Types de Méthodes
 PRINCIPALES MÉTHODES

• Le principal avantage des méthodes est de pouvoir

factoriser le code

• On distingue 5 Types de méthodes :

• Méthode constructeur
• Méthodes destructeurs
• Méthodes Abstraites
• Méthodes d’instance
• Méthodes de Classe
 MÉTHODE CONSTRUCTEUR
• Comme leur nom l'indique, les constructeurs servent à construire l'objet
en mémoire
• Un constructeur va donc se charger de mettre en place les données,
d'associer les méthodes avec les champs et de créer le diagramme
d'héritage de l'objet
• Il peut exister en mémoire plusieurs instances d'un même type objet,
autrement dit plusieurs variables du même type, seule une copie des
méthodes est conservée en mémoire
• Un objet peut ne pas avoir de constructeur explicite. Dans ce cas, c'est le
compilateur qui se charge de créer de manière statique les liens entre
champs et méthodes
• Un objet peut avoir plusieurs constructeurs : c'est l'utilisateur qui
décidera du constructeur à appeler.
• S'il n'est pas nécessaire de fournir un constructeur pour un objet
statique, il devient obligatoire en cas de gestion dynamique
 MÉTHODE DESTRUCTEUR

• Le destructeur est le pendant du constructeur : il se charge de

détruire l'instance de l'objet
• La mémoire allouée pour le diagramme d'héritage est libérée
• Certains compilateurs peuvent également se servir des
destructeurs pour éliminer de la mémoire le code correspondant
aux méthodes d'un type d'objet si plus aucune instance de cet
objet ne réside en mémoire.
• un objet peut ne pas avoir de destructeur. Une fois encore, c'est le
compilateur qui se chargera de la destruction statique de l'objet.
• Un objet peut posséder plusieurs destructeurs. Leur rôle commun
reste identique, mais peut s'y ajouter la destruction de certaines
variables internes pouvant différer d'un destructeur à l'autre
• En cas d'utilisation dynamique, un destructeur s'impose pour
détruire le diagramme créé par le constructeur.
 MÉTHODE ABSTRAITE

• Une méthode abstraite est une méthode qu'il est nécessaire de

surcharger
• Elle ne possède pas d'implémentation
• Ainsi, si on tente d'appeler une méthode abstraite, alors une
erreur est déclenchée.
• il convient lors de la surcharge d'une telle méthode de ne pas
faire appel à la méthode de l'ancêtre
• Les méthodes abstraites sont généralement utilisées lorsque l'on
bâtit un squelette d'objet devant donner lieu à de multiples
descendants devant tous posséder un comportement analogue
 MÉTHODES DE CLASSE ET
D’INSTANCE
• Une méthode statique ou de classe est une méthode qui peut être
appelée même sans avoir instancié la classe
• Une méthode statique ne peut accéder qu'à des attributs et
méthodes statiques.
• L'appel à une méthode statique se fait alors en utilisant le nom de
la classe, plutôt que le nom de l'objet.
• Une méthode d’instance est une méthodes qui est accessible
uniquement à travers un objet de la classe
• Une méthode d’instance peut accéder à des attributs et méthodes
statiques en plus des attributs et méthodes d’instance.
• L’appel d’une méthode d’instance se fait à travers un objet de la
classe
LA PROGRAMMATION
ORIENTÉ OBJET
Visibilité
 GÉNÉRALITÉS
• De par le principe de l'encapsulation, afin de pouvoir
garantir la protection des données, il convient de pouvoir
masquer certaines données et méthodes internes les gérant,
et de pouvoir laisser visibles certaines autres devant servir à
la gestion publique de l'objet. C'est le principe de la
visibilité.

• Ainsi on distingue 3 types de champs et méthodes

• Public

• Privées

• Protégées
 LES CHAMPS ET MÉTHODES
PUBLIQUES
• Comme leur nom l'indique, les champs et méthodes dits publics sont
accessibles depuis tous les descendants et dans tous les modules

• On peut considérer que les éléments publics n'ont pas de restriction

particulière

• Les méthodes publiques sont communément appelées accesseurs :

elles permettent d'accéder aux champs d'ordre privé.

• Il existe des accesseurs en lecture, destinés à récupérer la valeur d'un

champ, et des accesseurs en écriture destinés pour leur part à la
modification d'un champ.
 LES CHAMPS ET MÉTHODES
PRIVÉS
• La visibilité privée restreint la portée d'un champ ou d'une méthode au
module où il ou elle est déclaré(e)

• Ainsi, si un objet est déclaré dans une unité avec un champ privé, alors
ce champ ne pourra être accédé qu'à l'intérieur même de l'unité.

• Il n'est pas nécessaire d'avoir un accesseur par champ privé, car ceux-ci
peuvent n'être utilisés qu'à des fins internes.

• Très souvent, les accesseurs en lecture verront leur nom commencer par
Get quand leurs homologues en écriture verront le leur commencer par
Set.

• Généralement, les accesseurs, autrement dit les méthodes destinées à

modifier les champs, sont déclarés comme publics.
 LES CHAMPS ET MÉTHODES
PROTÉGÉS

• La visibilité protégée correspond à la visibilité privé excepté que tout

champ ou méthode protégé(e) est accessible dans tous les descendants,
quel que soit le module où ils se situent.

• Ainsi il n’est pas possible d’accéder à un champ ou une méthode

protégé si l’objet courant n’hérite de la classe de celui-ci, ou si l’objet
courant n’est pas dans le même package que la classe qui contient cette
propriété
 JAVA
Qu’est ce que c’est?
 POURQUOI JAVA?

• Quelques chiffres et faits à propos de Java en 2011 :

• 97% des machines d'entreprises ont une JVM installée

• Java est téléchargé plus d'un milliards de fois chaque année
• Il y a plus de 9 millions de développeurs Java dans le monde
• Java est un des langages les plus utilisé dans le monde
• Tous les lecteurs de Blu-Ray utilisent Java
• Plus de 3 milliards d'appareils mobiles peuvent mettre en œuvre Java
• Plus de 1,4 milliards de cartes à puce utilisant Java sont produites chaque
année
 LES APPLICATIONS

• Des milliers de terminaux utilisent Java:

• Navigateurs Webs
• Téléphones portables
• Cartes à puces systèmes embarqués
• Ordinateurs de poche (PDA)
• Ordinateurs portables
• Serveurs
FONCTIONNEMENT
• Les logiciels écrits dans ce
langage doivent être très
facilement portables sur
plusieurs systèmes
d’exploitation tels que UNIX,
Windows, Mac OS ou
GNU/Linux, avec peu ou pas
de modifications
COMPILATION
 PROGRAMMER EN JAVA

• J2SE (Java 2 Standard Environment)

• Pour des programmes de bases : application pour ordinateur
personnel, serveurs et autres

• J2EE (Java 2 Entreprise Edition)

• Pour des applications Web
• Alternative au langage de sites web dynamique (tel que PHP)

• J2ME (Java 2 Micro Edition)

• Pour des applications des systèmes embarqués
• Système possédant peu de ressources (mémoire, processeur, etc.)
 JAVA
Préparer son environnement
 PRÉPARATION DE
L’ENVIRONEMENT
• Installation de la JDK
 PRÉPARATION DE
L’ENVIRONEMENT (SUITE)
• Configuration de la variable d’environement
 PRÉPARATION DE
L’ENVIRONEMENT (SUITE)
• Configuration de la variable d’environnement (suite)

1. Désélectionner le texte sélectionner

2. Aller à la fin de ce champ de texte
3. Insérer un ‘’;’’
4. Coller le répertoire « bin » de votre JDK
(C:\Program Files\Java\jdk1.8.0_25\bin)
5. Cliquez sur Ok
6. Ouvrer l’invite de commande
7. Entrer la commande java –version pour
vérifier le bon déroulement de votre
installation
 PRÉPARATION DE
L’ENVIRONEMENT
• Pour les utilisateurs de linux
1. Décompresser l’archive de la JDK
2. Ouvrir le terminal et saisir la commande
 gedit ~/.bashrc
3. Aller à la dernière ligne et entrer les lignes suivantes
 export JAVA_HOME=/usr/local/java/jdk (Chemin vers la JDK)
 export PATH=${PATH}:${JAVA_HOME}/bin
4. Enregistrer le document et redémarrer le terminal
 PREMIER PROGRAMME
• Ouvrir le bloc note et saisir le code suivant :

• Sauvegarder sous le nom « HelloWorld.java »

 PREMIER PROGRAMME
(SUITE)
• Ouvrir l’invite de commande, se déplacer dans le répertoire contenant
votre classe et saisir « javac HelloWorld.java »
• Puis « java HelloWorld »
 JAVA
Les bases du langage
 QUELQUES CARACTÉRISTIQUES

• Java est sensible à la case

• Une instruction se termine par un point-virgule « ; »
• Un bloc d’instructions (boucle à plus de 2
instructions, méthodes, structures de contrôles, etc.)
se situe toujours entre des accolades « {…} »
• Une accolade ouverte doit toujours être fermée
 LES VARIABLES EN JAVA

• Deux types de variables :

• Type simple : il s'agit ici des types primitifs. Ce sont

généralement les types qu’on retrouve dans les
langages procéduraux à l’instar du langage C

• Type complexe : il s’agit dans ce cas d’objets. Et leur

type est alors leur classe d’appartenance
 TYPES PRIMITIFS
• Le type byte (1 octet) peut contenir les entiers entre -128 et +127.
• Le type short (2 octets) contient les entiers compris entre -32768 et
+32767.
• Le type int (4 octets) va de -2*109 à 2*109.
• Le type long (8 octets) peut aller de -9*1018 à -9*1018 (encore plus
gros…).
• Ex :
• Le type float (4 octets) est utilisé pour les nombres avec une virgule
flottante.
• Ex :
• Le type double (8 octets) est identique à float, si ce n'est qu'il contient
plus de chiffres derrière la virgule
• Ex :
 TYPES PRIMITIFS(SUITE)
• Le type char contient un caractère stocké entre apostrophes (« ' ' »),
comme ceci :
• Ex :

• Le type boolean, lui, ne peut contenir que deux valeurs : true (vrai) ou
false (faux), sans guillemets
• Ex :
 CATÉGORIES DE
VARIABLES
• Deux catégories de variables en Java:
• Les variables globales : elles sont déclarées dans la classe. Elle sont
crées en mémoire lors de l’instanciation de l’objet et retirées de la
mémoire lors de la destruction de cet objet
• Les variables locales : elles sont crées dans une méthode soit en tant que
paramètre de la méthode, soit en tant que variable de la méthode. Elles
sont accessibles uniquement dans leurs méthodes d’appartenance.

• On distingue aussi deux familles de variables globales:

• Les variables d’instances : elles représentent la « carte d’identité » d’un
objet.
• Les variables de classes : c’est une variable dont la valeur est commune
à toutes les instances de sa classe d’appartenance. Elles sont déclarées à
l’aide du mot clé static
 LES OPÉRATEURS (CAST)
• on ne peut faire du traitement arithmétique que sur des variables de
même type sous peine de perdre de la précision lors du calcul. On ne
s'amuse pas à diviser un int par un float, ou pire, par un char ! Ceci est
valable pour tous les opérateurs arithmétiques et pour tous les types
de variables numériques

• Le cast c’est la convers d’une variable d’un type à un autre.

• Ex :
 EXERCICE
• Compilez et Exécutez les codes suivants

• Commentez les résultats

 LES CONDITIONS
• La structure if… else
• « == » : permet de tester l'égalité.
• « != » : permet de tester l’inégalité.
• « < » : strictement inférieur.
• « <= » : inférieur ou égal.
• « > » : strictement supérieur.
• « >= » : supérieur ou égal.
• « && » : l'opérateur ET. Il permet de préciser une condition
• « || » : le OU. Même combat que le précédent.
• « ? : » : l'opérateur ternaire.
 LES CONDITIONS

• La structure if… else

 LES CONDITIONS
• La structure switch
• Le switch est surtout utilisé lorsque nous voulons des conditions « à la
carte »
• Prenons l'exemple d'une interrogation
• comportant deux questions : pour chacune d'elles, on peut obtenir
uniquement 0 ou 10 points
• Dans ce genre de cas, on utilise un switch pour éviter des else if à
répétition et pour alléger un peu le code.
 LES CONDITIONS
• La structure switch
• Ex :
 LES CONDITIONS
• La structure switch
• Depuis la version 7 de java, le switch peut prendre les variables de type
String
 LES BOUCLES
• La boucle while
• C’est l’équivalent de la boucle « tant que »

• La boucle do… while

• C’est l’équivalent de « répéter jusqu’à »

• La boucle pour :
• Equivaut à « pour »
 LES TABLEAUX
• Un tableau est une variables qui contient plusieurs valeurs ordonnées
séquentiellement que nous pourrons appeler au moyen d'un indice
• Il y a autant de types de tableaux que de types de variables
• Deux catégories de tableaux :
• Tableau à une dimension : on peut le voir comme un tableau à une ligne et
plusieurs colonnes ou un tableau à une colonne et plusieurs lignes

• Tableau multidimensionnel : ici, c’est un tableau qui a plusieurs lignes et

plusieurs colonnes :
 JAVA
Classe, Objet, Package, Héritage et Exception
 CLASSES ET OBJETS EN
JAVA
• Déclaration d’une classe public class NomClasse {//derscription}
• Toute classe java n’est pas exécutable. Pour qu’une classe java devient
exécutable, il faut quel implémente la méthode main
• Le prototype de la méthode main est : public static void main (String args []);
• Création d’un objet
• NomClasse nomObjet = new NomClasse();

• Déclaration d’une variable

• modificateur type nomVariable;
• modificateur type nomVariable = contenu;// déclaration + initialisation

• Déclaration d’une méthode

• modificateur type_retour nomFonction (type nomParamètre,…) {//contenu de la méthode}

• Le constructeur :
• méthode permettant d’instancier un nouvel objet
• Elle porte le nom de la classe et n’a pas de type de retour
 QUELQUES CONVENTIONS DE
JAVA
• Le nom d’une classe devrait commencer par une lettre majuscule
• Le nom d’une méthode ou d’une variable devrait commencer par une
lettre minuscule
• Dans le cas de nom venant de plusieurs mots, utiliser la notion en dos
de chameaux de préférence aux tirets, points, underscore ou tout autre
caractère spécial
• Ex: MaClasse, MaClasseEtudiant, nomEtudiant, nombreLivreAchete
• Les constantes se nomment en MAJUSCULE
 LES MODIFICATEURS
• Les modificateurs sont des mots clés qui permettent en général de
définir la façon dont on accèdera aux méthodes, variables ou classes
dans les programmes où ils sont utilisé.
• On distingue plusieurs types de modificateurs en Java:
• Modificateurs d’accès : public, private, protected, default
• Un modificateur d’accès indique si les autres classes de l'application
pourront accéder ou non à la classe/méthode/membre (qualifié par la
suite d'« item »). Ces modificateurs sont au nombre de quatre :
• public : toutes les classes peuvent accéder à l'item
• protected : seules les classes dérivées et les classes du même package peuvent
accéder à l'item
• private : l'item est seulement accessible depuis l'intérieur de la classe où il est
défini.
• (par défaut) : sans modificateur d'accès, seules les classes du même package
peuvent accéder à l'item.
 LES MODIFICATEURS
• Modificateurs d’accès : public, private, protected, default
 LES MODIFICATEURS
• abstract
• Le modificateur abstract indique qu'une classe ou méthode est abstraite.
• Toute classe déclarée avec ce mot clé ne peut être instanciée

• final
• Ajouté devant un attribut, il le rend immuable, dès lors qu'il est initialisé
• Pour les types primitifs, final fige la valeur, pour les objets, final fige la
référence, et non la valeur de la référence
• Devant une variable locale, il a le même comportement que pour un attribut.
• Devant une méthode, il indique que cette méthode ne peut pas être modifiée
dans une classe dérivée.
• Devant une classe, il indique que cette classe ne peut pas avoir de sous-classe.

• static
• Le modificateur static indique, pour une méthode, qu'elle peut être appelée
sans instancier sa classe (syntaxe : Classe.methode()).
• Pour un attribut, qu'il s'agit d'un attribut de classe, et que sa valeur est donc
partagée entre les différentes instances de sa classe.
 LES MODIFICATEURS
• synchronized
• Le modificateur synchronized indique que la méthode ne peut être exécutée que par un
thread à la fois. Le verrou ne s'active que pour l'objet sur lequel la méthode a été appelée

• transient
• Le modificateur transient indique que lors de la sérialisation de l'objet, cet attribut n'est
pas sérialisé et donc il est ignoré. Cela signifie que lorsque l'on désérialise l'objet,
l'attribut portant le modificateur transient n'est pas défini dans l'objet désérialisé.
• native
• Ce modificateur permet d'indiquer que cet item est défini dans une bibliothèque externe
écrite dans un autre langage de programmation, utilisant l'API JNI.

• strictfp
• Pour une méthode, une classe ou une interface, le modificateur strictfp (abréviation de
strict floating point) force la JVM à évaluer les opérations à virgules flottantes (sur les
double et float) conformément à la spécification Java, c'est-à-dire de la gauche vers la
droite. Cela permet d'avoir un comportement identique d'une JVM à une autre et d'éviter
certains dépassements de valeur limite pour les résultats intermédiaires.
• volatile
• Pour une variable, le modificateur volatile force la JVM, avant et après chaque utilisation
de la variable, à la rafraîchir à partir de la mémoire principale au lieu d'utiliser un cache
local. Cela permet de synchroniser la valeur de la variable entre plusieurs threads.
 EXERCICE
Saisir et compiler les programmes suivant :
EXERCICE
 LIRE LES ENTRÉES
CLAVIER
• En java, c’est la classe Scanner qui permet de prendre les
informations du clavier
• Pour récupérer une informations du clavier, il faut utiliser un
objet de cette classe
• Quelques méthodes pour récupérer les informations du clavier:
• nextLine() pour récupérer une chaine de caractère
• nextInt() pour récupérer un int
• nextLong() pour récupérer un long
• nextDouble pour récupérer un double
• nextByte() pour récupérer un byte

• Exercice : lire du clavier les informations d’un étudiant

 SETTER AND GETTER
• Méthodes permettant d’accéder en écriture (setter) ou en lecture
(getter) à une variable de globale déclarer comme privée
• Le setter d’une variable sera écrit comme suit

• Le getter d’une variable sera écrit comme suit

 PACKAGE

• Un package regroupe un ensemble de classes ayant la même

sémantique
• Il permet de regrouper les classes par thème, par lien, ou par
dépendances
• On peut le voir comme un répertoire contenant les fichiers Java
• Un package peut contenir plusieurs sous-packages
• Les noms des packages suivent alors le schéma suivant:
• name.subName.subSubName …
• Les API de Java sont organisés en packages
• ex : java.lang, java.io, java.net
 LE MOT CLÉ PACKAGE

• Pour créer un nouveau package il faut:

• Créer un dossier portant le nom du package dans le répertoire qui
doit accueillir nos fichiers java
• Utiliser le mot clé package suivis du nom complet de ce package au
début d’une classe. Ce qui va permettre de ranger (de manière
logique) cette classe dans le package en question
• Sauvegarder le fichier java dans le répertoire défini par le dernier
mot du nom complet de ce package

• Le nom complet d’une classe sera :

• nomPackage.NomClasse ou nomPackage.sousPackage.NomClasse
 LE MOT CLÉ IMPORT

• pour utiliser une classe java disponible dans un package différent de

celui dans lequel se trouve une classe il faut:
• Soit utiliser le nom complet de la classe
• Soit utiliser le mot clé import

• import permet d’importer une classe dans une autres, à fin de

l’utiliser sans être obligé de définir son chemin complet à tout
moment
• La syntaxe d’importation d’une classe est la suivante

• Exemple
 COMPILER UN PROGRAMME
MULTI-PACKAGE
• Créer ou choisir un dossier qui devra contenir les fichiers de votre
programme
• Créer un répertoire monPackage et enregistrer y la classe suivante
 COMPILER UN PROGRAMME
MULTI-PACKAGE
• Dans le répertoire de votre programme la classe suivante
 COMPILER UN PROGRAMME
MULTI-PACKAGE
• Ouvrir l’invite de commande et se déplacer dans le répertoire de votre
programme
• Aller dans le répertoire monPackage
• Compiler la classe Personne
• Revenir dans le répertoire du programme
• Compiler et exécuter la classe MainPers
• Créer un répertoire main dans le répertoire du programme et copier la
MainPers.java dans ce répertoire
• Ajouter la déclaration package main; au début du fichier (Première
ligne)
 COMPILER UN PROGRAMME
MULTI-PACKAGE
• La nouvelle classe ressemble à ceci

• Revenir dans l’invite de commande et se déplacer dans le répertoire main

• Compiler et exécuter la nouvelle classe
 HÉRITAGE
• Objectif : construire de nouvelles classes en réutilisant les
attributs et les méthodes de classes existantes
• Les attributs peuvent être modifiés au niveau de la sous-classe
• La sous-classe peut ajouter des attributs à ceux de sa classe mère;
dans ce cas ses attributs sont prioritaires sur les attributs qu’il
hérite.
• Une classe hérite d’une autre si elle répond à la relation « is a » ou
« est un »
• L'héritage successif de classes permet de définir une hiérarchie
de classe qui se compose de super classes et de sous-classes
• Toute classe hérite par défaut de la classe Object
 HÉRITAGE (SUITE)
• Pour dire que A hérite de B on utilise le mot clé extends (B extends A)
• Il n’est donc pas possible (en Java) d’écrire B extends A,C si B hérite à
la fois de A et C
• Une classe mère peut avoir plusieurs sous classes
• Une classe ne peut hérité que d’une seule classe à la fois dans un
programme Java
• Le mots clé super permet de faire appel à une méthode ou une donnée
de la super classe
• Exemple :
• super() pour le constructeur de la super classe
• super.toString() pour la méthode toString() de la classe mère
 EXERCICE - HÉRITAGE
• Réaliser le programme décris par l’architecture suivante :

Personne
- nom : String
La classe Principale va :
- prenom : String 1. Créer un objet des
- age : int différentes classes
- quartier : String
- pays : String 2. Prendre les informations
- sexe : String du clavier de chaque objet
+ donnerSesInfos () : String créer
...
3. Afficher les informations
de chaque objet à l’écran

Enseignant
Etudiant
- salaire : int
- matière : int - matricule : String
- montantVerse : int
+ donnerCours () : String
... + donnerInfos () : String
...
 EXCEPTIONS
• Les exceptions représentent le mécanisme de gestion des erreurs
intégré au langage Java.
• Il se compose d'objets représentant les erreurs et d'un ensemble
de trois mots clés qui permettent de détecter et de traiter ces
erreurs (try, catch et finally ) mais aussi de les lever ou les
propager (throw et throws).
• Deux phases de traitement d’une Exception :
• La propagation qui permet de levée une Exception à fin de signaler à
la JVM qu’un code est potentiellement dangereux
• La capture qui permet de récupérer une exception survenue à fin de
poursuivre l’exécution du programme

• Les exceptions représentent un mécanisme de sécurité en Java

HIÉRARCHIE DES CLASSES
D’EXCEPTION
 HIÉRARCHIE DES CLASSES
D’EXCEPTION
• Toute classe traitant une exception hérite de la classe Exception
• La classe Error représente une erreur grave intervenue dans la
machine virtuelle Java ou dans un sous système Java. L'application
Java s'arrête instantanément dès l'apparition d'une exception de la
classe Error.
• La classe Exception représente des erreurs moins graves. Les
exceptions héritant de la classe RuntimeException n'ont pas
besoin d'être détectées impérativement par des blocs try/catch.
• En cas de nécessité, on peut créer ses propres exceptions.
 THROWS ET THROW
• throws : ce mot clé permet de signaler à la JVM qu'un morceau
de code, une méthode, une classe. . . est potentiellement
dangereux et qu'il faut utiliser un bloc try{...}catch{...}. Il est
suivi du nom de la classe qui va gérer l'exception.

• throw : celui-ci permet tout simplement de lever une exception

manuellement en instanciant un objet de type Exception (ou
un objet hérité).

• Le mot clé throws est utiliser après la déclaration d’une

méthode potentiellement dangereuse

• Tandis que throw permet de propager l’erreur

 TRY/CATCH/FINALLY
• Le bloc try rassemble les appels de méthodes susceptibles de
produire des erreurs ou des exceptions.

• catch est défini pour capturer l'exception issue du bloc try

alors elle est traitée en exécutant le code associé au bloc.

• Le bloc optionnel finally permet d’exécuter un bloc de code

que l’exception soit survenue dans le try ou non
 EXEMPLE
• Supposons un projet calculatrice nous aurions des classes qui vont
réaliser des opérations mathématiques, des classes qui vont gérer des
exceptions et des classe qui vont permettre l’exécution de l’application

• Ceci nous donne un ensemble de trois packages

• mathématiques

• execution

• exception
EXEMPLE (SUITE)
EXEMPLE (SUITE)
EXEMPLE (SUITE)
EXEMPLE (SUITE)
 GÉNÉRALITÉS
• Dans le modèle Objet, les données d’un objet quelconque sont perdues dès
qu’on sort de sa portée.
• Il existe des mécanismes pour garder les informations d’un objet afin de le
reconstruire une fois qu’il ne se trouve plus en mémoire

• Parmi ces mécanismes nous avons:

• Les fichiers classiques
• Fichiers XML
• Les bases de données
• La sérialisation
• Etc

• Le principe ici est alors de sauvegarder les données, afin de les récupérées à
un moment quelconque.

• L’ensemble des classes qui vont permettre d’effectuer ces différentes tâches
constitueront la partie Modèle de notre application.
 LES BASES DE DONNÉES
• Une base de données est un outil permettant de stocker et de retrouver
l'intégralité de données brutes ou d'informations en rapport avec un thème ou
une activité
• Elle est généralement constituée de tables, et chaque table dispose d’un
ensemble d’attributs, parmi lesquels on a un attribut primaire appelé
identifiant de la table,
• Le logiciel qui permet de gérer ce stockage s’appelle SGBD (Système de
Gestion des Bases de Données) en anglais DBMS
• Il existe plusieurs SGBD parmi lesquels:
• Oracle Database
• PostgreSQL
• MySQL (que nous utiliserons)
• Microsoft SQL Server
• MariaDB
• SQLite
 LES BASES DE DONNÉES ET
JAVA
• Il existe deux technologies en Java pour la connexion à la base de données
• JDBC : Java DataBase Connectivity
• JPA : Java Persistance API

• Ces deux technologies permet la connexion des SGBD les plus Usuels grâce à
un API connector disponible sur le site Web du SGBD en question.
• La Java Persistence API (abrégée en JPA), est une interface de programmation
Java permettant aux développeurs d'organiser des données relationnelles dans
des applications utilisant la plateforme Java.
• La Java Persistence API repose essentiellement sur l'utilisation des annotations,
introduites dans Java 5. Elles permettent de définir facilement des objets métier,
qui pourront servir d'interface entre la base de données et l'application, dans le
cadre d'un mapping objet-relationnel.
 JDBC AVEC MYSQL
• JDBC (Java DataBase Connectivity) est une interface de
programmation créée par Sun Microsystems — depuis racheté par
Oracle Corporation — pour les programmes utilisant la plateforme
Java.
• Elle permet aux applications Java d'accéder par le biais d'une
interface commune à des sources de données pour lesquelles il
existe des pilotes JDBC.
• Il s'agit d'une base de données relationnelle, et des pilotes JDBC
sont disponibles pour tous les systèmes connus de bases de
données relationnelles.
• Le pilote JDBC pour MySQL s’appel mysql-connector-java et est
disponible sur le site de MySQL.
 JDBC AVEC MYSQL
• La première étape de la communication à une base de donnée est la
connexion.
• Elle se fait à partir de la méthode de classe Connection
getConnection(String url) de la classe DriverManager.
• Ex : Connection con = DriverManager.getConnection("jdbc:mysql://localhost/test?" +
"user=minty&password=greatsqldb");

• La deuxième c’est l’exécution d’une requête. Elle se fait en 2 phases:

• Ouverture de la connexion Grâce à la méthode d’instance Statement
createStatement() de la classe Connection
• Ex : Statement stmt = conn.createStatement();
• Exécution de la requête :
• Requête de lecture ResultSet rs = stmt.executeQuery(sql);
• Requete d’écriture int statut = stmt.executeUpdate(sql);