ITI1521A: Introduction à l’Informatique II

Révision Mi-Session

Hiver 2023

Dr. Mouhcine Guennoun

Les types de données
❑ Les types de données sont divisés en deux grands groupes :

➢ Les types primitifs:

➢ byte, short, int, long, float, double, boolean, et char

➢ Les types non-primitifs:

➢ String, les tableaux, les classes

Types primitifs
Rappel sur les variables
La portée d’une variable en java

❑ La portée d’une variable en java est le bloc de code dans lequel

la variable est déclarée, accessible et modifiable.

❑ On a trois principaux types de portée :

➢ La portée de bloc : La variable n’est valide que dans le
block dans lequel elle est déclarée. (for, if...else, while…)
NB : Un bloc est défini par les caractères { }
➢ La portée de méthode : La variable n’est valide que dans
la fonction dans laquelle elle est déclarée.
➢ La portée de classe : La variable n’est valide que dans la
classe dans laquelle elle est déclarée.
Les types références
❑ Exemple : cas des tableaux

int[ ] monTableau;
monTableau = new int[10];

System.out.println(monTableau[8]);
 Les types références

monTableau

❑ Dans cet exemple, monTableau contient l’adresse du premier élément du

tableau.
❑ On dit que la variable monTableau référence (pointe sur) l’espace mémoire qui
contient le tableau.

❑ Lorsqu’on accède par exemple à la neuvième valeur du tableau en faisant

monTableau[8], le programme ajoute un décalage (offset) à l’adresse
associée à monTableau pour obtenir l’adresse contenant la 9ème valeur du
tableau.
 Les classes enveloppantes « wrappers »
❑ Les classes enveloppantes ou wrappers nous donnent la possibilité
de convertir les types primitifs en objet et les objets en types
primitifs.

❑ Cette conversion est rendue possible grâce aux fonctionnalités

boxing et unboxing ou autoboxing et autounboxing. Ces
fonctionnalités ont été ajoutées à partir de java 5.

❑ Tableau de conversion :

Classe
Boolean Byte Short Character Integer Long Float Double
Enveloppante

Type primitif boolean byte short char int long float double
Les méthodes: Appel par valeur

❑ On dit que l’appel des méthodes en Java est un appel par valeur
❑ Si vous changez la valeur du paramètre, la valeur de l’argument ne change pas.
 Exemple d’une Classe
❑ Pour déclarer une nouvelle classe (nouveau type de données) on
utilise la syntaxe suivante:
class Rectangle {
double longueur;
Attributs ou les Variables
double largeur;

Rectangle(double lo, double la){

longueur = lo;
largeur = la; Constructeur
}
double perimetre() {
return(longueur + largeur) * 2;
}
double surface() { Méthodes
return longueur * largeur;
}
}
Création d’une instance de classe: Constructeur

❑ Un constructeur est une méthode d’instance bien spéciale :

➢ Le constructeur a le même nom que la classe.

➢ On ne l’appelle que dans le contexte de la création d’un objet, à la

suite du mot clé new.

➢ Il est impossible d’y faire appel dans un autre contexte.

➢ Cette méthode ne retourne aucune valeur.

Création d’une Classe
❑ Pour créer un objet à partir d’une classe, on utilise la syntaxe
suivante:

NomClasse nomInstance = new NomClasse(arguments);

Rectangle rect1 = new Rectangle(4.5, 2.6);

Rectangle
Rectangle longueur = 4.5
largeur = 2.6

rect1
Accès aux variables et méthodes d’instance

Rectangle
Rectangle longueur = 4.5
largeur = 2.6

rect1

❑ L’accès à une variable d’instance se fait à partir de l’instance

elle-même selon la syntaxe suivante:
nomInstance.nomVariable;
Exemple: rect1.longueur;

❑ La même analogie est suivie pour les méthodes d’instances:

nomInstance.nomMethode(arguments);
Exemple: rect1.perimetre();
Modificateurs de visibilité
❑ Afin de concrétiser les notions d’encapsulation abordées
précédemment, nous devons définir dans notre classe la partie
visible (interface) et la partie cachée.

❑ Pour déclarer la partie privée, on va rajouter le mot-clé private

devant chacun des attributs et des méthodes que l'on veut
cacher, et rendre inaccessibles depuis l'extérieur de la classe.

Exemple:

private double longueur;

private double largeur;

Avec l’implémentation ci-dessus, la syntaxe suivante produira une erreur:

rect1.longueur; //Produira une erreur de compilation
Les variables de classes (static)

❑ Une variable de classe est une variable définie dans le corps de la

classe et qui est partagée par toutes les instances (objets) de cette
classe.

