Plan

1. Présentation de Java
2. Concepts de la programmation orienté objet(POO)

3. Premier exemple de programme Java

4. Exécution d’un programme Java
5. Lecture d’informations au clavier
6. Types primitifs de Java
7. Déclaration de variables et Initialisation
8. Les opé rateurs
9. Les structures de contrô le
 1. Présentation de Java

Langage de programmation orienté objets introduit par la société SUN en

1995.

Il possède de nombreuses caractéristiques :

 C’est un langage compilé : avant d’être exécuté, il doit être traduit dans le
langage de la machine sur laquelle il doit fonctionner.

 Il emprunte sa syntaxe en grande partie du langage C et C++.

 Les programmes Java peuvent être exécutés sous forme d’applications

indépendantes ou distribuées à travers le réseau et exécutées par un
navigateur Internet sous forme d’applets.

 Portable sur plusieurs systèmes d’exploitation tels que Windows, MacOS ou

Linux.
2
 2. Concepts de la programmation orienté
objet(POO)
1. Objet
Un objet est une structure informatique caractérisée par un état et un
ensemble d'opérations exécutables par cet objet qui caractérise son
comportement.
Objet = état + comportement (opérations)
Exemple 1:
Fenêtre

É tat position, taille, bordure, titre,

couleur,...
Comportement dessiner, déplacer, agrandir...
(Opérations)

Exemple 2: Fichier

É tat nom, directory, id, protections,

propriétaire, contenu,
Comportement ouvrir, fermer, détruire,
(Opérations) 3
2. Concepts de la programmation orienté
objet(POO)
2. Classe
Une classe c’est la description d’un ensemble d’objets ayant une structure de
données commune et disposant des mêmes méthodes.
Exemple 1:
Personne
-Nom :String
-Prenom :String
-Age :int
+affiche() :void
+calculeAge() :int

Exemple 2:
Materiel
-Nom :String
-Prix :int
-Nombre :int
+affiche() :void
+achete() :void
4
2. Concepts de la programmation orienté
objet(POO)
2. Classe

Classe Instances

Personne -Nom : Meknassi

-Nom :String -Prenom :Ali
-Prenom :String -Age :23
-Age :int Instanciation
+affiche() :void -Nom : Kadiri
+calculeAge() :int -Prenom :Hamza
-Age :30

5
 2. Concepts de la programmation orienté
objet(POO)
3. Encapsulation
L’Encapsulation signifie qu’il n’est pas possible d’agir directement sur les
données d’un objet ; il est nécessaire de passer par ses méthodes, qui jouent
ainsi le rô le d’interface obligatoire.
4. Héritage
L’héritage permet de définir une nouvelle classe à partir d’une classe
existante, à laquelle on ajoute de nouvelles données et de nouvelles
méthodes. Personne
Exemple 1: -Nom :String
-Prenom :String
-Age :int
+affiche() :void
+calculeAge() :int

Étudiant Enseignant
-cne :int -ppr:int
+affiche() :void +affiche() :void 6
2. Concepts de la programmation orienté
objet(POO)
Exemple 2:
Materiel
-nom :String
-prix:String
-nombre :int
+affiche() :void
+achete():void

telephone Ordinateur
-autonomie:int -µp:String
-3G:boole -frequence:int
-resolution:String -memoire:int
+affiche() :void +affiche() :void

5. Polymorphisme
Le polymorphisme (de poly et morphe : plusieurs formes) est un mécanisme
qui permet de redéfinir certain méthodes héritées de sa classe de base.
7
 3. Premier exemple de programme Java

Exemple 1:

public class PremProg

{ public static void main (String args[])
{ System.out.println ("Mon premier programme Java") ;
}
}

public class PremProg{…..}: cette ligne correspond la définition d’une

classe nommé PremProg .

public static void main (String [] args){…} : cette ligne permet de définir
la méthode particulière nommé main.
8
 3. Premier exemple de programme Java

 public : obligatoire pour que votre programme puisse s’exécuter.

 static précise que la méthode main de la classe PremProg n’est pas liée à
