Cours: Programmation Java

Filière: 2 ème LSI

Enseignante: Dr. Majdoub Manel

2023-2024 Programmation JAVA 2eme SI 1

 Plan du cours

Chapitre 1 Introduction
Chapitre 2 Objets et Classes
Chapitre 3 Encapsulation et Surcharge
Chapitre 4 Héritage et Polymorphisme
Chapitre 5 Classes abstraites et Interfaces
Chapi
Chapitre 6 Les collections
tre 5
Chapitre 7 Les exceptions

18/09/2023 POO 2eme SI 2

Chapitre II: Objets et Classes
 Classe
• Une classe est un module qui sert à reproduire des objets
semblables.
• La déclaration d'une classe se fait de la façon suivante :

[Modificateurs] class NomClasse

{ corps de la classe
}

• Une classe est composée de deux parties:

– Les attributs : il s’agit des données représentant l’état de l’objet
– Les méthodes : il s’agit des opérations applicables aux objets.
 Exemple : classe Triangle
class Triangle
{ // Attributs de la classe
double hauteur ;
double base ;
// Méthode calculant la surface du triangle
double surface()
{
return base * hauteur / 2 ;
}
}
 Objet
• Un objet est caractérisé par plusieurs notions:
– Les attributs : Il s'agit des données caractérisant l'objet. Ce sont
des variables stockant des informations d'état de l'objet.
– Les méthodes (appelées parfois fonctions membres) : Les
méthodes d'un objet caractérisent son comportement, c'est-à-dire
l'ensemble des actions (appelées opérations) que l'objet peut
réaliser.
– L'identité : L'objet possède une identité qui permet de le
distinguer des autres objets, indépendamment de son état.
 Attributs

• Déclaration des attributs:

Syntaxe
Type Nom_variable [=valeur];
int x=0;

class Date {
int jour ; // Par défaut, un attribut est initialisé à zéro

int mois = 1 ;
int an = 2000 ;
final int MAX_MOIS = 12 ; //déclaration d’une constante

}
 Type de données en JAVA
• On distingue deux grandes familles de types de données en JAVA :
Les types primitifs
Dans ce cas, la déclaration de la variable
réserve la place mémoire pour stocker sa
valeur (qui dépend de son type)
Même types qu’en C : int , float , double ,
short , long , char , void
Plus deux nouveaux types : boolean ,
byte
Les types objets
La déclaration de la variable ne fait que
réserver la place d'une référence (une
sorte de pointeur) qui permettra
d'accéder à l'endroit en mémoire où est
effectivement stocké l'objet en lui même
Comprend les instances de classe et les
tableaux
le type String : ce type de données
pourra contenir une chaîne de caractères.
Comme il s'agit d'un type objet, le type
String dispose de méthodes propres,
comme par exemple la méthode equals()
qui permet de savoir si une chaîne contient
la valeur désirée.
 Méthodes
• Une méthode est composée de sa signature et d’un traitement associé
• La signature d’une méthode contient notamment
– un nom de méthode
– un type de données de retour
– des types de données pour ses arguments
• Par convention le nom des méthodes et attributs commencent toujours par une
minuscule

Syntaxe
<type de retour><nom de méthode>( <Arguments>)
{
<traitement>
}
 Exemple : classe Compte
class Compte {
int solde;
String titulaire;
int numero;
void afficher(){
System.out.println("solde: "+ this.solde);
}
void deposer(int montant){
this.solde = this.solde+ montant;
}
void retirer(int montant){
this.solde=this.solde-montant;
}
}
 Passage de paramètre
• Les types primitifs: passage de paramètres par valeur La transmission
des arguments de type simple est uniquement par valeur: les
arguments ne peuvent pas être modifiés par la méthode appelée.
• Les types objets : passage de paramètres par adresse Le passage des
objets en paramètre d’une méthode est par adresse: si la méthode
modifie l'objet, il sera donc toujours modifié après l'appel à cette
méthode.
 Instanciation
Le programme est lui-même une classe

Une classe public class Test {

Des objets public static void main () {
Class Etudiant
{ Etudiant E1, E2, E3; //on déclare les
objets
} E1=new Etudiant();
instancier E2=new Etudiant();
E1 E2 E3 E3=new Etudiant(); //on crée les objets
…}

}//fin MonProgramme
class Etudiant
{

}
 Instanciation
• Pour instancier un objet d’une classe (création d’un objet), on fait un appel
explicite à l’opérateur new en précisant la classe à instancier.
• Un objet est donc une instance d’une classe.
• Format général : <nomClasse> reference = new <nomClasse>() ;
• Pour créer un objet Triangle on met : Mémoire
Triangle t ; // Déclaration d’une variable t
t

t = new Triangle (); // Création d’un objet Triangle

Stack Heap
 Instanciation
• Pour instancier un objet d’une classe (création d’un objet), on fait un appel
explicite à l’opérateur new en précisant la classe à instancier.
• Un objet est donc une instance d’une classe. L’adresse de
L’objet t dans
• Format général : <nomClasse> reference = new <nomClasse>() ;
la mémoire
• Pour créer un objet Triangle on met :
Mémoire
Triangle t ; // Déclaration d’une variable t
0058007
t
t = new Triangle (); // Création d’un objet Triangle 0058007 Hauteur 0.0
t est la référence de l’objet créé 0.0
base

Stack Heap
• Il est possible de mettre directement :
Triangle t = new Triangle ();

• En Java, le mot-clé new provoque une instanciation en faisant appel à un

constructeur de la classe instanciée
 Constructeur
