Tutoriel java

Cours Tutoriel JAVA
DIABY Kalilou
23 F´evrier 2015
DIABY Kalilou Cours Tutoriel JAVA

”Le bonheur c’est lorsque nos actes sont en conformit´es avec nos
pens´ees ”: Gandhi

Sommaire
Dans notre séance de tutoriel nous aborderons dans un premier
temps les méthodes :
• Outils de la Programmation Orientée Objet.
• l’héritage
• le JAVABEAN
• les exceptions
• le design pattern
• aper¸cu des JDBC.
NB : Nous aborderons pas le côté graphique de JAVA car d’un
point de vue personnelle, je trouve qu’il existe des outils beaucoup
plus puissants permettant de développer de manière graphique et
de l’appeler dans un langage de programmation tel que JAVA.

Généralités
Partie 1 : Généralités
Rappels sur le monde de JAVA
1 Historique : Source : Wikipedia
2 Recommandations

Généralités
1 Historique : Source : Wikipedia
Le langage Java est un langage de programmation informatique
orienté objet créé par James Gosling et Patrick Naughton,
employés de Sun Microsystems, avec le soutien de Bill Joy
(cofondateur de Sun Microsystems en 1982), présenté
officiellement le 23 mai 1995 au SunWorld.
La société Sun a été ensuite rachetée en 2009 par la société Oracle
qui détient et maintient désormais Java.
La particularité et l’objectif central de Java est que 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.

Généralités
Pour cela, divers plateformes et frameworks associés visent à
guider, sinon garantir, cette portabilité des applications
développées en Java. Le langage Java reprend en grande partie la
syntaxe du langage C++, très utilisée par les informaticiens.
Néanmoins, Java a été épuré des concepts les plus subtils du C++
et à la fois les plus déroutants, tels que les pointeurs et références,
ou l’héritage multiple contourné par l’implémentation des
interfaces. Les concepteurs ont privilégié l’approche orientée objet
de sorte qu’en Java, tout est objet à l’exception des types primitifs
(nombres entiers, nombres à virgule flottante, etc.).
Java permet de développer des applications client-serveur. Côté
client, les applets sont à l’origine de la notoriété du langage. C’est
surtout côté serveur que Java s’est imposé dans le milieu de
l’entreprise grâce aux servlets, le pendant serveur des applets, et
plus récemment les JSP (JavaServer Pages) qui peuvent se
substituer à PHP, ASP et ASP.NET.

Généralités
Java a donné naissance à un système d’exploitation (JavaOS), à
des environnements de développement (eclipse/JDK), des
machines virtuelles (MSJVM (en), JRE) applicatives
multiplate-forme (JVM), une déclinaison pour les périphériques
mobiles/embarqués (J2ME), une bibliothèque de conception
d’interface graphique (AWT/Swing), des applications lourdes
(Jude, Oracle SQL Worksheet, etc.), des technologies web
(servlets, applets) et une déclinaison pour l’entreprise (J2EE). La
portabilité du bytecode Java est assurée par la machine virtuelle
Java, et éventuellement par des bibliothèques standard incluses
dans un JRE. Cette machine virtuelle peut interpréter le bytecode
ou le compiler à la volée en langage machine. La portabilité est
dépendante de la qualité de portage des JVM sur chaque OS.

Généralités
1
2 Recommandations
Salut à tous et à toutes.
Ce cours se présentera sous forme de tutoriels et sera à vrai dire
différents de ceux que vous aviez l’habitude de voir.
On partira d’un principe très simple :
Toujours donner le meilleur de soi même et ne jamais au grand
jamais donner son maximum
Ce tutoriel se présentera sous la forme de petits exemples qui
seront expliqués de fa¸con simples en vue de faciliter sa
compréhension.

Généralités
L’objet d’un tel document fut motivé par deux facteurs que sont:
1 la démystification de certains aspects de la programmation
que l’on rencontre dans bon nombre de documents de
programmations.
2 la mise à la disposition de documents assez simple de
compréhension et de lecture de tous.
3 l’élaboration et écriture de programmes intelligents, simple et
propre.
4 l’ utilité de tel ou tel langage de programmation.

Premiers pas
Introduction
En POO (Programmation Oriente Objet), JAVA, tout est classe et
objet. Dans notre schéma, nous obéirons la norme JAVABEAN, et
ceux dès le début de ce tutoriel. Il nous est possible de développer
de manière traditionnelle ou d’utiliser un IDE. Nous opterons ici
pour l’ EDI (Environnement de Développement Intégré) ; peut
importe celui que vous utiliser : ECLIPSE, INTELLIJI,
NETBEANS.
Écrivons notre premier projet JAVA ( ctrl + n ), et donnons un
nom a notre projet ; dans mon cas je travaille avec JDK 7 .
Une fois cela fait créons notre 1 ère classe JAVA : dika.java
Au moment de la création de dika.java, il nous est demande de
renseigner un nom de Package que nous remplirons selon la
convention du Reverse DNS pour Nom de domaine Inversé.

Premiers pas
Pour ceux qui ne le savent pas, le DNS est le nom que l’on
attribue à une adresse IP(192.168.15.42) en vue de faciliter son
accès que ce soit par le client que par l’Informaticien. Cette @ IP
fictive correspond a www.google.ci.
A supposer que l’on développe pour ces derniers, on pourrait entrer
comme nom de package : ci.google.vuegenerale.
Ou dans le cas, ou l’on aura à utiliser plusieurs packages :
ci.google.vuegenerale.machine.control
Vue qu’ici on aborde JAVA de fa¸con simple, nous n’allons pas trop
polémiquer sur ce que c’est le package.
Ensuite créons notre classe en y ajoutant un nom à la classe.