une instance (objet) particulière de la classe.

 String[] args : permet de récupérer des arguments transmis au programme

au moment de son lancement. On peut lancer un programme sans fournir
d’arguments, mais l’indication String args[] est obligatoire.

System.out.println ("Mon premier programme Java") ; cette ligne sert à

définir le contenu de notre programme qui va afficher le message Mon
premier programme Java suivi d’un changement de ligne dans la fenêtre de
console.

9
 4. Exécution d’un programme Java

Pour exécuter un programme Java on va utiliser l’enivrement de

développement Eclipse (plus utiliser).

10
 5. Lecture d’informations au clavier

Pour la saisie de données au clavier, on va utiliser la classe Scanner (Scanner

.java) qui regroupe des méthodes pratiques pour effectuer des saisies de
données :
 nextInt(),

 nextDouble(),

 nextFloat(),

 nextLong(),

 nextBoolean(),

11
 6. Types primitifs de Java
1. Types de données entiers

Type Taille Valeur minimale Valeur maximale

(octets)

byte 1 -128 (Byte.MIN_VALUE) 127 (Byte.MAX_VALUE)

short 2 -32 768 (Short.MIN_VALUE) 32 767 (Short.MAX_VALUE)

int 4 -2 147 483 648 2 147 483 647

(Integer.MIN_VALUE) (Integer.MAX_VALUE)
long 8 -9 223 372 036 854 775 808 9 223 372 036 854 775 807
(Long.MIN_VALUE) (Long.MAX_VALUE)

12
 6. Types primitifs de Java
2. Types de données réels

Précision
Taille Valeur absolue Valeur absolue
Type (chiffres
(octets) minimale maximale
significatifs)

1.40239846E-45 3.40282347E38
float 4 7
(Float.MIN_VALUE) (Float.MAX_VALUE)
4.9406564584124654E- 1.797693134862316E3
doule 8 15 324 02
(Double.MIN_VALUE) (Double.MAX_VALUE)

13
 6. Types primitifs de Java
3. Types de données caractères

Chaque variable de type char permet de stocker un seul caractère à la fois en

occupant 2 octets en mémoire.

Exemple : char C = 'x';

4. Types de données booléens

Les variables de type boolean peuvent prendre la valeur true ou false.

Exemple : boolean etat = true;

14
7. Déclaration de variables et Initialisation
1. Variables

 une variable est déclarée comme suit:

Exemple : int c ;
On peut l’initialiser int c=12;

2. Constantes

Les constantes sont déclarées par le mot clé final.

Exemple : final n = 20;

15
 8. Les opérateurs
1. Opérateurs arithmétiques

Symbole Description Exemple

- soustraction x-y 
* multiplication 3 *x 
Opérateurs
arithmétiques / division 4/2 
% modulo (reste de la 5%2
division)

2. Opérateurs d’affectations

Symbole Description Exemple

= Affectation x=2 
-= Soustraction et x-=2 
Opérateurs affectation
d’affectation
+= Addition et x+=2 
affectation
16
 8. Les opérateurs
3. Opérateurs d’incrémentations et décrémentations

Symbole Description Exemple

++ Pré-incrémentation ++x 
Opérateurs ++ Post-incrémentation x++ 
d’incrémentations et
décrémentations -- Pré-décrémentation --x 
-- Post-décrémentation x--

4. Opérateurs relationnels

Symbole Description Exemple

== égal à x==2
< inférieur à x<2
Opérateurs <= inférieur ou égal à x<=3 
relationnels > supérieure à x>2
>= supérieur ou égal à x>=3
!= différent de a !=b
17
 8. Les opérateurs
5. Opérateurs logiques

Symbole Description Exemple

&& et a && b
Opérateurs logiques || ou a ||b
! non !a

6. Opérateurs bit à bit

Symbole Description Exemple

& et a&b
| ou a|b
Opérateurs ^ ou exclusif a^b 
relationnels ˜ nom ˜x
<< décalage à gauche a<<3
>> décalage à droite b>>2

