Les bases du langage JAVA:

*Notions de variable:est une zone memoire reservé pour stocker les données du même
type:
-Nom: indentifie la variable
-Type: taille ou nature
-Valeur: contenu
Ex: Soit la variable a de type entier
int a = 4;
--Les types primitifs: ils sont regroupés en 4 grandes familles:
-Entiers(short,bite,int,long)
-Reel(float,double)
-Chaine(String)
-Booleen(Boolean)
Syntaxe de déclaration d'une variable:
type nomVariable = Valeurs;
Ex: int montant = 4500;
float prix = 4000;
double tva = 0.18;
long a = 0014;
String ="Chaine";
boolean p = true;
*Convention d'écriture:(C'est l'ensemble des règles et principe l'écriture du code
en JAVA)
-1ère règle:Nom des variables et méthodes:
Le nom d'une variable ou une méthode commence par une lettre minuscule et ne doit
pas contenir
de caractère speciaux, lorsqu'il est composé de plusieur mots la prémière lettre de
chaque mot
commence par une lettre majuscule.
Ex:
int prix = 200;
int prixUnitaire = 500;
float valeurParDefaut = 2000;
Cas de la methode:
function int calculPrix(){
return a;
}
function void afficheValeurOperation(){

}
2ème règle: Nom des classes et interfaces:
le nom de la classe ou de l'interface commence par une lettre majuscule et ne doit
pas contenir
de caractère speciaux, lorsqu'il est composé de plusieur mot la première lettre de
chaque mot commence
par une lettre majuscule:
Ex: public class FigureGeometrique(){

}
Ex2: public interface.FigureGeometrique(){

}
3ème règle: Nom des constantes
le nom d'une constante doit être en majuscule, lorsqu'il est composé de plusieurs
mots les mots doivent
être separer par un undersort(_)
Ex: final double PI=3.14;
final int VALEUR_MAXIMALE = 4;
*Les Operateurs:
Les Operateurs arthimetique(numerique)
+, -,*,/,%,=
Les Operateurs logique(ce sont des signes conventionnels permettant d'effectuer un
ou plusieurs operants)
&&(et),||(ou),!(negation)
Les Operateurs de comparaison
<,>, >=,<=,==,!=
Les Operateurs d'incrementation
++(incrementation)
--(decrementation)
-Les ternaires:
+=,-=,/=,*=,%=
*Structure générale d'un programme Java
1ère partie: "Entête permet" d'importer les packatages necessaire pour le bon
fonctionnement du programme
syntaxe: import nomPackage;
2ère partie: "la classe principale" concerne la description du programme
syntaxe: public class NomClasse{
public static void main(String[]arg){

}
}
Syntaxe Generale:
[import nomPackage;]
public class NomClasse{
public static void main(String arg[])
{

}
}
Explication: Methode principale main();
elle regroupe l'ensemble des instructions à executer dans le programme.
Ex: public class Bonjour{
public static void main(String arg[])
{
System.out.println("Bonjour");
}
}
Les commentaires (Ce sont les lignes de code non executable par le compilateur qui
permettent d'expliciter le programme)
// pour les mono ligne
/* .....*/ pour les multiligne
Les instructions de communication: ce sont les instructions qui permettent
d'établir une communication entre le programme
et l'utilisateur
Console: ce sont les instructions utilisant l'écrant noir
*Sortie: c'est tout ce que l'utilisateur va voir
Syntaxe: System.out.println("Message");
ou System.out.println("Messge"+);
*Entrée:
1-Importer le package de la classe Scanner
import java.util.Scanner;
-instantier la classe Scanner
Scanner s = new Scanner(System.in);
Les methodes de lecture des types primitif sont:
nextInt():les entier
nextFloat():
nextDouble():
nextLong():
nextLn():
Syntaxe:
Scanner c = new Scanner(System.in);
int a = c.nextInt();
float a = c.nextFloat();
*Les entrées/sorties graphique autrement dit boîte de dialogue
-Sortie:
1-Importer le package javax.
swing.JOptionPane
Syntaxe: JOptionPane.showMessageDialog(null,"message"+expression);
-Entrée
Syntaxe: JOptionPane.showInputDialog("Expression");
NB: La methode showInputDialog reçoit une chaine de caractère et retourne aussi une
chaine de caractère.
*Convertion de type
1-Convertion explicite:permet d'utiliser une methode ou une instruction prédefinie
pour convertir un type
Syntax:
Integer.parseInt(Expression);
float.parseFloat(Expression);
long.parseLong(Expression);
--Syntaxe:
expression.toString(); permet de convertir un objet à une chaine de caractère.
*Exécution:
1) Enregistrer le fichier avec le même nom que la classe
2) Compiler le fichier:
Syntaxe: javaC NomFichier.java
3) Exécuter le fichier java NomFichier
*Exercice de consolidation sur la partie:
Ex1: Ecrire un programme java permettant de calculer la distance qui sépare deux
points A et B représenter
sur un répère orthonormé, resoudre cet exercice en utilisant
a-la console
b-les boîtes de dialogue
Ex2: Ecrire un programme java permettant de calculer la registance en serie et en
parallèle de trois résistance,
resoudre cet exercice en utilisant:
a-la console
b-les boîtes de dialogue
Traité de l'Ex1 avec la console:
import java.util.Scanner;
public class Distance{
public static void main(String[]ar)
{
Scanner clavier = new Scanner(System.in);
System.out.println("Saisir les coordonnees du point A");
int xA = clavier.nextInt();
int yA = clavier.nextInt();
System.out.println("Saisir les coordonnees du point B");
int xB = clavier.nextInt();
int yB = clavier.nextInt();
double d = Math.sqrt(Math.pow((xB-xA),2)+Math.pow((yB-yA),2)));
System.out.println("La distance est: "+ d);
}
}
Traité de l'Ex1 avec les boîtes de dialogue
import javax.swing.JOptionPane;
public class DistanceDialogue{
public static void main(String[]ar)
 {
int xA = Integer.parseInt(JOptionPane.showInputDialog("Saisir XA:"));
int yA = Integer.parseInt(JOptionPane.showInputDialog("Saisir YA:"));
int xB = Integer.parseInt(JOptionPane.showInputDialog("Saisir XB:"));
int yB = Integer.parseInt(JOptionPane.showInputDialog("Saisir YB:"));
double d = Math.sqrt(Math.pow((xB-xA),2)+Math.pow((yB-yA),2));
JOptionPane.showMessageDialog(null,"La distance est"+d);
}
}
***********************************************************************************
*****************************************************
Chapitre4: Structure de contrôle:
Definition: C'est un ensemble d'instruction permettant d'imposer des conditions sur
l'exécution d'autres instructions
*Structure conditionnelle (Branchement conditionnel)
Syntaxe:
if(condition)
instruction;
else if(condition)
instructions;
else
instructions;
*Structure répétitive
while (conditions){

}
do{

}while(condition);
for (NomCollection item:NomClasse)
{

}
*Structure alternative (choix)
switch(choix){
case val1:
{

}break;
........
........
default:
}
Tableau:
Définition: c'est une liste d'ordonner d'éléments de même type, même nom dont les
éléments sont accesssible par leur indice
dont le prémier élément à pour indice 0 et le dernier n-1
1ère methode:
type nomTableau[]; ou type[] nomTableau;
2ème methode:
type nomTableau = new type[taille];
*Parcourir un tableau
for (iniatition;condition;condition)
{
S.outprintlnnomtable[indice];
}
for(intiation;condition;incrementation)
{
nomTableau[indice]=objet.nextType();
}
Methode
Définition: Une methode est une portion du programme faisant parti d'une classe ou
pas permettant d'effectuer les traitements spécifiques
Type:
1- Avec paramètre et type de retour
function type nomMethode(arg,..arg)
{
return valeur;
}
2-Avec parametre sans type de retour
function void nomMethode(arg,..,arg)
{

}
3-Sans parametre et type de retour
function type nomMethode(){
return valeur;
}
4-Sans parametre et sans type de retour
function void nomMethode(){

}
La classe string
String est une classe specifique dedier à la manipulation des chaines de caractère.
Déclaration d'une chaine:
1ère Syntaxe:
String nomVariable = "Valeur";
2ère Syntaxe:
String nomVariable = new String ("Valeur");
*Les méthodes de manipulation des chaines :
-charA(indice): Permet de retourner le caractère correspondant à l'indice
-indexOf(Caractère): Retoune l'indice d'un caractère passer en parametre
-lastIndexOf(Caractère): Retourne le dernier indice correspondance en caractère
-replace(caractère, caractère): Remplacer un caractère pour un autre
-SubString(position,chaine): Substituer un caractère dans une chaine
-equals(chaine): Comparer deux(2) chaines en tenant compte de leur casse
-equalsIgnoreCase(chaine): Comparer deux(2) chaines sans tenir compte de leur casse
Exercice de consolidation:
Exo1: Ecrire un programme java permettant de convertir un montant de l'Euro,
dollard et livre starling en franc guinéen
Resoudre cet exercice en utilisant les boîtes de dialogue.
Exo2: Ecrire un programme java permettant d'imiter un jeux de dé, le programme
fournira un nombre aléatoire entre 1 et 50 et
l'utilisateur devra deviner ce nombre, si le nombre est supperieure au nombre
aleatoire le programme affichera "ce nombre est plus
grand" et demandera à l'utilisateur de rejouer encore et si le nombre est
inferieure au nombre aléatoire ce progamme affichera
"ce nombre est plus petit" et demandera à l'utilisateur de rejouer encore et si le
nombre est égal au nombre aléatoire le
programme affichera Bravo! vous avez gagnez suivi du nombre de tentative. Resoudre
cet exercice en utilisant la console.
Exo3: Ecrire une methode java permettant d'effectuer la somme des éléments d'un
tableau d'entiers
Traité d'Exo3:
public void sommes(){
int entier[] ={4,5,3,2,1}
int som = 0;
for(int i; i<entier.length; i++){
 som = som + entier[i];
}
system.out.println("La somme = " + som);
}
public statc void main(String [] arg){
somme ();
}