• En Java, vous pouvez écrire au sein d’une classe des constructeurs, prenant
éventuellement des paramètres d’entrée, et initialisant l’objet lors de sa
création.
• Le constructeur est alors automatiquement appelé par l’opérateur new
quand vous instanciez un nouvel objet de la classe.
• Le constructeur d’une classe ressemble à une méthode, sans sortie, sans
type, et qui a le même nom que la classe.
class Triangle
{….
Triangle (double h, double b)
//Constructeur de la classe Triangle
{hauteur = h ;
Triangle t = new Triangle (3,4);
base = b ;
}
….
L’opérateur new fait appel au constructeur de la
}
classe
 Constructeur
• Constructeur par défaut (constructeur sans arguments) initialise les
attributs de la ..aux valeurs par défaut.
Triangle () //Constructeur par défaut
Triangle () //Constructeur par défaut
{ this.hauteur = 10.0 ;
{}
this.base = 5.0 ; }

Ce constructeur initialise l’attribut Ce constructeur initialise l’attribut

hauteur et l’attribut base par 0.0 hauteur par 10.0 et l’attribut base par 5.0

• Constructeur surchargé

Triangle (double h, double b)

//Constructeur surchargé
{this.hauteur = h ;
this.base = b ;}
 Constructeur
• Un constructeur est une méthode qui a le même nom que la classe
• Un constructeur n’a pas de valeur de retour
• Plusieurs constructeurs peuvent exister dans une même classe (avec
des arguments différents)
• Il faut au moins un constructeur dans une classe pour en instancier des
objets.
• Si aucun constructeur n'est défini, la classe a un constructeur par défaut
sans paramètres
 Exemple classe Rectangle
class Rectangle
{private int longueur ;
private int largeur ;
Rectangle () Utilisation:
{// C’est un constructeur sans paramètres
this.longueur =10 ; Rectangle R1= new Rectangle();
this.largeur = 5 ;}
Rectangle (int x, int y)
{// constructeur avec 2 paramètres
this.longueur =x ; Rectangle R2= new Rectangle(10, 20);
this. largeur = y ;
}
Rectangle (int x)
{
this.longueur =2*x ; Rectangle R3= new Rectangle(15);
this.largeur = x ;
} // constructeur avec 1 paramètre
public int calcul_surface ( )
{return (this.longueur*this.largeur) ;}
}
 Le mot clé this
• Le mot clé this permet est utilisé pour faire référence à l'objet
courant à l'intérieur d'une méthode ou d'un constructeur.
permet d’accéder aux attributs et aux méthodes de l’objet courant

class Triangle
{
double hauteur ;
double base ; Dans le constructeur de la classe on
Triangle (double hauteur, double base) a this.hauteur indique
{ l’attribut hauteur de l’objet courant
this.hauteur = hauteur ;
this.base = base ; hauteur ( à droite de l’affectation)
} correspond au paramètre du
double surface() constructeur.
{
return base * hauteur / 2 ;
}
}
 Variables
• Il y a trois grands types de variables dans une classe objet :
– Les variables d'instance: permettent de contenir l'état d'un
objet, aussi appelée attribut.

– Variables de classe ou variable static: sont communes à toutes les

instances de votre classe.
– Les variables locales : sont déclarées dans des méthodes, des
constructeurs ou des blocs. Ces variables ne sont visibles que
dans la méthode, le constructeur ou le bloc.
 Variables d'instances

class Triangle
{
// Variable d'instance Class Test
//sa valeur est propre à chaque instance Public static void main (String[] args)
double hauteur ; {
double base ; Rectangle R2= new Rectangle(10, 20);
Triangle (double hauteur, double base) //Les variables d’instance sont
{ //appelées avec le nom de l’instance
this.hauteur = hauteur ; System.out.println(R2.hauteur);
this.base = base ; }
} }
}
 Variables de classe ou variable static
• Les variables de classe, également appelées variables statiques, sont
déclarées avec le mot clé « static » dans une classe, mais en dehors d’une
méthode, d’un constructeur ou d’un bloc.
• Définies pour l’ensemble du programme et sont visibles depuis toutes les
méthodes
 Variables de classe ou variable static
public class Personnage
{ // variable de Classe: sa valeur est la même pour tous les objets de la classe
static int nbPersonnages = 0;
String nom; // nom du personnage
public Personnage(String pNom)
{
nbPersonnages++; // un nouveau personnage est créé, on incrémenete donc le
//nombre total de personnages créés
this.nom = pNom;
}}

public class Test

{ public static void main(String[] args)
{
Personnage P1 = new Personnage(« Ali");
Personnage P2 = new Personnage("Sami");
//Les variables de classe sont appelées avec le nom de la classe
System.out.println("Nombre total de personnages créés: " + Personnage .nbPersonnages);
}}
 Les constantes
• Les constantes sont définies avec le mot clé final : leur valeur ne
peut pas être modifiée.
public class Point {
final double pi=3.14 ;
}
 Les méthodes static
• S’appellent aussi méthodes de classe, elles désignent les méthodes dont les
actions concernent la classe entière et non pas un objet particulier.
• L’accès à ces méthodes ne nécessite pas la création d’un objet de la classe,
car on peut appeler directement la méthode à travers le nom de la classe.
• On peut utiliser aussi ces méthodes statiques pour manipuler des données
statiques

public class Calcul Class Test

{ public static void main (String[] args)
static int max(int a, int b) {int X;
{ X=Calcul.max(5,3);
if(a>=b) System.out.println(X);
return a; }
else }
return b;
}
}