18
 9. Les structures de contrôle
1. Structure if

if (expression logique) instruction;

if (expression logique)
{instruction;
instruction;
...
}
2. Structure if else
if (expression logique) instruction;
else instruction;

if (expression logique)
{ instruction;
instruction;
...
}else
{ instruction;
instruction;
...
19
}
 9. Les structures de contrôle
3. Boucle for

for (initialisation; condition ; incrémentation ou décrémentation)

{
instruction_1;
instruction_2;
...
instruction_n;
}

4. Boucle while

while (expression booléenne)

{
instruction_1;
instruction_2;
...
instruction_n;
}

20
 9. Les structures de contrôle
3. Boucle do while

do
{
instruction_1;
instruction_2;
...
instruction_n;
} while(condition);

4. L’instruction switch

switch (variable){
case valeur1 : instructions1 ;
case valeur2 : instructions2 ;
…
default : instructions ;
}

21
 9. Les structures de contrôle
3. L’instruction break : Permet de terminer l’exécution d’une boucle.

Exemple :// Impression des nombres premiers entre 2 et 50.

int n = 50;
boolean Premier = true;
for (int i = 2; i <= n; i++)
{
Premier = true;
for (int j = 2; j < i; j++)
{
if (i % j == 0)
{
Premier = false;
break;
}
}
if (Premier) System.out.println(i);
}

22
 9. Les structures de contrôle

3. L’instruction continue: Permet l’interruption d’une itération en cours et

retour au début de la boucle avec exécution de la partie incrémentation.

Exemple : int somme = 0;

for (int i = 0; i < 100; i++)
{
if (i % 2 == 0) continue;
somme += i;
}

// somme renferme la somme des entiers impairs.

23
 10. Les classes et les objets

Syntaxe de déclaration d’une classe est :

public class Nom_de_la_classe

{
type1 p1; // propriété p1 Attributs
type2 p2; // propriété p2
…
type3 m3(…){ // méthode m3
…
} Méthodes
type4 m4(…){ // méthode m4
…
}
…
}
24
 10. Les classes et les objets

Exemple:

public class Point

{ public void initialise (int abs, int ord)
{ x = abs ;
y = ord ;
}
public void deplace (int dx, int dy) Méthodes
{ x += dx ;
y += dy ;
}
public void affiche ()
{ System.out.println ("Je suis un point de coordonnees " +
x + " " + y) ;
} Attributs
private int x ; // abscisse
private int y ; // ordonnee
} 25
 10. Les classes et les objets

1. Attributs ou propriétés: Les attributs (propriétés) peuvent avoir l'un des

trois caractéristiques suivantes :

Un attribut privé (private) n'est accessible que par

privé 
les seules méthodes internes de la classe.

Un attribut public est accessible par toute fonction

public
définie ou non au sein de la classe.

Un champ protégé (protected) n'est accessible que

protégé  par les seules méthodes internes de la classe ou d'un
objet dérivé.

26
 10. Les classes et les objets

2. Méthodes ou fonctions membres: La définition d’une méthode se

compose d’un en-tête et d’un bloc.

public void initialise (int abs, int ord) En-tête

{ x = abs ;
y = ord ; Bloc
}

Remarque : L’ordre des méthodes dans une classe n’a pas d’importance. Par
exemple dans la classe Point on peut déclarer la méthode affiche() puis la
méthode deplace(), affiche() peut être appelée sans problème dans
deplace().

27
 10. Les classes et les objets

3. Utilisation d'une classe : Pour pouvoir utiliser une classe il faut d’abord
déclarer un objet, la déclaration est réalisée de la manière suivante :

NomDeClasse NomDeVariable ;

//cette déclaration ne réserve pas d’emplacement pour un objet

de type Point,
Point a ;
//mais seulement un emplacement pour une référence à un
objet de type Point.

28
 10. Les classes et les objets
Pour créer une instance d’une classe, il faut utiliser l’opérateur new qui se
charge de créer une instance (ou objet) de la classe et de l’associer à la
variable. L’instanciation est réalisée par la façon suivante :