Premiers pas
Exemple :

Premiers pas
Ajoutons un message de bienvenue dans notre console qui se
trouve à côte de l’onglet problèmes Pour ce faire, nous rajouterons
ce bout de code :
System.out.println(”Bienvenue”);ou
System.out.print(”Bienvenue”); .On obtient donc :
package com.dikait.vuegenerale;
public class dika {
public static void main(String[ ] args) {
System.out.println(”Bienvenue”);
}
}
Le System.out.print(”Bienvenue”) se contentera d’afficher le mot
Bienvenue sans retour à la ligne. Alors que le
System.out.println(”Bienvenue”); ferait automatiquement un
retour à la ligne. Vous pouviez le tester en rajoutant d’autres
choses dans votre code.

Outils de la POO en JAVA
Les types Objets et Primitifs
1 Les types primitifs
2 Les types Objets

1 Les types primitifs
En POO, on emploie généralement le terme type primitif que
lorsque veut fait référence à des variables de types simples c’est à
dire prédéfinie dans le langage en question.
Il est d’usage de mettre la première lettre du nom de notre
attribut( variable ) en minuscules, puis le compléter ”comme nous
le voulons”.
En JAVA, il en existe un bon nombre. Ce qui est le cas des autres
langages de programmation orientes objets.
Néanmoins certaines différences s’y glissent d’un langage à un
autre.
Exemple : En Java le type String est un type primitif, alors qu’en
CSharp (C#) ce type est à la fois Objet et/ou primitif selon
l’écriture que l’on emploie; en l’écrivant avec un grand ”S” il est un
type Objet, et en l’écrivant avec un ”s” il devient un type primitif.

Pour rester dans le cadre de JAVA, nous parlerons des types
primitifs les plus utilisés que sont:
1 Integer (Entier): Ce type permet de gérer des attributs qui
serviront au programmeur de manipuler les entiers.
2 Double (double): Ce type permet de gérer des attributs qui
prendront des valeurs decimal avec une plage bien définie(
nombre de zéros connue).
3 Float (Réel ): Ce type permet la manipulation de valeurs réel.
Vous remarque sans doute qu’il a les mêmes fonctions que le
double, alors quelle différences existent-ils entre ces deux
types.
La réponse à cette question serait en terme d’espaces de
mémoire qu’elle offre aux attributs qui sont déclares en ce
type; la plage est bien plus importante que celle du double.

1 Char (caractère): Celui ci permet la gestion des
caractères(Exemple : a, est un caractère).
2 String (Chaˆıne de caractères) : Comme son nom l’indique
permet la gestion de chaˆınes de caractères(mot bien faites ou
pas).
Retenez que ce sont des attributs qui vous serviront dans
votre programme vous pourriez choisir les noms qui vous sien.

1
2 Les types Objets
Lorsque l’on parle de type Objet, en fait l’on fait référence a un
modèle qui nous est propre; c’est à dire que ce type a été créer par
nous même.
Ce type possède des comportements qui ont été définies par le
programmeur lui même. Pour ce qui est de l’exemple voir la partie
sur les classes.
Exemple : Personne dika = new Personne();

Quelques mots clefs
Quelques mots clefs
1 this
2 super
3 null

Quelques mots clefs
1 this
Le mot clef this, est l’un des termes le plus utilise en POO.
Car il permet au programmeur de spécifier à son code qu’il
souhaiterait effectuer une tache ou un traitement sur l’objet en
cours; il permet donc l’instanciation de l’objet en cours.
Sa syntaxe est : this.objet;
Il s’utilise très souvent à l’intérieur de méthodes prédéfinies par le
langage ou définie par le programmeur (l’ utilisateur).
NB : Ne perdez pas de vue le fait qu’en JAVA tout est classe et
Objet.

Quelques mots clefs
1
2 super
En POO, nous sommes le plus souvent confrontes a des problèmes
de redéfinition de méthodes. Ce qui a tendance à souvent porter a
confusion bon nombre de programmeurs.
Pour palier à ce problème Java a mis à la disposition des
programmeurs,le mot clef super afin que tout programmeur qui
souhaiterait manipuler des méthodes redéfinies de la classe mère
dans la classe fille, puisse le faire.
Sa syntaxe est la suivante :
super.methodeDeLaClasseMereRedefinie();

Quelques mots clefs
1
2
3 null
En POO, le vide est symbolise par le terme null et non par un
espace blanc(champ vide).
Parlant du vide qu’entendons-nous?
Par vide, nous exprimons le fait pour un objet, son existence ou
pas.
Partant de l’exemple de certaines chemises, il est possible de
s’apercevoir que certaines d’entre elles n’ont pas de poches. On
pourrait dans ce cas en JAVA, parler de poche == null .

Les méthodes en POO JAVA
1 Méthodes de classe
2 Méthodes Objets
3 Rédéfinition
4 Surchage

1 Méthodes de classe
Une méthode peut-être défini comme une fonction, qui sera
utilisable dans tout le programme. Elle possède un type de
retour(primitif ou objet) , une portée, un ou des arguments, et le
mot clé static. Elle permet une organisation plus simple et efficace
des objets que nous auront à utiliser.
Exemple de méthode de classe :
• Type de retour: void (rien)
• Portée : Public
• Le nom de la méthode ici correspond a methode-de-classe
• Nombre d’arguments : aucun

1
2 Méthodes Objets
Méthodes d’objets quand à eux n’ont pas le mot clé static. Nous
verrons plus en détail cela lorsque nous verrons les getters et
setters.
• Portée Public : Accessible à toutes les classes du package.
• private: Accessible qu’aux méthodes de la classe dans laquelle
elle est contenue.
• protected : Accessible au même package.

1
2
3 Rédéfinition
La redéfinition consiste à réécrire une méthode déjà existante de
notre classe mère, dans notre classe héritière ( fille ).
De ce fait si l’on hérite de la méthode JavaBean(String nom,
String prenom), on pourrait redéfinir cette méthode en la
modifiant en gardant ces arguments, portée, ...
Exemple : Redefinition.java

- JavaBean.java
import java.util.Set;
public class JavaBean {
String nom, prenom;
public JavaBean() { ... }
public String getNom() {
return nom; }
public String getPrenom() {
return prenom; }
public void setNom(String nom) {
this.nom = nom; }
public void setPrenom(String prenom) {
this.prenom = prenom; }

public void JavaBeanMethodeARedefinir(String nom, String
prenom) {
System.out.println(”Je suis la mehode
JavaBeanMethodeARedefinir de la classe mère”); }
}

1
2
3
4 Surchage
La surcharge ou sur-définition consiste pour une méthode d’être
réécrite avec des arguments différents.
Par exemple dans la première, on peut avoir un argument, dans la
deuxième deux argument,et ainsi de suite, ... , et toujours en
gardant la même signature(type de retour, portée, nom de la
méthode).
Exemple : Sucharge.java

class Test {
public void personne(String nom) {
// la méthode prend un argument
System.out.println(”Je prends un seul argument qui est : ” +
nom); }
public void personne(String nom, String prenom) {
// la méthode prend deux arguments
System.out.println(”Je prends deux arguments qui sont : ” + nom
+ ” ” + prenom); }
}
public class Surchage {
Test objet = new Test();
// création d’un nouvel objet
objet.personne(”DIABY”);
objet.personne(”DIABY”, ”Kalilou”); }
}