2ème methode:
public class SommeTableauD{
public static void sommes(){
static Scanner src = new Scanner(System.in);
int[] entier = new int[5];
som = 0;
for(int i; i<entier.length; i++){
System.out.println("Saisir l'élément: " + i++);
entier[i]=src.nextInt();
som = som + entier[i];
}
System.out.println("La somme = " + som);
}
}
public statc void main(String [] arg){
somme ();
}
***********************************************************************************
**********************************************************
POO:
Introduction:
1-Encapsulation
Notion de classe = caractéristiques (attribut) + comportement (méthodes)
Syntaxe :
Modificateur class NomClasse{
attributs
methodes
}
public class voiture{
String marque;
String couleur;
int puissance;
String type;
int duree;
public void rouler{

}
public void accelerer{

}
public void ralentir{

}
}
Type de modificateurs: public, protected, private ,(static, final).
Notion d'objet:
Constructeur:
Il existe trois types de constructeurs: par défaut, d'initiation, par recopie.
Ex:
public class Point{
int x;
 int y;
public void afficher(){
System.out.println("("+x+";"+y+")")
}
public void deplacer(int dx, int dy){
x = x+ dx;
y = y +dy;
}
public Point(int x, int y){
this.x=x;
this.y=y;
}
}
Import java.util.*;
public
public static void main(String [] arg){

}
Exemple1:Créer une classe nommée Rectangle permettant de définir un rectangle ayant
la méthode surface permettant de
calculer la surface du rectangle, la méthode périmètre permettant de calculer le
périmètre du rectangle et
une méthode affiche permettant d'afficher les côtés du rectangle
a)- Ecrire le code de création de classe rectangle
b)- Créer une classe TestRectangle permettant de tester la classe Rectangle
Exemple2:Créer une classe nommée Voiture permettant de créer une voiture 🚘
contenant la méthode affiche
affichant les caractéristiques d'une voiture.
2-Héritage
3-Polymorphisme
Ex: Ecrire un progamme java permettant de calculer la surface, le périmètre, le
demi-périmètre des figures geometriques
suivantes Carré, Rectangle, Cercle. Resoudre cet exercice en utilisant les classes
abstraites et classes interfaces
********************************************************08/05/2023*****************
*************************************
Interface: ne contient pes les attributs, mains contient les prototypes;
Collection: defini l'ensemble, add(); remove(), Update();
les types de collection sont: list, set, Mat, set List, Set Map.
Exception: zone à risque(l'endroit où l'extension de la base de données,
type d'exception: Il y'a Zone (try) et surveiller (thows)
Ex:
On sais realiaser une application pour la gestion d'un compte bancaire sachant
qu'un compte est caractérisé par
NumeroCompte, Solde, DateCreation. Il existe deux types de comptes( compte courants
et les comptes d'épargne)
un compte est dit courant lorsque son taux d'intèrêt est supérieur ou égal à 5%, et
une compte d'épargne à pour
taux d'intérêt 15%.
TAF: application doit être capable de:
a)créer un compte en spécifiant le type de compte
b) Effectuer un depôt sur un compte
c) Effectuer un retrait sur un compte
d) Effectuer un virement d'un compte A vers un compte B
e) Afficher la liste des comptes
f) Consulter un compte par son numéro
g) Consulter le solde d'un compte
h) Supprimer un compte.
1) Ecrire le code de création de la classe compte, compte épargne et compte
courant.
2) Réaliser un programme pour tester la classe courante, et classe épargne
3) Faites un menu permettant de faciler la navigation à l'utilisateur
***********************************************************************************
*************
Les Exigences d'une application
1- Exigences technique
-Les outils à utiliser
-Technologie à utiliser
-Monter en charge des données
-...ect
2-Exigence fonctionnelle
-Tenir compte des fonctionnalités listé dans le cahier des charges
-Intitive et simple d'utilisation
-Evaluer dans le temps
-Maintenable
....ect.
Le JDBC(Java Data Base Connectivity)
*le pilote est fichier char qui est déjà implementé pour chaque système de base de
données.
1-Avoir le pilote du SGBD à utiliser
2-charger le pilote dans son projet
3-Charger le pilote dans le programme(il faut utiliser la classe 'class')
Instructions: 'class.forName('nom du pilote')'
4-Etablir une ou plusieurs chaine de connexion
5-Emettre les instructions sql
6-Etablir les états sur les instructions sql
7-Fermer la chaine de connexion
**********************************Les Ordres SQL***************************
DDL create, alter, drop,
DML insert, update, delete
DCL select
DTL grant, revoke,
Il existe deux type de requêtes(simple et préparées)
Les classes utiliser
Requetes classe Methodes
simple statement createStatement
Preparée PreparedStatement prepareStatement
Resultats ResultSet on peut utiliser createStatement
ou prepareStatement

Ajents, Clients, comptes

Ajents Clients Comptes Operation
id Code numero id
nom nom type intitule
prenom prenom client type
adresse adresse solde montant
poste contact dateTrans
contact genre numero
genre

***********************************************************************************
*********************************
Devoir: definir l'instantiation ou l'instance d'une classe, et donnez l'utiliter
d'une instance et l'importance d'une instance