NomDeVariable = new NomDeClasse() ;

crée un emplacement pour un objet de type Point et

a = new Point() ;
fournit sa référence en a.
Il est possible de réunir les deux instructions en une seule :
NomDeClasse NomDeVariable = new NomDeClasse() ;

Crée une référence et un emplacement pour un

Point a = new Point() ; objet de type Point et fournit sa référence en a.
La situation peut être a ? x
? y
schématisée ainsi : 29
 10. Les classes et les objets
On peut appliquer la méthode initialise à l’objet référencié par a.

//appelle la méthode initialise de la classe Point en

a.initialise(3, 5) ; l’appliquant à l’objet de référence a, et en lui
transmettant les arguments 3 et 5
La situation peut être a 3 x
5 y
schématisée ainsi :

Pour employer notre classe Point nous pouvons définir une méthode main ou
une méthode d’une autre classe.

30
 10. Les classes et les objets
4. Constructeur(s) de classe : Un constructeur est une méthode particulière
dans une classe, le constructeur porte le même nom que la classe, et permet
de créer une instance de cette classe (allocation mémoire).
public class Point
{ public Point (int abs, int ord)
{ x = abs ;
y = ord ;
}
public void deplace (int dx, int dy)
{ x += dx ;
y += dy ;
}
public void affiche ()
{ System.out.println ("Je suis un point de coordonnees " + x + " " + y) ;
}
private int x ; // abscisse
private int y ; // ordonnee
} 31
 10. Les classes et les objets
 Quelques règles concernant les constructeurs

 Un constructeur ne renvoie aucune valeur. Dans son en-tête, aucun type

ne doit figurer devant son nom. Même la présence (logique) de void est
une erreur.

 Une classe peut ne disposer d’aucun constructeur (c’était le cas de notre

première classe Point). On peut alors instancier des objets comme s’il
existait un constructeur par défaut sans arguments.

 Une classe peut avoir plusieurs constructeurs, qui seront différenciés par
leurs paramètres.

 Un constructeur est toujours appelé à l’aide de l’opérateur new.

32
 10. Les classes et les objets
5. Affectation et comparaison d’objets

Point a, b ; //déclaration deux objets de type point

a 3 x
a = new Point(3,5); 5 y

b 2 x
b= new Point(2,0) 0 y

Si maintenant nous exécutons l’instruction d’affectation a=b ;

a 3 x
5 y
b 2 x
0 y

33
 11. Le mot clé this
On utilise le mot clé this dans les trois circonstances suivantes:
1- Dans une méthode sert à référencer l'instance de l'objet en cours
d'utilisation. this est un objet qui est égale à l'instance de l'objet dans lequel il
est utilisé.

Public class Point public class TestePoint