Polymorphisme
Le polymorphisme est le fait de pouvoir redéfinir des méthodes
hérité de la classe de base. C’est la possibilité de traiter de la
même manière des objets de type différents, pour peu qu’ils soient
tous de classes dérivées de la même classe mère.
Son but est d’améliorer l’extensibilité d’un programme.

Encapsulation
L’encapsulation est un terme qui signifie qu’il n’est pas possible
d’agir directement sur les données.
Pour ce faire, on utilise des méthodes qui jouent le rôle
d’interfaces.
En JAVA, cela est réalisé via les accesseurs et mutateurs se
trouvant dans notre bean.

Interaction utilisateur
1 Généralités
2 Méthode de saisie utilisateur

1 Généralités
Dans toute activité et vie humaine, la communication est une
condition nécessaire à son bon fonctionnement et son maintient.
C’est s’inspirant de ce principe, que tout programme se doit d’être
le plus interactif que possible en donnant la main à l’utilisateur de
telle sorte a éviter qu’il s’ennuie assez vite lorsqu’il sera amener à
utiliser votre application.
En POO, ou PP , cela se fait via des méthodes déjà existantes
dans des classes fournies et développeurs par les concepteurs de ce
logiciel.

M´ethode de saisie utilisateur
1 Scanner
2 Autres m´ethodes

1 Scanner
La méthode Scanner est une méthode permettant de donner la
main a l’utilisateur. Elle s’ insert dans notre code grâce à ce bout
de code :
Scanner saisieUtilisateur = new Scanner(System.in);
/* System est une classe JAVA. Le ”.in” ou ”.out” permet
d’utiliser respectivement l’entrée et la sortie du clavier .*/
On à aussi besoin d’importer le package qui lui faut. Ici, le terme
package correspond à une librairie. Car en important un package,
on charge la librairie dans lequel se trouve la méthode appelante.
Cela se fait grâce à cette instruction : import java.io.*;
// Le * permet d’importer tous les éléments de cette librairie
d’entrée et sortie.

Exemple : Interaction.java
import java.util.Scanner;
class Interaction{
public static void main String [ ] args){
private int valeur1;
Scanner lecture = new Scanner(System.in);
valeur1 = lecture.nextInt();
}
}

1
2 Autres méthodes
Pour ce qui est des autres méthodes veuillez a vous référer au web.
Un tas de documents s’y trouvent.

Outils de comparaisons
1 L’égalité ( ==) et l’ affectation (=)
2 Le OU logique (||)
3 Le ET logique (& &)
4 Le modulo (%)

L’égalité (==) et l’ affectation (=)
En Programmation, le signe == et = diffèrent.
1 l’ affectation (=)
2 L’égalité (==)

1 l’ affectation (=)
L’affectation consiste à donner une valeur à un attribut bien
spécifique; elle fixe la valeur de cette variable alpha à une valeur
bêta.
Sa syntaxe est : Type variable1 = variable2;
Toutefois, il nous est possible d’affecter une valeur à plusieurs
variables d’un coup.
Sa syntaxe est : Type variable1, variable2 = variable3;
Exemple : Affectation.java
class Affectation {
String nom = ”DIABY”;
// On affecte ici au nom le mot DIABY
int numero, identifiant = 123;}

