UNIVERSITE INUKA

DEPARTEMENT DES SCIENCES INFORMATIQUES

2e Année Licence(L2)
Cours JAVA II, Session I
Professeur : Jaures PIERRE

Année Académique 2019-2020

 Chapitre 3

23/10/2020
 TABLEAUX

 Définition
 Tableau à une dimension
 Déclaration et création
 Accès aux éléments
 Saisir et affichages
 Tableaux à plusieurs dimensions
 Déclaration et création
 Accès aux éléments
 Saisir et affichages
 Exercices d’application 23/10/2020 3
 DÉFINITION

Un tableau est une structure de données contenant un groupe d'éléments tous du même type. Le type des
éléments peut être un type primitif ou une classe. Lors de la définition d’un tableau les [] spécifiant qu’il
s’agit d’un tableau peuvent être placés avant ou après le nom du tableau. Un tableau peut avoir une ou
plusieurs dimensions. Le premier élément d’un tableau a toujours pour index zéro. Le nombre de cases du
tableau est spécifié au moment de la création du tableau.
Le plus grand index d’un tableau est donc égal au nombre de cases moins un. Après sa création les
caractéristiques d’un tableau ne peuvent plus être modifiées (nombre de cases, type d’éléments stockés dans
le tableau). La
manipulation d’un tableau doit être décomposée en trois étapes :
● Déclaration d’une variable permettant de manipuler le tableau.
● Création du tableau (allocation mémoire).
● Stockage et manipulation des éléments du tableau. 23/10/2020 4
 TABLEAU A UNE DIMENSION

Un tableau a une dimension est un tableau qui est manipule par une seule indice.
Déclaration: La déclaration se fait comme une variable classique sauf que l’on doit ajouter à la suite du type
de données ou du nom de la variable les caractères [ et ]. Il est préférable, pour une meilleure lisibilité du
code, d’associer les caractères [ et ] au type de données. La ligne suivante déclare une variable de type tableau
a une dimension:
type[] tableau ou type tableau[]; Exemple: int tableau[] ou int []tableau;
Création: Après la déclaration de la variable il faut créer le tableau en obtenant de la mémoire pour stocker ces
éléments. C’est à ce moment que nous indiquons la taille du tableau. Les tableaux étant assimilés à des objets c’est donc
l’opérateur new qui va être utilisé pour créer une instance du tableau. La valeur fournie par l’opérateur new est stockée
dans la variable déclarée au préalable.
tableau=new type [taille]; // taille représente le nombre d’element du tableau.
int [] tableau=new int[12];//tableau de 10 entiers. Cette déclaration va créer un tableau avec douze cases numérotées de 0
à 11. La déclaration et la création peut se faire en une seule instruction: type []tableau=new type[taille];
 INITIALISATION D’UN TABLEAU A UNE
DIMENSION
L’Initialisation d’un tableau consiste à lui attribuer des valeurs statiques au moment de sa création.
Exemple, Soit un tableau d’entier a initialiser:
int[] nombre=new int{1,2,3,4,5,6,7,8,100,8388,171}; ou
int[] nombre={1,2,3,4,5,6,7,8,100,8388,171};
Il n’y a dans ce cas pas besoin de préciser de taille pour le tableau. Le dimensionnement se fera
automatiquement en fonction du nombre de valeurs placées entre les accolades.

23/10/2020 6
 ACCÈS AUX ÉLÉMENTS

L’Acces a un élément dans un tableau a une dimension se fait a l'aide du nom du tableau suivi de l’indice
de élément a rechercher -1.
Exemple:
Soit un tableau d’entier de 4 éléments: int tab[ ]=new int[4];
L’acces a éléments 4 du tableau se fait de la façon suivante: tab[3]; // on pose tab[3]puisque le premier
élément du tableau est de l’indice 0.
 SAISIR ET AFFICHAGE

Pour saisir et afficher les éléments d’un tableau en bloc, il est beaucoup plus facile d’utiliser une boucle
pour parcourir les éléments à saisir ou à afficher.
Exemple: soit tab un tableau de 5 entiers.
int tab[]=new int[5];
Saisir:
for(int i=0;i<4;i++){
tab[i]=instanceScanner.nextInt();
}
Affichage:
for(int i=0;i<4;i++){
System.out.println(tab[i]);
}
 TABLEAU A DEUX DIMENSIONS