{ public Point (int abs, int ord) // constructeur
{ x = abs ; y = ord ; } { public static void main (String args[])
public Point doubleCoordonnees () { Point a, b;
{Point p=new Point() ; a = new Point(3, 5) ;
p.x=2*this.x ; p.y= 2*this.y ;
a.affiche() ;
return p ; }
public void affiche () b=a.doubleCoordonnees() ;
{ System.out.println ("Je suis un point de b.affiche()
coordonnees " + x + " " + y) ; } }
private int x ; // abscisse
private int y ; // ordonnee }
}
Je suis un point de coordonnees 3 5
Je suis un point de coordonnees 6 10

34
 11. Le mot clé this
2- Dans une méthode le mot-clé this permet d'éviter les conflits de nom
lorsque les noms d’arguments d’une méthode et les variables locales
identiques à des noms d’attributs d’une classe.

Public class Point{

public Point (int x, int y) // constructeur
{ this.x fait référence à la variable public class TestePoint
this. x =x ; membre x alors que x fait référence
{ public static void main (String args[])
this.y = y ; à la valeur de l'argument.
} { Point a ;
public void affiche () a = new Point(3, 5) ;
{ System.out.println ("Je suis un point de
a.affiche() ;
coordonnees " + this.x + " " + this.y) ;
} }
private int x ; // abscisse }
private int y ; // ordonnee
}

Je suis un point de coordonnees 3 5

35
 11. Le mot clé this
3- Dans les classes définissant plusieurs constructeurs, un constructeur peut
invoquer un autre constructeur de cette classe par le mot clé this().

Public class Point {

public Point (int x, int y) // constructeur
{
this. x =x ; this.y = y ; public class TestePoint
System.out.println("Constructeur avec 2
arguments "+x+" et "+y); { public static void main (String args[])
} { Point a ;
public Point () // constructeur sans argument
{ a = new Point(1,2) ;
this(0,0) ; b= new Point() ;
System.out.println("Constructeur sans
argument"); }
} }
private int x ; // abscisse
private int y ; // ordonnee
}

Constructeur avec 2 arguments 1 et 2

Constructeur avec 2 arguments 0 et 0
Constructeur sans argument
36
 12. L’opérateur instanceof
L'opérateur instanceof permet de vérifier si une référence d'objet est une
instance d'une certaine classe ou interface.

public class TestePoint

{ public static void main (String
Public class Point { args[])
public Point (int x, int y) // constructeur { Point a =new Point(1,2);
{ if(a instanceof Point)
this. x =x ;
System.out.println("l’objet a est
this.y = y ;
} une instance de la classe point");
private int x ; // abscisse else
private int y ; // ordonnee System.out.println("l’objet a n’est
}
pas une instance de la classe point
"); }
}
l’objet a est une instance de la classe point

37
 13. Les accesseurs
Un accesseur est une méthode publique qui donne l'accès à une propriété privée d’une
classe. L’accès peut être réalisé en lecture ou écriture. Par convention, les accesseurs
en lecture commencent par get et sont appelés des getters (accesseurs) et les
accesseurs en écriture commencent par set et sont appelés des setters (mutateurs).

Public class Point public class TestePoint

{ public Point (int x, int y) // constructeur { public static void main (String args[])
{ this.x =x ; this.y =y ; } { Point a = new Point(3, 5) ; a.affiche() ;
public void deplace (int dx, int dy){
x += dx ; y += dy ; } a.x=4 ;//interdit
public int getX () { return x; } a.setX(4 ) ;//solution
public int getY() { return y; } a.affiche() ;
public void setX (int c) { x=c; }
public void setY(int d) { y=d; } int t=a.x ;//interdit
public void affiche () { int t=a.getX() ;//solution
System.out.println ("Je suis un point de a.y=setY(7 ) ;
coordonnees " + x + " " + y) ; System.out.println ("Je suis un point de coordonnees " +
} a.x + " " +a. y) ;//Interdit
private int x ; // abscisse System.out.println ("Je suis un point de coordonnees " +
private int y ; // ordonnee a.getX() + " " +a. getY()) ;//Solution
}
}}

38
 14. La surcharge de méthodes
La surcharge d'une méthode permet de définir plusieurs fois une même
méthode avec des arguments différents. Lors de l’appel de la méthode, Le
compilateur choisi la méthode qui doit être appelée en fonction du nombre et
du type des arguments.

Public class Point{

public class TestePoint
public Point (int x, int y) // constructeur
{ this. x =x ; this.y = y ; } { public static void main (String args[])
public void deplace (int dx, int dy) //deplace (int, int) { Point a = new Point (1, 2) ;
{ x += dx ; y += dy ; } a.deplace (1, 3); // appelle deplace (int, int)
public void deplace (int dx) // deplace (int)
{ x += dx ; } a.deplace (2) ; // appelle deplace (int)
public void deplace (short dx) // deplace (short) short p = 3 ;
{ x += dx ; } a.deplace (p) ; // appelle deplace (short)
public void affiche ()
{ System.out.println ("Je suis un point de coordonnees " byte b = 2 ;
+ this.x + " " + this.y) ; a.deplace (b) ; // appelle deplace (short)
} apres conversion de b en short
private int x ; // abscisse
}
private int y ; // ordonnee
} }

39