1
2 L’égalité ( ==)
L’Égalité consiste à tester si une valeur valeur1 correspond à une
valeur valeur2. Elle s’utilise généralement avec les structure de
contrôles.
Sa syntaxe est : if(valeur1 == valeur2){ //instruction }
Exemple : Egalite.java
class Egalite{
Type valeur1 = 12; Type valeur2 = 50;
if(valeur1 = valeur2){
System.out.print(”Valeur 1 est égale à valeur 2”);}
... }

1
2
3 Le OU logique (||)
Le OU logique permet d’effectuer des test. Elle s’utilise très
souvent dans les structures de contrôle.
Sa syntaxe est : if(varaiable1 == variable3 || variable2 ==
varaible4){ ... }
Prenons l’exemple de la tenue vestimentaire. Si elle est trempée ou
si elles et sale, je ne la mettrai pas.
Exemple : OuLogique.java
class OuLogique{
if(tenue == trempee || tenue = sale){
System.out.print(” Je ne porterai cette tenue vestimentaire”);}
}

1
2
3
4 Le ET logique( && )
Le ET Logique tout comme le Ou Logique, permet d’effectuer des
test. Et elle s’emploie également dans les structures de contrôle.
Sa syntaxe est : if (variable1 == variable3 && variable2 ==
variable4){ ... }
Prenons l’exemple des feux tricolores. Si le feu est rouge et qu’il
n’y a pas de voiture sur la voie alors je traverse la rue.
Exemple : EtLogique.java
class EtLogique{
if ( feux == rouge && voiture == null ){
System.out.print(”Je traverse la rue”);}
... }

1
2
3
4
5 Le modulo ( % )
Le modulo consiste en programmation, à un traitement d’une
variable sur une autre variable en vue d’obtenir le reste de cette
dernière. En d’autres terme, il consiste à obtenir le reste de la
division de la variable1 par la variable2. Sa syntaxe est: Type
variable1, variable2, resultat;
resultat = variable1 % variable2;
Partons d’un exemple simple, pour celui ci. Nous chercherons a
déterminer le reste de la division de 5 par 2 (5 modulo 2).

Exemple : Modulo.java
class Modulo{
int valeur1 = 5;
int valeur2 = 2;
int reste;// Par d´efaut, un entier(int) est initialise `a zero (0)
reste = valeur1 % valeur2;
System.out.println(”Le modulo de 5 par 2 est ”+reste);}
}

Le JAVABEAN
La norme JAVABEAN
1 D´eclarations des attributs
2 Constructeurs
3 Accesseur
4 Mutateur

Le JAVABEAN
La norme JAVABEAN
La norme JAVABEAN est un des principes les puissants, lorsque
l’on est amener à coder de manière sécurisé et propre.Elle consiste
en créer une classe spéciale .java qui contiendra notre bean. Une
classe JAVABEAN se présente comme suit :
- Tous les champs sont déclarés de types privées - Un constructeur
par défaut est initialisé(est ajoute au code de notre classe
javabean)
- Des accesseurs (getters) et mutateurs (setters) y sont ajoutes
- une Sérialisation des Objets peut être envisagés

Le JAVABEAN
1 Déclarations des attributs
Tout attribut(variables ou champs) doit être déclarés de type
privées. Pourquoi cela ?
Cela ne permettra la manipulation de ces dits attributs que par les
accesseurs et mutateurs commis à chacune de ces variables.
Exemple : JavaBean.java
class JavaBean{
private String nom, prenom;
private int age;
private float taille;
}

Le JAVABEAN
1
2 Constructeurs
Un constructeur est une méthode qui porte le même nom que la
classe, elle ne comporte pas de paramètres,ni d’arguments, ni de
type de retour, et à une portée de type public.
Il est à noter que toute classe Java possède un constructeur par
défaut, et ceux même s’il n’est pas écrit dans notre code.
Un constructeur à notre classe bean se doit d’être crées.
class JavaBean{
public JavaBean(){
// On définit ici ce que fera le constructeur( les actions qu’il devra
exécuter). }
}

Le JAVABEAN
1
2
3 Accesseur
On utilise des méthodes get pour pouvoir manipuler les différents
attributs déclarés de type privés. Ces différentes méthodes get
,appelle getters, permettent une manipulation plus sécurisé des
différentes valeurs.
class JavaBean{
public String getNom(){
return nom;}
}

Le JAVABEAN
1
2
3
4 Mutateur
Idem comme pour le getters. Le mutateur est une méthode set
permettant la manipulation des attributs déclarés de type prives et
qui se trouve dans notre classe java.
class JavaBean{
public void setNom(String nom){
this.nom = nom; }
}

Le JAVABEAN
NB: Ce principe de programmation respectant la norme
JAVABEAN permet une meilleure sécurité et facilite la réutilisation
des objets auxquels l’on à affaire.

Classe
Les Classes en JAVA
1 Classe Principale
2 Classe Simple( Non principale )
3 Classe Abstraites