❑ Pour déclarer une variable de classe on utilise le mot clé static

class Rectangle {
private double longueur;
private double largeur;
public static String nomDeLaForme = "Rectangle";
Rectangle(double lo, double la){
longueur = lo;
largeur = la;
}
}
 Classe Abstraite
❑ Exemple:
abstract class FormeGeometrique {
private double x_centre;
private double y_centre;
FormeGeometrique(double x, double y){
this. x_centre = x;
this. y_centre =y;
}
public void afficherPositionCentre() {
System.out.println(“Le centre esr situé à : (“ + x_centre + “, ”+ y_centre + “)” );
}
public abstract void nature(); Méthode abstraite
}
Avec l’implémentation ci-dessus, le code suivant produira une erreur:
FormeGeometrique forme = new FormeGeometrique(2.5, 3.6); // erreur
 Classe Abstraite: Utilisation
❑ Exemple:
class Cercle extends FormeGeometrique {
private double radius;
…
public void nature() {
System.out.println (“Cette forme est un cercle“ );
}
}
Maintenant, nous pouvons écrire le code suivant:
Cercle cerc1 = new Cercle(2.5, 3.6);
cerc1. afficherPositionCentre(); //Méthode de la classe FormeGeometrique
cerc1. nature();
Interface
❑ Une interface suit la même analogie qu’une classe abstraite avec
quelques différences.

❑ Une interface ne possède que des méthodes abstraites.

❑ Toutes les variables définies dans une interface sont public, final et static.

❑ Une interface ne possède pas de constructeur.

NB: On peut omettre le mot clé abstract lorsqu’on déclare les méthodes
d’une interface du moment que toutes les méthodes étant abstraites.

Les mots clés final et static peuvent être omis également lors de la
définition des variables de l’interface.
Interface
❑ Une interface est comme un contrat.
Exemple:
Pour être un quadrilatère, une figure doit être construite selon l’interface
suivante.
interface Quadrilatere {
int NBRE_COTES = 4; Variables final, static

double perimetre();
double surface(); Méthodes abstraite

}
Héritage: super
class Cercle extends FormeGeometrique {
private double radius;
Cercle(){
super();
this.radius = 0;
}
Cercle(double x, double y , double radius){
super(x, y);
this.radius = radius;
}

}
❑ La ligne super(…) est un appel explicite au constructeur de la
superclasse immédiate.
❑ Cette forme d’appel, super(…), n’apparaît que dans un constructeur
et doit être la première instruction.
❑ Par défaut, un appel de la forme super() est automatiquement
inséré dans le constructeur de la sous classe.
Polymorphisme « ad hoc »

class Test {
public static void somme(int a, int b) {
System.out.println("La somme des 02 entiers est: " + (a + b));
}
public static void somme(int a, int b, int c) {
System.out.println ("La somme des 03 entiers est: " + (a + b + c));
}
public static void somme(double a, double b) {
System.out.println ("La somme des 02 decimaux est: " + (a + b));
}
public static void main(String[] arguments) {
somme(2, 3);
somme(2, 3, 5);
somme(3.14, 5.91);
}
}
Polymorphisme par sous-typage
import java.lang.Math;
abstract class Forme {
private double x, y;
public double surface() {
double s = 0;
//Cacule de la surface ...
return s;
}
}
class Cercle extends Forme {
private double rayon;
public double surface() {
return rayon * rayon * Math.PI;
} Overriding
}
class Rectangle extends Forme {
private double longueur, largeur;
public double surface() {
return longueur * largeur;
}
}
 Types génériques (Polymorphisme paramétré)
class Couple <T>{
private T element1, element2;
Couple(T x, T y){
this. element1 = x;
this. element2 = y;
}
public T getElement1() {
return element1;
}
public T getElement2() {
return element2;
}
}
class Test {
public static void main(String[] arguments) {
Couple <Integer> c1;
Couple <String> c2;
c1 = new Couple<Integer>(Integer.valueOf(1), Integer.valueOf(2));
c2 = new Couple<String>("first", "second");
Integer a = c1.getElement1();
String s = c2.getElement1();
System.out.println("a = " + a);
System.out.println("S = " + s);
}
}
Types génériques: plusieurs types
Méthodes génériques
class Test {
public static <T> void display(T[] maListe) {
for (T x : maListe) {
System.out.println(x); Boucle for-each
}
}
public static void main(String[] arguments) {
Integer [] monTableau = { 2, 6, -8, 10, 12 };
display(monTableau);
String [] monTableau2 = {"Bonjour","Bonsoir","Bonne journee"};
display(monTableau2);
}
}