Un tableau a deux dimensions est un tableau qui est manipule une indice ligne et une indice colonne.
Déclaration: La déclaration se fait comme une variable classique sauf que l’on doit ajouter à la suite du type
de données ou du nom de la variable les un double crochet [ ][ ]. Il est préférable, pour une meilleure
lisibilité du code, d’associer les caractères [ ][ ] au type de données. La ligne suivante déclare une variable
de type tableau a deux dimensions :
type[][] tableau ou type tableau[][]; Exemple: int tableau[][]ou int [][]tableau;
Création: Après la déclaration de la variable il faut créer le tableau en obtenant de la mémoire pour stocker ces
éléments. C’est à ce moment que nous indiquons la taille du tableau. Les tableaux étant assimilés à des objets c’est donc
l’opérateur new qui va être utilisé pour créer une instance du tableau. La valeur fournie par l’opérateur new est
stockée dans la variable déclarée au préalable.
tableau=new type [ligne][colonne]; // ligne représente le nombre de ligne et colonne represente le nombre de colonne
du tableau.
int [][] tableau=new int[3][4];//tableau de 12 entiers. Cette déclaration va créer un tableau avec 3lignes et 4 colonnes.
La déclaration et la création peut se faire en une seule instruction: type [][[] tableau=new type[ligne][colonne];
 INITIALISATION D’UN TABLEAU A DEUX DIMENSIONS

L’Initialisation d’un tableau consiste à lui attribuer des valeurs statiques au moment de sa création.
Exemple, Soit un tableau de nombre a initialiser:
double[][] nombre=new double[][]{
{1,2,3,5},
{4,6,7,7}
{100,66,555,6}
};
Ou double[][] nombre={
{1,2,3,5},
{4,6,7,7}
{100,66,555,6}
};
Il n’y a dans ce cas pas besoin de préciser de taille pour le tableau. Le dimensionnement se fera
automatiquement en fonction du nombre de valeurs placées entre les accolades.
 ACCÈS AUX ÉLÉMENTS

L’Acces a un élément dans un tableau a une dimension se fait à l'aide du nom du tableau suivi de l’indice
ligne -1 et de l’indice colonne -1 de élément à rechercher.
Exemple:
Soit un tableau d’entier de 3 lignes et 4 colonnes: int [][]tab=new int[3][4];
L’acces a l’élément 4 du tableau se fait de la façon suivante: tab[0][3]; // on pose tab[0][3]puisque le
premier élément du tableau est de l’indice ligne 0 et de l’indice colonne 0.
 SAISIR ET AFFICHAGE

Pour saisir et afficher les éléments d’un tableau a deux dimensions en bloc, il est beaucoup plus facile
d’utiliser une boucle pour parcourir les lignes et une boucle pour parcourir les colonnes.
Exemple: soit tab un tableau d’entier de 3 lignes et 4 colonnes.
int tab[]=new int[3][4];
Saisir:
for(int i=0;i<3;i++){
for(int j=0;j<4;j++){
tab[i][j]=instanceScanner.nextInt();
}
}
Affichage:
for(int i=0;i<3;i++){
for(int j=0;j<4;j++){
System.out.println(tab[i][j]);
}
}
 TABLEAU D’OBJETS

Un tableau d’objet est un tableau ou son type n’est pas un type primitif mais un type Objet(type de classe).
Ces types de tableaux sont généralement lies aux tableaux a une dimension et possède les mêmes syntaxes.
Il suffit de faire précéder le nom du nouveautypeobjet.
Exemple: Si on veut saisir des informations sur une classe de 12 Etudiants.
On peut créer une classe étudiants avec les champs relatifs puis créer un tableau pour les ajouter.
Soit une classe Personne avec les champs suivants: id,nom, prénom, sexe.
Si on veut saisir des informations sur 4 personnes. On peut créer un tableau de personne comme suit:
Personne []p=new Personne[4];
On parcours une boucle:
for(int i=0;i<4;i++){
p=new Personne[i];
p[i].id=instanceScanner.nextLine(); p[i].nom=instanceScanner.nextLine(); } etc…
 MANIPULATION COURANTE DES TABLEAUX

Lorsque l’on travaille avec les tableaux, certaines opérations doivent être fréquemment réalisées. Ce
paragraphe décrit les opérations les plus courantes réalisées sur les tableaux. La plupart d’entre elles sont
disponibles grâce à la classe java.util.Arrays fournissant de nombreuses méthodes static de manipulation de
tableaux.
Pour obtenir la taille d’un tableau, il suffit d’utiliser la propriété length du tableau pour connaître le
nombre d’éléments qu’il contient. Dans le cas d’un tableau multidimensionnel, il faut se souvenir qu’il s’agit
en fait de tableaux de tableaux. La propriété length indique alors le nombre d’éléments sur la première
dimension. Pour obtenir la même information sur les autres dimensions, il faut utiliser la propriété length
de chaque ligne du tableau de niveau inférieur.
 HÉRITAGE

 Définition
 Avantages
 Syntaxe
 Construction des classes dérivées
 Mot clés : this et Super
 Surcharge et redéfinition
 Accès aux constructeurs et aux méthodes de la classe mère
 Exercices d’Application

23/10/2020 15
 DÉFINITION

L'héritage est une notion fondamentale en Java et de manière générale dans les langages de programmation
Orientes Objets qui permet de créer de nouvelles classes par combinaison de classes déjà existantes sans
toucher au code source des classes existantes. l’héritage offre un moyen très efficace qui permet la
réutilisation du code.
 EXPLICATION

Ainsi, pour créer une nouvelle classe en appliquant ce concept, il suffit de faire hériter la nouvelle classe d'une classe
existante et de lui ajouter de nouvelles propriétés/méthodes. La classe créée à partir d'une autre classe sera nommée
classe fille(classe dérivée ou sous-classe). Celle qui sert à la création des classes filles sera nommée classe mère(classe de
base, super-classe). On dit alors que la classe fille hérite (ou dérive) de la classe mère.

Une remarque importante en Java, une classe fille dérive d'une unique classe mère, l'héritage multiple n'étant pas
supporté par le langage Java (nous verrons par la suite un moyen de simuler l'héritage multiple, ce avec le concept
d'interface). Une fois que l'héritage est spécifié, la classe fille possède aussi l'ensemble des attributs et des méthodes de
sa classe mère.

La classe mère de toutes les classes en java en java.lang.Object. Si aucune relation d’heritage n’est spécifiée, la nouvelle
classe creee hérite implicitement la classe java.lang.Object.
 AVANTAGES

Dans cette partie, Je cite quelques points importants qui pourraient être considérés comme des avantages du concept
d’heritage en POO. -
L’heritage offre la possibilité d’organiser les classes dans une hiérarchie de communication interrelationnelle.
Il permet de réutiliser une classe existante:
- en l'adaptant: ajouter de nouveaux attributs et méthodes à la nouvelles classes ou adapter (personnaliser) les attributs
et les en la factorisant: méthodes de la classes existante.
- plusieurs classes peuvent partager les mêmes attributs et les mêmes méthodes.
NB: L’héritage présente la relation EST-UN: Un chat . Les membres des Objets de l’heritage presente la relation A-UN.
La principale difficulté, avec l'héritage, est de définir ce qui est propre à la classe mère et ce qui l'est pour sa classe
héritière.
 SYNTAXE

Pour appliquer le concept d’héritage entre deux classes en Java, on utilise le mot clé extends (en minuscule),situe entre
la classe dérivée et la classe de base.

Voici la façon doit-on procéder pour utiliser le concept d’héritage:

class <NomClasseDerivee> extends <NomClasseDeBase>

Exemple: soit une classe de base appelée Personne. Si on veut créer une classe Etudiant qui hérite de la classe
personne, on doit procéder comme suit:
public class Etudiant extends Personne{
instructions;
}
 INTERPRÉTATION

La syntaxe donnée ci-dessus permet de définir un lien d'héritage entre deux classes:
- La classe <NomClasseDeBase> est le nom de la classe de base. On l’appelle aussi
une classe mère, une classe parente ou une super-classe. Le mot clef extends indique la classe mère.
- La classe <NomClasseDerivee> est le nom de la classe dérivée. Elle hérite de la
classe <NomClasseDeBase>. On l'appelle aussi une classe fille ou une sous-classe.
Remarques:
- On a seulement besoin du code compilé de la clase de base.
- Toutes les classe héritent de la classe Object. Par défaut, on ne met pas extends
Object dans la définition d’une classe. Exemple:
public class TestClasse { …} // équivalent à : public class TestClasse extends Objet { …}
 CONSTRUCTION DES CLASSES DÉRIVÉES

class ClasseDeBase { // classe mère

// Définition des attributs et des méthodes
}
class ClasseDerivee extends Classedebase{
// ClasseDerivee : Sous-classe directe de la classe ClasseDeBase
// Définition de nouveaux attributs et méthodes (propres à la classe ClasseDerivee)
// Adaptation des méthodes qui sont déjà définies dans la classe mère
// ClasseDerivee hérite des méthodes et attributs de la classe ClasseDeBase
}
class ClasseSousDerivee extends ClasseDerivee {
/* ClasseSousDerivee: Sous-classe directe de la classe ClasseDerivee et sous-classe
indirecte de la classe ClasseDeBase */
// Définition de nouveaux attributs et méthodes (propres à la classe ClasseSousDerivee)
// Adaptation des méthodes qui sont déjà définies dans les superclasses directes ou indirectes
// ClasseSousDerivee hérite des méthodes et attributs des superclasses.
}
 CONSTRUCTEUR DES CLASSES DÉRIVÉES

Le constructeur de la classe dérivée peut faire appel au constructeur de la classe parente en utilisant le mot
super() suivi de ses paramètres.
toutes les variables du constructeur de la classe de base doit être passées en paramètres au constructeur de
la classe fille mais seulement les variables de la classe fille vont être initialisées vu que les champs lies a la
classe de base ne sont pas des variables d’instances.
 APPEL AU CONSTRUCTEUR DE LA CLASSE
DE BASE

On peut faire appel au constructeur de la classe mère en utilisant le mot-clé super( ) avec les paramètres
requis. super remplace le nom du constructeur de la classe mère.
L'instruction super( ) doit être obligatoirement la première instruction des constructeurs de la classe fille.
Tout constructeur d'une classe fille appelle forcément l'un des constructeurs de la classe mère : si cet appel
n'est pas explicite, l'appel du constructeur par défaut(sans paramètre) est effectué implicitement.
 MOTS CLÉS THIS ET SUPER

Chaque instance est munie de deux références particulières :

this réfère l’instance elle-même.
super réfère la partie héritée de l’instance.
Le mot-clé this désigne, dans une classe, l'instance courante de la classe elle-même. Il est utilisé à différentes fins
décrites dans les sections suivantes. Il peut être utilisé pour rendre le code explicite et non ambigu.
Le mot-clé this peut être utilisé pour passer une référence à l'instance elle-même comme paramètre d'une méthode.
Par exemple : s'enregistrer comme écouteur d'évènement :
source.addListener(this);
Le mot-clé super permet d'accéder aux membres de la super-classe d'une classe, de la même manière que l'on accède
aux attributs de la classe elle-même à l'aide du mot-clé this.

Exemple: super.nomattribut ou super.nommethode()

 SURCHARGE

En programmation orientée objet, la surcharge, aussi appelée « overloading » ou , consiste à déclarer, dans
une même classe, des méthodes de même nom mais avec des sémantiques différentes :
 Même nom de méthode,
 Paramètres différents (soit sur le nombre ou le/les type(s)),
 Le type de retour n’est pas pris en compte.
 REDÉFINITION

Une méthode de la classe mère peut être implémentée différemment dans une classe fille: la méthode est
dite redéfinie. Aucun signe n'indique en java qu'une méthode est redéfinie (contrairement à Pascal, VB, C# ou à C++).
La redéfinition d'une méthode dans une classe fille cache la méthode d'origine de la classe mère. Pour
utiliser la méthode redéfinie de la classe et non celle qui a été implémentée dans la classe fille, on utilise
la mot-clé super suivi du nom de la méthode.
ex:
super.machin( ) fait appel à la méthode machin( ) implémentée dans la classe mère et non à l'implémentation de la
classe fille.
 EXERCICES

Supposons que nous souhaitions créer une application qui permet de manipuler différents types de comptes bancaires:
les comptes épargnes et les comptes payants.
Tous les types de comptes sont caractériser par:
Un code et un solde
Un compte peut subir les opérations de versement et de retrait. Pour ces deux opérations, il faut connaître le montant
de l’opération.
Pour consulter un compte on peut faire appel à sa méthode toString().
Un compte Epargne est un compte bancaire qui possède en plus un champ «taux Interêt» et une méthode
calculIntérêt() qui permet de mettre à jour le solde en tenant compte des interêts.
Un ComptePayant est un compte bancaire pour lequel chaque opération de retrait et de versement est payante et vaut
5 % du montant de l’opération.
Analysez si c’est possible ou non d’appliquer le principe d’heritage et décrire l’enchainement.
 ENCAPSULATION

 Définition
 Modificateurs d’accès
 Par défaut (package)
 Public
 Private
 Protected
 Les getters
 Les setters
 Exercice d’application

23/10/2020 28
 DEFINITION

L'encapsulation est un mécanisme consistant à rassembler les données et les méthodes au sein d'une
structure en cachant l'implémentation de l'objet, c'est-à-dire en empêchant l'accès aux données par un
autre moyen que les services proposés. L'encapsulation permet donc de garantir l'intégrité des données
contenues dans l'objet.
Pour mettre en œuvre l'encapsulation, la première étape consiste à privatiser les attributs. Pour ce faire, un
mot clé spécial vous est proposé : private
Ensuite, il faut fournir les méthodes d'accès sécurisées : ce qu'on appelle généralement des propriétés en
programmation orientée objet et assez souvent getters/setters en Java.
 LE MASQUAGE DES INFORMATIONS

L'utilisateur d'une classe n'a pas forcément à savoir de quelle façon sont structurées les données dans
l'objet, cela signifie qu'un utilisateur n'a pas à connaître l'implémentation. Ainsi, en interdisant l'utilisateur
de modifier directement les attributs, et en l'obligeant à utiliser les fonctions définies pour les modifier
(appelées interfaces), on est capable de s'assurer de l'intégrité des données (on pourra par exemple s'assurer
que le type des données fournies est conforme à nos attentes, ou encore que les données se trouvent bien
dans l'intervalle .
 MODIFICATEURS D’ACCÈS

En java, il existe 4 niveaux de protection ou modificateurs d’acces :

1) private : Un membre privé d’une classe n’est accessible qu’à l’intérieur de cette classe.
2) protected: Un membre protégé d’une classe est accessible à l’intérieur de cette classe.
Aux classes dérivées de cette classe.
Aux classes du même package.
3) public (+) : accès à partir de toute entité interne ou externe à la classe.
4) Autorisation par défaut : dans java, en l’absence des trois autorisations précédentes, l’autorisation par
défaut est package. Cette autorisation indique que uniquement les classes du même package ont
l’autorisation d’accès.
 GETTER

Les Getters sont des méthodes le plus souvent publiques, de même type que l’attribut dont il est lie,
permettant d’acceder au contenu des variables privées d’une classe dans d’autres classes. Il retourne la
variable en question.
Pour définir un Getter, il faut d’abord définir une variable et on utilise couramment le préfixe get devant le
nom de la variable d’où le getter est lie. La définition d’un Getter est comme suit:

[portée] typeVariable getNomVariable(){

return NomVariable;
}
 SETTER

Les Setters sont des méthodes le plus souvent publiques, de type void qui prend un paramètre de même type
que l’attribut dont il est lie. Il permet de modifier le contenu des variables privées d’une classe dans
d’autres classes.
Pour définir un Setter, il faut d’abord définir une variable et on utilise couramment le préfixe set devant le
nom de la variable d’où le setter est lie. La définition d’un setter est comme suit:

[portee] void setNomVariable(typeVariable variable){

this.variableIntancePrivee=variable;
}
A LA PROCHAINE!!!