Classe
Classe
En POO, la notion de classe est un des éléments les plus
importants principe qui lui confèrent le titre de langage de POO et
le différencie des langages de Programmation Procédurale.
Il est de mise de mettre en CAPITAL (ou en Majuscule) la
première lettre de chaque mot lorsqu’il s’agit de donner le nom
d’une classe. Et par la suite tous les nouveaux mots qui la
composent, la première lettre en CAPITALE.
En JAVA, il existe des plusieurs types de classes. Toutefois, au sein
d’un projet (ou application) plusieurs classes peuvent exister mais
une seule classe main existe et est lancée à l’exécution de notre
projet. une classe se déclare comme suit:
class NomDeLaClasse{

Classe
1 Classe principale
Une classe principale est une classe qui permet l’exécution de notre
application et elle est unique. Elle se déclare comme suit :
Exemple :
class ClassePrincicipale{
/* Les deux lignes qui suivent permettent de dire à notre EDI qu’il
s’agit de notre classe principale. */
public static void main(String [ ] args){
// Instruction de notre main }
}

Classe
1
2 Classe Simple( Non principale )
Une classe est par définition, un ensemble dans lequel se trouve les
informations spécifique à notre traitement en POO. Elle se dit
simple, si elle ne comporte pas de main.
NB: Toutefois, attention à ne pas généraliser trop vite.
Sa forme générale est : class NomDeLaClasse{ ... }
Prenons comme exemple, une classe contenant en son sein un
attribut et une méthode. Exemple : Simple.java
class Simple{
private String nom =”DIABY”;
public void affiche(){
System.out.print(”Salut”);}
}

Classe
1
2
3 Classe Abstraites
Sachez tout simplement qu’elles existent.
Nous n’en parlerons pas dans ce tutoriel.

Structures de contrˆoles
Structures de contrˆoles : boucles
1 IF
2 FOR
3 DO WHILE
4 SWITCH

Structures de contrôles : boucles
Les structures de contrôles répondent à une certaine logique
auquel nous sommes confrontes tous les jours de notre vie. Cette
logique, se trouve rapidement retranscrit dans le code. Vue ce fait,
et aussi pour ne pas avoir vous embrouille on fera des exemples
très terrains c’est à dire de la vie courante.
Son principe est de faire un certain contrôle puis d’en vérifier sa
véracité puis en fonction de la réponse obtenue déclenche une
action(un événement).

1 IF
F (ou Si ), est une structure de contrôle à laquelle nous sommes
confrontes à tout instant de notre vie. Cette structure de contrôle
à pour but de tester qu’une seule fois l’instruction qui lui est
soumise.
Elle est de la forme : if (// argument) { ... } else { ... }
Partons d’un exemple : S’il fait jour ou qu’il est 7 h 30 min, je bois
du café, sinon s’il est midi je mange du riz sinon s’il est 16 h je
prendrais un goûter, sinon s’il fait soir je mangerais du léger,
sinon(dans le cas ou aucune de ces 3 condition ne parvient à être
réalisé ) je me contenterais d’un verre d’eau.

Exemple : StructureContole.java
class StructureControle{
String heure = ”jour”;
// Vous pouvez vous amusez à changez la valeur de l’heure.
Remarquez,
// il est de type String
if (heure == ”jour”) {
System.out.print(”Je bois du café au lait”);
} else if (heure == ”midi”) {
System.out.print(”Je mangerai du riz”);
} else if (heure == ”soir”) {
System.out.print(”Je mangerai du léger”);
} else {
System.out.print(”Je bois de l’eau”);
}
}

1
2 FOR
For ( pour en fran¸cais), quand a elle s’utilise dans le cas d’
itérations (suite d’événements). Cette structure de contrôle à pour
but de tester l’instruction qui lui est soumise d’une valeur
alpha(point de départ) à une autre valeur bêta(valeur d’arrêt).
Elle est de la forme : for (int alpha, alpha < bêta; alpha ++) { ...
}
Prenons l’exemple des bonbons.
Pour toute personne dont l’age est inférieure à 18, on lui donne un
bonbon.

Exemple : StructureControle.java
public class StructureControle {
for (int agePersonne = 0; agePersonne < 18; agePersonne++) {
System.out.print(”Vous aurez droit `a un bonbon”); }
}
}

1
2
3 DO WHILE
WHILE( tant que), pourrait être définit comme s’utilisant pour
vérifier un état bien spécifique , devant être rempli. Sa syntaxe :
while(//argument){...}
DO WHILE, à un comportement quasi similaire à celui du while ;
seul différence, l’instruction sera exécuté au moins une fois. Sa
syntaxe : do { ... } while(//argument) { ... }
Cette structure de contrôle, do while, à pour but de lancer(ou
d’exécuter) l’instruction se trouvant dans le do, puis de tester celle
se trouvant dans le while.
Exemple : Tant que l’age de l’utilisateur est inférieur a 18 dites lui
qu’il n’a pas accès à ce service. Faire Salut , et après on entre dans
le while en vérifiant que l’utilisateur est âges d’au moins 18 ans et
on lui donnera accès dans le cas contraire on lui dira qu’il n’a pas
accès a ce service.

public class StructureControle {
int age;
do {
System.out.println(”Salut, veuillez saisir votre âge”);
age = lecture.nextInt(); }
while (age >= 18);
System.out.print(”Vous n’aviez pas accès à ce service”); }
}

1
2
3
4 SWITCH
Switch est la structure de contrôle que j’adore car pour moi elle
s’utilise dans les situations ou nous connaissions les cas de figures
qui peuvent se présenter à l’avance. Elle devient plus précise, donc
évite l’utilisation du IF qui se trouve être trop englobant
(généraliste). Sa forme est :
switch (//valeur ) {
case value: //...
break;
default://...
break;}
Utilisons ici, le cas d’un programme qui demande à un utilisateur
de faire un choix entre différentes catégories d’ages (mineur,
adulte, vieillard) en fonction de son age et nous lui retournerons un

public class PPrincipale {
public static void main(String[] args) {
int age;
System.out.println(”Veuillez faire votre choix : 1 pour mineur , 2
pour adulte, 3 pour vieillard”);
age = lecture.nextInt();
switch (age) {
case 1: System.out.print(”Vous êtes un mineur”); break;
case 2: System.out.print(”Vous êtes un adulte”); break;
case 3: System.out.print(”Vous êtes un vieillard”); break;
default: System.out.print(”Vous êtes inconnu dans notre base”);
break; }
} }

Tableau
Tableau
1 Généralités
2 Tableau en JAVA

Tableau
1 Généralités
Un tableau est un moyen de regrouper des éléments dans un seul
objet, puis de permettre d’effectuer des traitements sur ce dernier
que sont la lecture, écriture, exécution d’opérations.
En Programmation, le tableau s’utilise dans le gain d’espace
mémoire, car toute conception d’ application se veut la plus
économique possible en termes de mémoires utilises.

Tableau
1
2 Tableau en JAVA
1 Tableau Primaire
2 Tableau `a une dimension
3 Tableau `a plusieurs dimensions
4 Tableau de type ArrayList

Tableau
En JAVA
En JAVA, il s’utilise pour stocker des donnes sur un individus bien
sp´eciﬁque. Prenons un individus qui est une personne, on pourrait
avoir sur lui son nom, prenom, age, sexe; que nous stockerons dans
un tableau de type String.

Tableau
1 Tableau Primaire
Par tableau primaire, j’entends tableau de type primitifs. On
distingue plusieurs types dont les tableau `a une dimension et les
tableaux `a deux dimensions.

Tableau
1
2 Tableau à une dimension
Le tableau à une dimension est un type de tableau ne pouvant
prendre qu’une valeur par zone de mémoire.
Sa syntaxe est :
Pour créer un tableau d’entier : int tableau [] = {””,”””,... }
Pour récupérer un élément de ce tableau : tableau[0]
NB : En java et dans la plupart des langages de programmations,
on commence par compter à partir de zero (0). Faisant de 0 le
premier élément.
Reprenons l’exemple précédent portant sur la personne possédant
un nom, ...

Tableau
Exemple : TableauUneDimension.java
public class TableauUneDimension {
String[ ] personne = { ”DIABY”, ”Kalilou”, ”21”, ”Masculin” };
System.out.print(personne[0] + ” ” + personne[1] + ” ” +
personne[2] + ” ans et de sexe ” + personne[3]);}
}

Tableau
1
2
3 Tableau à plusieurs dimensions
Le tableau à plusieurs dimensions fonctionnent de la même
manière que celui à une dimension à la seule différence qu’il prend
plus d’un élément sur une zone mémoire.
Partant de l’exemple précédant si l’on était amener à identifier la
personne se trouvant a une position donnée : cas d’une salle de
classe ou autre salle bien disposée. l’on serait amener à créer un
deuxième tableau; ce qui serait trop long et fatiguant.
Pour y remédier l’on à disposition le tableau à plusieurs
dimensions.Et dans ce cas précis, on peut créer un tableau a 2
dimensions et qui aura en une seule zone tous les éléments relatifs
à la position d’une personne.

Tableau
Exemple : TableauDeuxDimensions.java
public class TableauDeuxDimensions {
String[ ][ ] personnes = { { ”DIABY Kalilou”, ”Kone Paterson”,
”GOHORE BI Arsene”, ”IBO Landry” }, { ”KOUAME Dimitry”,
”AMICHIA Affiba”, ” FOLLY Vomua”, ”N’CHO Lo¨ıc ” } };
System.out.print(personnes[0][0]);}
/* Ici il affichera la personne la ligne 0 (ligne 1) et la colonne 0 (
colonne 0), qui se trouve être DIABY Kalilou */
// Toutefois, amusez-vous a changer les différentes valeurs
}

Tableau
1
2
3
4 Tableau de type ArrayList
Une ArrayList est un tableau listés pour stocker et contenir un
ensemble d’éléments sous forme de liste.
Sa syntaxe est : ArrayList<Type Objet> nomArrayList = new
ArrayList<Type Objet>

Tableau
Exemple : ArrayList1.java
import java.util.ArrayList;
public class ArrayList1 {
ArrayList <String> list = new ArrayList<String>();
list.add(”DIABY”); // on insère un nom à l’index 0
list.add(”Kalilou”);
list.add(2, ”Masculin”);
/* Ici, le 2 est mis pour l’index; le forcant ainsi à le mettre à
l’index 2. Sinon, l’on aurait Kalilou qui aurait ete à la position 1
s’il avait ete declaree comme DIABY */
System.out.print(”L’enregistrement se trouvant à la position 0 est
” + list.get(0) + ” et a la position 1 est : ” + list.get(1) + ” et a
la position 2 est : ” + list.get(2)); }
}

Exception
1 Exception prédéfinies
2 Exception personnalisées

Exception
1 Exception prédéfinies
1 TRY
2 CATCH
3 FINALY

Exception
Exception prédéfinies
En POO, ou en Programmation Procédurale (PP), la gestion des
erreurs est un critère nécessaire de bon codage. Par ce principe,
l’on est capable d’intercepter d’éventuelles erreurs qui pourrait
surgir pendant l’utilisation de notre application par l’utilisateur ou
des erreurs autres. Pour ce faire, on utilise des instructions que
sont : try, catch(), finally.

Exception
1 L’instruction TRY
L’instruction try est celle qui nous permettra d’exécuter notre bout
de code susceptible de généré d’éventuelles erreurs.
Exemples : Exception.java
class Exception{
private int valeur1, valeur2;
private float resultat;
try{
resultat = valeur1 / valeur2;
}
}

Exception
1
2 L’instruction CATCH
L’instruction Catch est celle chargée de gérer l’erreur qui est
générer par notre application.Elle capte ce message et en renvoie
un autre beaucoup plus simple et facile de compréhension par le
client.

Exception
Exemples : Exception.java
class Exception{
public static void main(String [] args){
private ﬂoat reultat;
try{
}
catch(Exception une exception arithmetique sera genere){
System.out.print(”Erreur !”);
}
} } }

Exception
1
2
3 L’instruction FINALLY
L’instruction finally permet l’exécution de la commande de manière
obligatoire, c’est à dire après exécution des du try et du catch.
Cette instruction s’utilise généralement avec une base de données
(nous emploierons dans la suite de ce tutoriel très souvent le terme
database en remplacement de base de données), afin de
déconnecter notre database, dans le cas où elle ne réussit pas a
être déconnecte dans le try et le catch.

Exception
Exemple : Exception.java
class Exception {
private float reultat;
try{
}
catch(Exception une exception arithmetique sera genere ){
System.out.print(”Erreur !”);}
finally {
System.out.println(”Exécution des instructions se trouvant dans le
finally”);}
} }

Exception
1 Exception personnalis´ee
1 L’instruction THROW
2 L’instruction THROWS

Exception
Exception personnalisées
Une exception personnalise s’utilise généralement lorsque l’on
souhaite générer soit soit même ces exceptions ; il s’avère être nul
lorsque l’exception que l’on souhaite créer existe déjà. Pour ce
faire, on utilise le mot clé throw et throws. Pour ce faire, on crée
une nouvelle méthode dans laquelle on définit nos différentes
exceptions.

Exception
1 L’instruction THROW
Le mot clef throw permet de gérer manuellement une exception.
Cela se fait grâce à la création de nouvel objet du type de
l’exception que nous venons de créer nous même.
Allez comprendre, que nous densifierons les différentes erreurs
possibles et capables de survenir, et aussi ce qu’il en devra résulter
une fois que ce cas se présentera.
Sa syntaxe est : throw new Exception
Partons ici d’un exemple tout simple qui consistera à nous afficher
tout simplement un message qu’est : Erreur ! exception
personnalisé.

Exception
Exemple : ExceptionPersonnalise.java
public class ExceptionPersonnalise extends Exception{
@Override public String getMessage() {
System.out.println(”Erreur ! exception personnalis´e ”);
return super.getMessage(); }
}
- PPrincipale1.java
public class PPrincipale {
public static void main(String[] args) {
try {
throw new ExceptionPersonnalise();
} catch (Exception e) {
e.printStackTrace(); }
}
}
1
P pour programme

Exception
1
2 L’instruction THROWS
Le mot clef throws permet d’indiquer à notre JVM que cette
méthode est susceptible de déclencher une erreur. Sa syntaxe est :
Methode throws ClasseExceptionCreerParUtilisateur { ... }

Héritage
1 Généralité
2 Héritage selon JAVA

Héritage
1 Généralité
L’héritage est une technique de la POO qui permet à une classe
fille d’hériter de tous les attributs et méthodes de la classe mère(de
base). On utilise pour cela le mot clef extends.
L’héritage permet de ce fait un gain en temps de travail et de
calcul, et en mémoire puisque l’on aura qu’à hériter d’une classe et
automatiquement posséder de toutes ses fonctionnalités.
De plus, on peut en rajouter de nouvelles que ce soit bien des
méthodes au sein de cette classe fille, ou les redéfinir ou les
surcharger.

Héritage
1
2 Héritage selon JAVA
En JAVA, la question d’héritage peut s’étendre jusqu’à celle de
l’implémentation. De ce fait, une classe Java peut hériter d’une et
unique classe Java, mais peut toutefois implémenter plusieurs
Interfaces.
Pour qu’une classe hérite d’une autre classe on utilise le mot clef
extends et pour qu’elle puisse implémenter une interface on utilise
le mot clef implements.

H´eritage
Exemple : Heritage.java
class Heritage extends JavaBean implements Interface1,
ActionListener{
// instruction et code de notre classe Heritage
// Action Listener est un ´ecouteur d’action.
// Nous y reviendrons plus tard
}

Design Pattern
1 Généralités
2 M-V-C

Design Pattern
1 Généralités
Le design pattern est une architecture destine en générale vers des
projets de grande envergure. Toutefois, Il est applicable à tout type
de projet.
Le design pattern n’est pas une affaire de JAVA pour ne pas dire
POO, elle s’applique aussi aux langages du WEB tels que PHP,
Ruby, ...
Dans notre tutoriel, nous parlerons du M-V-C. Cependant, il est à
noter qu’il existe le M-V-C 2. Pour plus d’informations se référer à
Internet.

Design Pattern
1 M-V-C : Modèle Vue Contrôleur
1 Modèle
2 Vue
3 Contrôleur
4 M-V-C 2

Design Pattern
1
2 M-V-C : Modèle Vue Contrôleur
Dans ce type d’architecture, la vue correspond à l’ IHM:Interface
Homme Machine, pour le client (l’utilisateur final). Le contrôleur,
tout en respectant notre schéma, est notre classe beans qui est
charge d’effectuer d’ éventuelles modifications et actions sur nos
différents champs ; elle contrôle le modèle.
Le modèle, ici représente les différentes classes a partir desquels le
bean sera utilise ; c’est à dire la classe qui utilisera le bean afin
d’accéder à ses différents champs et méthodes

Design Pattern
1 Modèle
Le modèle est en général l’élément qui permettra de définir tous les
objets que nous auront à manipuler dans notre application
structure en M-V-C. C’est en générale une classe en JAVA.
Comme additif, dans les applications Java Entreprise Edition
(JEE), c’est notre classe JAVABEAN.

Design Pattern
1 Vue
La vue est et représente notre Interface Homme Machine (IHM).
Pour ce qui est de JAVA, cette partie se gère grâce au graphisme en
utilisant le JAVA SWING, AWT, qui se trouve aujourd’hui obsolète
du fait que assez de framework existe et permettent de créer cette
vue tout en se chargeant de générer le code qui y va avec. Pour ce
faire, on dispose d’outils tels que Netbeans, JDeveloppers, ...
Dans le cadre d’une application web JEE, la vue peut être
représente par une Java Server Pages (JSP).
NB : Une JSP est une page HTML capable de contenir du code
JAVA.

Design Pattern
1 Contrôleur
Le contrôleur est la classe a partir de laquelle tous nos traitements
seront effectues. Le contrôleur agit sur le modèle en avisant à tout
moment la vue, permettant une gestion plus simple, sécurisé et
structure de notre programme.
Dans le cadre d’une application web JEE, elle représente les servlet
qui effectuerons les différents traitements, tout en informant notre
JSP.
NB : Une servlet est classe JAVA qui hérite de classe HttpServlet,
au travers de laquelle existe des méthodes doPost et doGet
permettant une interaction avec la (ou les) JSP.

Design Pattern
Exemple de Servlet
public class NewServlet extends HttpServlet {
protected void processRequest(HttpServletRequest request,
HttpServletResponse response) throws ServletException,
IOException {
}
@Override protected void doGet(HttpServletRequest request,
IOException {
processRequest(request, response); }
@Override protected void doPost(HttpServletRequest request,
IOException {
processRequest(request, response); }
@Override public String getServletInfo() {
return ”Short description”; }
}

Design Pattern
1
2
3
4 M-V-C 2
Ce design pattern, M-V-C 2, ne possède qu’une seule classe appelle
Front Control, qui va déléguer certains traitements spécifique à
d’autres classes, qu’on appelle les classes de Command.

Les Bases de données
1 Généralités
2 Java Database Connectivity

Généralités
De nos jours, toute bon application se doit de conserver
l’historique des taches effectues par l’utilisateur. Ceux ci, dans le
but de lui offrir un certain confort de par son utilisation(soft2 )
tout en lui donnant l’envie de se reconnecter à votre application.
Dans le but de palier à ce problème, l’on a recours à une base de
données qui sert de stockage à nos différentes données que sont :
- Informations personnelles utilisateurs
- Informations et sauvegarde du log utilisateur et machine
- etc, ...
Cette base de donnée se gère grâce à ce que l’on nomme un
Système Gestion de Base de Donnée Relationnel (SGBD 3 ). Il en
existe aujourd’hui plusieurs types dont le SGBDR (R pour
Relationnel) qui nous intéresse dans ce tutoriel.
2
Logiciel
3
Un logiciel de Gestion de Base de Données

Ce tutoriel n’étant axé sur la base de donnée, nous nous limiterons
à ce qui à été dit, et pour plus de complement référer a internet de
bons documents s’y trouvent.
La connexion a une base de donnes est devenue aujourd’hui, une
tache que peut effectuer tout programmeur. Cette connexion se
trouve simplifie de nos jours, vue la multitude de langages de
programmations et de SGBD dont nous disposons.

Java Database Connectivity
Java Database Connectivity : Connexion avec les bases de données
La connexion à une base de données en JAVA, ce fait via un
certain nombre d’outils que sont un driver 4, de méthodes de
préparations à la connexion, de quelques requêtes SQL ou NOSQL.
4
Un pilote qui à pour but de permettre l’accès d’un ou des services à un un
autre service qui l’installe.

1 Téléchargements et installation du driver
2 Méthodes de connexions ‘a une base de donnes

1 Téléchargements et installation du driver
1 Téléchargements
2 Installation du driver

Téléchargements et installation du driver
Pour ce faire, il nous faut utiliser un driver. Comment y
procède-t-on?

1 Téléchargements
Pour le téléchargement du driver, il est à noter que bon nombre de
SGBD nous est offert. Toutefois, pas de panique, car le choix du
SGBD est fonction de l’utilisation de notre base de données, du
public cible vers qui elle est orientée et aussi de nos moyens.
Pour notre tutoriel, nous utiliserons MySQL. Sans tarder,
téléchargeons le pilote nécessaire à cela en vue d’effectuer la
connexion.
Dans notre cas, le driver à chercher est: mysql-connector-java5
Lien de téléchargements :
Personnellement, moi j’ai le mysql-connector-java-5.1.32
NB : Je vous conseillerai de vous référer à Google en vue de
trouver la version la plus récente de votre driver
5
Je l’ai fait exprès d’enlever la version afin que vous puissiez récupérez la
dernière version du driver souhaitée

1
2 Installation driver : MySQL
Pour l’installation, sachez tout simplement une chose; ce n’en est
pas une. Car, il nous suffit juste de charger la librairie de ce driver
dans notre EDI6 et l’intégrer à notre projet. Cela je pense que vous
serez à mesure de le faire.
6
Integrate Developement Environnement

1
2 Méthodes de connexions à une base de données
1 Etablissement de la connexion
2 Erreur à ne jamais commettre avec les bases de données
3 Méthodes de connexions

Nous voici enfin arrive à l’instant de vérité, celle de la connexion et
des traitements (requêtes) a effectuer.
Avant tout sachez que tous les traitements que nous ferons ne
seront possible que par la librairie java.sql.*; qui se trouve inclus
dans JAVA.

1 Etablissement de la connexion
Créons à présent un nouvel objet pour la connexion à notre base de
données. Pour cela, nous utiliserons l’objet Connection.
La syntaxe serait : Connection ObjetDeConnection;

1
2 Erreur à ne jamais commettre avec les base de données
Dans bon nombre de cas, les bases de donnes servent à stocker les
informations sensibles sur des personnes (morales et physiques).
D’un tel point de vue, il est déconseillé de laisser une connexion à
la base donnes ouverte trop longtemps afin de réduire le hacking7
de nos data.
Pour cela, nous aurons recours au try, catch et finally8.
Dans ce cas, il n’y aura pas d’exemple précis car d’un point de vue
personnelle le JDBC s’utilise beaucoup avec le JEE9, et ceux même
s’il existe dans les JSE10.
7
Piratage de nos données
8
Vous comprendrez à ce niveau l’importance de ce finally
9
Java Entreprise Edition
10
Java Standard Edition

1
2
3 Méthodes de connexions
La connexion s’établit grâce a la méthode Class.forName() du
moins si l’on se base sur la norme 1.0 du JDBC.

Tutoriel java

Contenu connexe

Tendances (20)

En vedette (13)

Similaire à Tutoriel java (20)

Dernier (12)

Tutoriel java