1 ère Informatique

Liste des mots en JAVA

1] Abstract :

= est un mot clé en Java permettant de spécifier qu'une classe ne peut être instanciée mais doit être
héritée, à l'aide du mot clé « extends », par une autre classe (sous-classe). Une classe abstraite
peut aussi contenir des méthodes abstraites qui devront être implémentée par ses sous-classes.

a) Classe abstraite :

 Une classe est dite « abstraite » ssi elle possède une méthode abstraite !!
- elle contient une déclaration de méthode abstraite,

- un de ses parents a une méthode abstraite qu’aucune classe enfant n’implémente,

- une de ses interfaces a une méthode qu’aucune classe enfant n’implémente

 Elle est utilisée généralement quand d’autres classes vont hériter de cette classe et
ils ont la même méthode que la classe mère donc ont l'écrit pour ne pas répéter les
mêmes méthodes chaque fois dans ces classes.

Remarque :
- Une classe abstraite ne peut pas être instanciée
- PAS DE CONSTRUCTEUR DANS UNE CLASSE ABSTRAITE

Ex :
public abstract class Coup implements Action {
public abstract boolean estValide (EtatPartie etat );
public abstract void effectuer (EtatPartie etat ) throws IllegalCoupException ;
public void effectuer(Partie partie)throws IllegalActionException {
effectuer(partie.getEtat());
partie.getHistorique().add( (EtatPartie) partie.getEtat().clone() );
}
}

public class Rebond extends Coup {

private Position arrivee ;
public Rebond(Position unArrivee) {
arrivee = unArrivee ;
}
public boolean estValide (EtatPartie etat) {
boolean valide = false ;
if (etat.getPlateau().positionValide(arrivee) ){
...
return valide ;
}
public void effectuer (EtatPartie etat) throws IllegalCoupException {
if ( estValide (etat) ) {
if(etat.getPlateau().getPion(arrivee)==null) {
...
}
}else {
throw new IllegalCoupException ("Le Rebond est incorrect!!!");
}
}
}
1 ère Informatique

Mot clé : « extends » et « abstract »

b) Méthode abstraite :

= est une méthode « sans corps », elle est déclarée mais pas implémentée

Pourquoi ?
Une méthode est nécessaire lors de la création de la classe parent mais on ne peut en
spécifier le corps, ce sera pour la classe enfant !

Ex : public abstract void foo() ;

Mot clé : « abstract »

2] Autoboxing :(ou Boxing)  A VERIFIER

= permet de transformer un type de variable de type primitif en son type objet correspondant et
ceci automatiquement. Il s’agit d’un « cast automatique ».

- boolean −→ Boolean
- byte −→ Byte
- char −→ Character
- short −→ Short
- int −→ Integer
- long −→ Long
- float −→ Float
- double −→ Double

L'autoboxing est l'opération qui consiste à envelopper automatiquement une primitive dans sa
classe enveloppe correspondante.

Au lieu d'être obligé d'écrire du code semblable à ceci:

Integer i = new Integer(1000);

Boolean b = new Boolean(true);
Character c = new Character('A');

vous pouvez maintenant écrire le code suivant:

Integer i = 1000;
Boolean b = true;
Character c = 'A';

ATTENTION :
public class ComparerDesEntiers {
public static void main(String[] args) {
Integer b = new Integer(1000);
Integer b2 = new Integer(1000);
if (b==b2) {
System.out.println("b == b2");
}else {
System.out.println("b <> b2");
}
}
1 ère Informatique

Cela renvoie “b<>b2”

PQ?

Car le fait d'appeler un constructeur, on crée toujours un nouvel Objet en

mémoire. Et lorsqu'on compare les deux références, elles pointes vers deux
objets bien distincts.

Remarque :

-(Auto)Unboxing = est l'opération inverse de l'autoboxing. On prend la valeur de la classe

enveloppe pour en faire une primitive.

Ex :
{
Integer i = new Integer(100); //Création d'une classe enveloppant la
valeur 100

int j = i.intValue(); //Ce qu'on aurait du faire avec une version

antérieure au JDK 5.0

int j = i; //Unboxing de Integer en int.

}

3] Break/Continue :
a) Break :

= Sert à arrêter brutalement une instruction

 Grammaire :

- Si pas d’étiquette ! Arrête la première instruction while/for/do/switch englobante

- Si étiquette ! Arrête brutalement l’instruction étiquetée et passe à la suivante

Ex :
int nb;
entrée : while(true) {
nb = clavier . nextInt ();
if (nb>0)
break entrée;
System.out.println( "Mauvais nb. Recommencer.");
}

Int i =1 ;
lab1 : { if ( i==1) break lab1 ; System.out.println (2);}
System.out.println (3); // affiche : 3

int nb;
while(true) {
nb = clavier . nextInt ();
if (nb>0) break;
System.out.println( "Mauvais nb. Recommencer.");
}
1 ère Informatique

b)Continue :

= permet une nouvelle itération d’une boucle

 Grammaire :

- Si pas d’étiquette ! Recommence la première instruction répétitive englobante

- Si étiquette ! Recommence la boucle étiquetée

Ex :
for ( int i=0; i<10; i++) {
if ( i%2==0) continue;
System.out.println( i );
}

bcli : for ( int i=0; i<10; i++) {

bclj : for ( int j=0; j<10; j++) {
if ( ( i_j)%2==0 ) continue bcli;
System.out.println( j );
}
System.out.println( i );
}

4] Catch :

= est une partie du « try-catch »surveille les instructions et permet d’attraper les exceptions
renvoyé par un bout de code

 Le « catch » attrape une certaine exception et contient la gestion (le traitement) de

l’exception !!!
(On peut avoir un ou plusieurs catch, cela dépend du nombre d’exceptions a attraper)
Ex :
try {
nb = Integer .parseInt(chaîne);
} catch (NumberFormatException ex) {
// gestion de l ’exception
}

Une exception est un objet qui est créé et lancé quand le problème apparaît
 « Attraper une exception » c’est attraper un objet que l’on pourra manipuler

Remarque :
- on peut mettre en œuvre le polymorphisme avec les exceptions attrapées lors du catchµ

-Si par contre on désire que l'exception soit traité par les blocs de niveaux supérieurs, il suffit
d'inclure à la fin de la série d'instructions contenues dans le bloc catch{} une clause throw, suivie du
type de l'exception entre parenthèse puis du nom de l'exception (son handle pour utiliser un terme
exact). Ainsi l'exception continuera son chemin...
1 ère Informatique

5] Constructeur :

= est une méthode particulière d’une classe qui permet d’initialiser un Objet

- Le rôle d’un constructeur : est de déclarer et de permettre d'initialiser les données membres de la
classe, ainsi que de permettre différentes actions (définies par le
concepteur de la classe) lors de l'instanciation.

- Remarques :
 Il existe un constructeur par défaut
 Retourne la référence de l’objet
 N’a pas de type de retour
 A le même nom que celui de la classe

Ex : « Constructeur Etudiant »
public Etudiant ( int unNuméro, String unNom) {
numéro = unNuméro;
nom = unNom;
annéeEtude = 1;
doubleur = false;
ancien = false;
}

- A propos des Tests dans le constructeur :

Un constructeur peut effectuer des tests de validité sur les paramètres
→ On est sûr que l’objet est créé dans un état valide.

SI les paramètres ne sont pas valides  Lancé une exception !!!! (Throw new ….)

6] Conversions :

Les groupes (sortes) de conversions :

- Elargissante de type primitif
1 ère Informatique

- Arrondissante de type primitif

- Elargissante de type référence

- Arrondissante de type référence
- Conversion de chaîne de caractères (Tout peut être converti en String)
- Conversion identique (pour faciliter les règles)
- Boxing

- Unboxing (réalise l’inverse de Boxing)

Les 5 contextes de conversions :

- La promotion numérique :
1 ère Informatique

- L’assignation :

- Le casting :

- La chaîne de caractères
1 ère Informatique

- L’appel de méthode :
1 ère Informatique

7] Encapsulation :
=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.

 En pratique, cela sert à contrôler ce qu'une classe expose aux autres. Une bonne pratique
consiste à n'exposer que le strict minimum nécessaire, pour des raisons de maintenabilité et de
découplage des classes.

C’est pourquoi, on utilise les mots clé : public, private, protected, package, selon ce que l’on
souhaite. (Voir « Visibilité » !!!!)

Du plus visible au moins visible on a :

- public (mot-clé : public)

- protected (mot-clé : protected)
- package (pas de mot-clé)
- private (mot-clé : private)

On déclarera généralement les attributs PRIVES accompagnés de méthodes PUBLIQUES.

8] Enum :
=Mot clé de java qui permet de déclarer une énumération. Une énumération représente un type
énuméré, c'est à dire un type qui n'accepte qu'un ensemble fini d'éléments. Toutefois, une
énumération reste une classe Java, elle accepte donc des méthodes et des constructeurs.

Une énumération ne peut en aucun cas prendre une autre valeur que celle définie dans sa
déclaration, c'est pourquoi on ne peut ni construire de nouvelle instance, ni hériter d'une
énumération...

On pourra créer par exemple :

Une énumération PointCardinaux qui aurait comme attributs : NORD SUD OUEST EST.
Public enum PointCardinaux {
NORD SUD OUEST EST
}
Un constructeur sui cree un joueur d’apres un des valeurs de l’enum :
Public Joueur {
Joueur = new Humain (PointCardinaux.SUD) ;
}

Une énumération Saison qui reprend toutes les saisons

Public enum Saison {
PRINTEMPS , HIVER , AUTOMNE , ÉTÉ
}
1 ère Informatique

9] Equals :

=est une méthode de la classe Object qui la classe « mère » de toutes les classes. . Cette méthode
permet de comparer la valeur de deux instances. Par défaut, l'implémentation retourne true si le
paramètre est égal à this (objet courant).

Comme nous pouvons écrire des milliers de classes différentes, il nous faut la redéfinir. Par exemple,
si l’on créer une Classe Adresse. La réécriture de la méthode equals est nécessaire car elle n’est pas
implémentée de la même manière que pour une Classe CoursALEsi.

Remarque :

- Nous pouvons utiliser l'opérateur == pour comparer les valeurs de variables primitives et
déterminer si ils sont égales. Cependant, si c'est les instances qui sont comparées, l'opérateur ==
vous retournera false.

Pour vérifier l'égalité de deux instances, la classe Object vous fournit la méthode equals.

Ex :
String s1 = "abc";
String s2 = new String("abc");
if (s1 == s2) // retourne false
System.out.println("Egale");
if (s1.equals(s2)) // retourne true
System.out.println("Egale"); // affiche "Egale"

10] Extends :
=Mot clé de java qui définit qu’une classe hérite d’une autre.

Une classe Enfant hérite d’une classe Parent  Enfant extends Parent.

La classe enfant qui hérite, récupère les attributs et les méthodes de la classe Parents.

Ex :

Une classe Pion. Un point est définit par une valeur de x et de y dans un plan. Nous pouvons choisir
que certains pions ont aussi une couleur. Nous ferons : public class PionColore extends Pion. La classe
PionColoré ne nécessite pas de redéfinir les attributs x et y. On se contente de l’attribut couleur car x
et y sont herité .Idem pour certaines méthodes.

Public class Pion {

private int x ;
private int y ;
}
Public class PionColore extends Pion {
Private String couleur ; // x et y sont 2 attributs hérité que Pion colore possède
}
1 ère Informatique

11] Final :
=Mot clé permettant de designer un attribut comme une constante. La première valeur qui lui sera
initialisé ne pourra plus être modifiée par une méthode. On l’initialise généralement a sa
déclaration sauf si elle dépend d’un facteur extérieur ( choix de l’utilisateur,…).

On l’écrira, par convention, en MAJUSCULE.

Pq utilisé une constante ?

Cela permet d'affecter une valeur différente à chaque exécution du programme, tout en
garantissant que la variable, une fois initialisée avec une valeur, ne subira plus aucune
modification.

Ex :
final int Variable = 12;

final class :
une classe qui ne peut être hérité , ni avoir de classe parent
1 ère Informatique

12] For :
L'instruction for permet d'exécuter plusieurs fois la même série d'instructions: (boucle)

Dans sa syntaxe, il suffit de préciser le nom de la variable qui sert de compteur (et éventuellement sa
valeur de départ, la condition sur la variable pour laquelle la boucle s'arrête et enfin une instruction
qui incrémente (ou décrémente) le compteur.

for ( int i=début; i<=fin; i=i+pas ) {

instructions

Grammaire :

ForStatement :

BasicForStatement

EnhancedForStatement

BasicForStatement :

for ( ForInit(opt) ; Expression(opt) ; ForUpdate(opt) )

Statement

EnhancedForStatement :

for ( Type Identifier : Expression ) Statement

ForInit :

StatementExpressionList

LocalVariableDeclaration

ForUpdate :

StatementExpressionList

StatementExpressionList :

StatementExpression

StatementExpressionList , StatementExpression
1 ère Informatique

Ordre d’exécution:

1. l’initialisation : ForInit

2. l’évaluation du test : Expression

3. si le test vaut true alors

(a) le corps : Statement

(b) l’incrémentation : ForUpdate

(c) retour à l’étape 2

4. sinon, on passe à l’instruction suivant le for

Toute boucle for peut s’écrire avec une boucle while :

ForInit

while(Expression) {

Statement

ForUpdate

Exemple d’une boucle for infini :

for (;;) System.out.println( "Je ne me fatigue pas !");

1 ère Informatique

13] Foreach :

Le foreach est une technique (écriture simplifier du for) qui permet de parcourir tout ce qui est
itérable (list, tableau, map, …). Cela est possible que depuis la version 1.5 de java.

Attention ! On a accès aux éléments mais pas à l’indice. Il est aussi impossible de modifier les valeurs
(on ne peut que lire la valeur).

for (String mot : dictionnaire ){

System.out.println(mot);

Pour une arrayList :

ArrayList<Element> elements = new ArrayList<Element>();

...

for( Element element : elements) {

System.out.println( element );

Pour une matrice 2*2 :

public static void afficher ( int [][] mat ) {

for( int [] ligne : mat ) {

for( int val : ligne ) {

System.out.println( val + " " );

System.out.println ();

La variable mot prendra une valeur qui est contenue dans le dictionnaire à chaque itération et cela
jusque tout le dictionnaire à été parcourue.
1 ère Informatique

Pour une collection :

public void afficher ( Set<Integer> set ) {

for( Integer val : set ) {

System.out.println( val );

Rappel ! L’ordre dans le quelle les valeurs sera affiché va dépendre de l’implémentation.

Pour un simple affichage, on peut utiliser le toString () de la colection

Grammaire :

ForStatement :

BasicForStatement

EnhancedForStatement

EnhancedForStatement :

for ( Type Identifier : Expression ) Statement

1 ère Informatique

14] I/O :
L’entrée-sortie peut-être de type :

⊲ binaire (byte) ou texte (char)

⊲ séquentiel, direct, . . .

On peut y accéder en lecture, écriture, lecture/écriture, . . .

On peut l’envisager à partir de / vers un fichier mais aussi d’un tableau en mémoire, socket, autre
application.

Les différent flux sont :

- Flux standard
- Flux binaire
- Flux de caractére (texte)
- Flux englobant
- Flux formaté
- Flux de type primitif

Lecture dans un fichier binaire :

Le fichier est vu comme une suite de bytes.

L’ouverture d’un fichier se faire lors de l’instance d’un objet.

Il y a pas de méthode EOF mais un -1 si on est à la fin du fichier.

Pourquoi lit-on un "int" si on est intéressé par un "byte" (ou un "char") uniquement ?

Lors de d’une lecture on fait apelle à la méthode read de la classe InputStream qui retroune la valeur
d’un byte mais sous la forme d’un entier dans l'intervalle 0 à 255. Ce qui correspond bien à un byte les
bits de point fort (24 bits de gauche) sont donc supprimer.

On renvois un INT a cause du -1 car si on prend un byte signer on peut avoir des nombres de -128 à
127 et qu’une valeur d’un byte est entre 0-255.  conversion implicite : on ne prend direct un INT.

Exemple :

InputStream file = new FileInputStream("data");

int b;

b=file .read(); // lit un byte

while (b!=−1) {

System.out.print(b+" ");

b=file .read();

file .close ();

1 ère Informatique

Il est important de ne pas oublier de fermer les fichiers une fois qu’on la plus besoin.

Un finally ne fonctionne pas car une fermeture peut générer aussi des exceptions

Voici comment bien le faire :

InputStream file = null ;

try {

file = new FileInputStream("data");

// la suite sans close()

} catch (IOException ex) {

System.out.println( "Problème de lecture du fichier");

} finally {

if ( file != null) {

try {

file .close ();

} catch (IOException ex) {

// Impossible de fermer le fichier

Gestion des erreurs :

Quand on utilise des entrées/sorties de nombreux erreur peut surgir pour palier à cela, on utilise des
exceptions contrôlé de la classe IOException (qui hérite aussi de Exception).

Exemple de classe qui hérite d’IOExeption : FileNotFoundException.

Comme dit plus haut ces exeption sont contrôlé, on est donc obliger de les attraper (try and catch)
ou de les renvoyer à la classe qui l’appel (throws dans la signiature).

Il faut aussi bien faire attention à l’ordre dans le quelle on plus les catchs car si on cach
« IOException » et apres « FileNotFoundException » cela ne servira à rien car IOException englobe
tout les sous exception.
1 ère Informatique

Ecriture dans un fichier binaire :

Le fichier est créer lors de l’instanciation d’un objet et remplace sont contenue sur le fichier existe.

Seul l’octet de poids faible est écrit. Mais pq la méthode write de outPutStream reçois un INT allez
vous me dire. Et bien tout simplement les 24bits de point fort seront pas traiter (on en fait rien). On
prendra juste les 8 derniers bits.

Il y a pas de de FileNotFoundException vue qu’on le crée.

Exemple d’une copie d’un fichier :

public static void copier( InputStream in, OutputStream out) throws IOException {

int b;

while((b = in .read()) != −1) {

out.write(b);

// On devrait gérer la fermerture en cas de problème.

in .close ();

out.close ();

Le mode caractère :

Comme vous l’avez surement comprit dans ce mode la valeur de l’échange est le caractère et non le
byte comme vu plus haut.

Comme pour le binaire a l’écriture, seuls les 2 octects de poids faible sont écrits et à la lecture seul
les poids faible serrât envoyé dans le INT.

On utilise plus outPutStream et InPutStream mais reader et Writer qui on les même méthodes de
base (read,close,writh).
1 ère Informatique

Copie d’un fichier en mode caractère :

public static void copier( Reader in, Writer out) throws IOException {

int c;

while((c = in .read()) != −1) {

out.write(c);

// On devrait gérer la fermeture en cas de problème.

in .close ();

out.close ();

Généralisation :

Ce mécanisme d’I/O peut être généralisé à tout ce qui peut être vu comme un stream (flot/flux)
c'est-à-dire fichier, mémoire, socket, application, . . .

Tout se base sur les 4 classes abstraites suivantes :

Lecture Ecriture

Texte Reader Writer

Binaire InputStream OutputStream

◮ Les flux en lecture/écriture sont à part

◮ Idem pour les accès non séquentiels

1 ère Informatique

Exemple avec la lecture d’une chaine (forme générale) :

public void lecture(Reader in) throws IOException {

int c;

while((c = in .read()) != −1) {

System.out.print( (char) c );

in .close ();

Appelée avec un FileReader en situation réelle.

Flux englobant :

Un flux englobant se place autour d’un flux existant

En modifient le comportement

Cela permet de faire de la bufferisation, compression, concaténation, . . .

readLine permet de lire le retour de ligne mais ne le retourne pas et retourne null quand il n’y a plus
rien

Exemple d’un flux englobant ligne par ligne :

Reader sr = new StringReader("Un\nDeux");

BufferedReader in = new BufferedReader(sr);

String s = null ;

while((s = in .readLine()) != null) {

System.out.println( s );

in .close ();
1 ère Informatique

Le format est indépendant de la machine.

Exemple de flux sur un type primitif :

DataOutputStream out = new DataOutputStream(

new FileOutputStream("result.dat"));

out. writeInt (10);

out.writeDouble(1.2);

out.close ();

Les flux formaté permettent une grande liberté de format pour les entrées/sorties c'est-à-dire qu’on
peut définir complètement une sortie écran (exemple centrer un texte à l’écran(printf)).

Utilisation de la classe scaner (scaner,nextIn,…) et de la classe printStream (print, pritf, prinln,...)

Exemple :

PrintWriter out = new PrintWriter(

new FileOutputStream("result.dat"));

out. println (10);

out. print ( "Hello" );

out.close ();
1 ère Informatique

Sortie standard :

Certains flux sont prédéfinis dans la classe System (in, ou, err sont des flux) :

Utilisation courant : System.out.println(unObject);

Systeme classe

Out  atribut de la classe

Println Methode de out

15] I++ :
i++ est un raccourci pour i=i+1 ou de i+=1 (ici si 5+=2  7)

++i : i est incrémenté avant d’être utilisée

i++ : i est incrémenté après avoir été utilisée

16] if :
Si est un keyword du langage java qui permet de définir une condition.

Gramaire :

if ( condition ) {

instructions

La condition peut être suivi par une instruction, pas forcément un bloc

L’Expression doit être un type booléen

Le Si-sinon

if ( condition ) {

instructions

} else {

instructions

}
1 ère Informatique

Exemple :

if (nombre1 < 0) {

System.out.println( "négatif " );

} else {

System.out.println( " positif " );

Un if permet aussi de générer une exception :

if (condErreur) throw new Exception (" justification " );

17] Implements :

Une classe peut implémenter une interface (classe qui ne contient que les entêtes) ou une classe
abstraite (qui contient des méthodes déjà codé). Une classe abstraite est vue comme une interface.

Le token implements j’utilise comme pour l’héritage (extends) sauf qu’ici la classe qui implémente
une interface devra contenir / partager les méthodes de l’interface.

Exemple si dans l’interface calcul il y a les entête suivant :

Public int addition (int val1, int val2) ;

Public int division (int val1, int val2) ;

Public int multiplication (int val1, int val2) ;

La classe qui implémente calcule est obliger de les avoir comme méthode.

Exemple :

public class Poule implements Comparable<Poule> {

private int taille ;

public int compareTo(Poule p) {

return this. taille − p. taille ;

...

Toute classe qui implemente la classe Comparable dois contenire la methode compareTo.
1 ère Informatique

18] Import :

Un import permet d’importer une ou un ensemble de classe d’un autre package qu’on aimerait
utiliser dans notre classe.

Exemple : import java. util .∗;

Ce qui à pour effet d’importer dans les classe qui se trouve dans le package util.

Import les plus courant : import java. util .Scanner;

Il est possible de faire des import static qui va créer un raccourci pour l’accès aux membres statiques.

Exemple :

import static java.lang.Math.log;

import static java.lang.Math.E;

public class Test {

public static void main( String [] args ) {

System.out.println( log(E) );

}
1 ère Informatique

19] InstanceOf :

L’opérateur booléen instanceof permet de tester le type d’une instance d’un objet

À l’exécution, un objet est capable de donnerson type :

unObjetQuelconque.getClass();

unObjetQuelconque.getClass().getName();

Cela redonne le type réel de l’objet (pas le type déclaré !)

Grammaire d’instanceof :

RelationalExpression instanceof ReferenceType

RelationalExpression est un type référence

ReferenceType est un type référence

Retourne vrai lorsque le type de la référence peut être « casté » dans le type de référence

 null instanceof XXX est toujours faux

Exemple :

public class Brol {

public boolean equals(Object o) {

if ( ! (o instanceof Brol) ) return false;

Brol autre = (Brol) o;

return true

}
1 ère Informatique

20] Instruction-expression :

L’assignation est une expression

 qui peut devenir une instruction

 par ajout d’un ;

 la valeur est perdue

Grammaire :

Statement : ExpressionStatement :

ExpressionStatement StatementExpression ;

(...)

StatementExpression :

Assignment

(...)

Autres expressions instructions :

StatementExpression :

Assignment

PreIncrementExpression

PreDecrementExpression

PostIncrementExpression

PostDecrementExpression

MethodInvocation

ClassInstanceCreationExpression

Une assignation est d’abord une expression

⊲ Son type : le type de la variable

⊲ Sa valeur : la valeur du left hand side

Une assignation deviens une expresion par l’ajout d’un ;

Peut donc intervenir comme élément d’une autre expression

Priorité faible et associative de droite à gauche

1 ère Informatique

Exemple :

i = j = k = l = 0;

i = ( j = i+j ) + 1;

f ( i=1,j=0);

while( ( i=i−1) != 0 ) {...}

while( ok=true ) {...} // boucle infinie !

Grammaire d’une assignation :

Assignment :

LeftHandSide = Expression

LeftHandSide :

Identifier

ArrayAccess

FieldAccess

Il existe d’autre opérateur d’assignation comme le *=, -=

Assignment :

LeftHandSide AssignmentOperator Expression

AssignmentOperator : one of = *= /= %= += -=
1 ère Informatique

Priorité des assignations :

De la plus grande à la plus petite et Associativité de gauche à droite sauf pour les assignations.

postfixes unaires (params), ., expr++, expr−−

préfixes unaires ++expr, −−expr, −, +, !

création new

multiplicatif ∗, /, %

additif −, +

relationnels <, >, <=, >=

égalité ==, !=

et &&

ou ||

assignations =, +=, −=, ∗=, /=, %=

L’appel des méthodes est aussi une expression-instruction tout comme une instanciation.

new Personne ("Dupont", "Damien"); et element.getNom(); sont tout 2 valable sauf que les valeur
sont perdue.
1 ère Informatique

L’instruction :

Une instruction peut être une :

◮ L’instruction vide : ;

◮ Le bloc

◮ L’instruction if , if-else

◮ L’instruction switch

◮ L’instruction for

◮ L’instruction while

◮ L’instruction do-while

◮ L’instruction étiquetée (label) : Break, continue

◮ L’instruction break

◮ L’instruction continue

Exemple :

if ( i%2==0) continue;

System.out.println( i );
1 ère Informatique

21] Iterator :

Toute classe Iterable qui est une collection peut être parcourue avec un foreach, C’est pour cela
qu’on peut itérer sur une liste. Le parcoure peut se faire en avançant ou en reculant, en remplaçant
les valeurs, modifier les valeurs…

Rem. : un foreach est plus rapide qu’une boucle avec indice (un foreach ne fait que lire).

public class Poulailler implements Iterable<Poule> {

private List<Poule> poules ;

public Iterator <Poule> iterator () {

return poules. iterator () ;

...

On pourra donc utiliser la méthode :

Poulailler poulailler = ...

for( Poule poule : poulailler )

System.out.println(poule);

En résumer un Iterator est un objet permettant de parcourir "quelque chose" et est est muni des
méthodes hasNext(), next(),previous(). Il est Utilisé implicitement par le foreach.

Si un objet implémente l’interface Iterable<E> alors on sait qu’il offre une méthode iterator () qui
donne un Iterator <E>
1 ère Informatique

La classe iterator possède également une méthode remove()

Exemple :

public void enleverImpairs(Collection<Integer> liste) {

Iterator <Integer> it = liste . iterator ();

while( it .hasNext() ) {

int val = it .next ();

if (val%2!=0) it .remove();

Certains objets peuvent fournir un ListIterator qui est plus intelligeant et peut Il peut montrer le
suivant (next()) et le précédent (previous()).

Les listes et les piles peuvent fournir un itérateur de liste.

22] List :

La classe list hérite de l’interface collection. Les listes permettent de regrouper les données, d’y
accéder librement et elles sont ordonnées (il y a un ième élément).

Une liste est une séquence d’éléments (ordonnés mais pas nécessairement triés) auxquels on accède
librement.

Création d’une liste de poule :

List<Poule> al = new ArrayList<Poule>() ;

1 ère Informatique

Les méthodes principales sont :

◮ add, ajout

◮ remove, suppression,

◮ get, accès à la position i,

◮ contains, test d’appartenance

◮ isEmpty, liste vide

◮ size, taille

La classe ArrayList est munie d’une méthode toString.

Suppression d’un élément :

◮ Supprime l’élément à l’index i,

dictionnaire .remove(i). Élement supprimé en retour.

◮ Supprime la première occurence d’un objet :

dictionnaire .remove("zèbre"). Valeur booléenne en retour.

◮ Vérifie si un objet appartient à la liste :

dictionnaire .contains("remplacé")

Il existe aussi :

max(List), permet d’obtenir le maximum d’une List

sort ( List ), reverse(List ) et shuffle ( List ),permettent respectivement de trier, renverser, et mélanger
une List

2 types de liste :

ArrayList et LinkedList

Pour rendre le code le plus modulable on écrira :

List<Integer> liste = new ArrayList<Integer>();

Ici List peut être une ArrayList ou une LinkedList.

Il est possible d’utiliser une pile grâce au liste c’est le rôle de ListStack
1 ère Informatique

23] Map :

= (Une Map (anglais), Dictionnaire ou encore table) est une collection qui associe une clé à
une valeur.

Les clés  unique et permette d’accéder aux valeurs

Les valeurs  peuvent apparaitre plusieurs fois pour des clés différentes
Ex:

Constante (String) – valeur (double)

Pi 3,1416
e 2,7183

- « Map » est l’interface de base (Classe qui contient le nom des méthodes qui sont écrite
différemment en fonction de l’implémentation choisie).

Les 3 implémentations sont : (Les collections de type « Map »)

HashMap | LinkedHashMap | TreeMap

Table de hachage | Table de hachage | Arbre

Plus rapide | garde l’ordre d’insertion | ordre normal

Pas d’ordre | un peu plus lent | encore plus lent

MAP

Hashmap LinkedHashMap TreeMap

Ex :

import java. util .Map;

import java. util .HashMap;

public class TestHashMap {

public static void main ( String [] args ) {

Map<String,Double> map; //dictionnaire String ( nom de la constante ) , Double ( valeur )

map = new HashMap<String,Double>(); //Polymorphisme ( déclaration classe parent instancier en classe enfant )

map.put( "Pi", 3.14 );

map.put( "e", 2.71 );

System.out.println( "Mon dictionnaire: " + map);

} // end − main

} //
1 ère Informatique

24] Méthode :

= est une boîte noire :

 On lui fournit 0/1/des donnée(s),

 Elle renvoie 0/1 résultat.

Pour l’appeler, on donne :

 Son nom,
 Les éventuelles données nécessaires (les paramètres)
 A précéder du nom de la classe si dans une classe différente.

Pour définir une méthode, on donne :

 Son nom,
 La liste des données (paramètres),
 Le type de la valeur retournée,
 Le code de la méthode,
 La valeur de retour est donnée par l’instruction RETURN,
 Si pas de valeur de retour, on écrit « void » dans l’entête de la méthode,
 Il existe aussi des méthodes sans paramètres.

 Exemple 1 :
public static void main(String []args){
//code

|Cette méthode ne retourne rien et reçoit en paramètre un tableau de chaine

(arguments).

 Exemple 2 :
public int getNb () {
return nb ;

|Cette méthode ne reçoit rien en paramètre et retourne nb qui est de type int.

Une méthode d’objet (d’instance) :

 Connaît l’état de l’objet,

 Peut le modifier.

Une méthode peut être :

 Public,
 Protected,
 Private,
 Statique ou non statique.
1 ère Informatique

25] New :

= Pour instancier une classe, c'est-à-dire créer un objet à partir d'une classe, il s'agit d'utiliser
l'opérateur « new ».
En réalité l'opérateur « new », lorsqu'il est utilisé, fait appel à une méthode spéciale de la classe: le
constructeur.

Ex :

Rectangle rect1

rect1 |

Cette déclaration crée une case mémoire nommée rect1, destinée à contenir une référence vers
l’adresse où sont stockées les informations concernant le rectangle rect1. Á ce stade, aucune adresse
n’est encore déterminée. Les informations caractérisant le rectangle rect1 ne peuvent être stocké car
l’espace mémoire servant à ce stockage n’est pas encore réservé. C’est la que le new intervient.

C’est lui qui réalise cette réservation. Lorsqu’on applique l’opérateur new à un objet il détermine
combien d’octet lui sont nécessaire pour stocké l’information contenue dans la classe.

Dans notre exemple la réservation de l’espace mémoire pour l’objet rect1

rect1 = new Rectangle() ;

Il est aussi possible de déclaré et réservé l’espace mémoire en une fois.

Ex :

Rectangle rect1 = new Rectangle() ;

Pour chaque objet déclaré l’opérateur new réserve suffisamment d’espace mémoire pour stocké les
données de la classe et pour copier ces méthodes associée. Il détermine aussi l’adresse ou sera
stocké l’ensemble de ces informations.

Lors de cette réservation l’interpréteur initialise les données de la classe à 0 pour les entier à 0.0
pour les réels et à Null pour les Object ( String compris )
1 ère Informatique

26] Object :

= Toute classe créer hérite au minimum de la classe Object (héritage implicite),

La classe Object est donc la racine de l’arbre et toute classe possède donc au minimum les
méthodes de la classe Object.

Les méthodes de Object les plus utilisé sont :

a) ToString()

Representation textuelle de l’état de l’objet

b) Boolean equals(Object o)

Permet de comparé 2 objets

c) Class getClass()

Donne la classe de l’objet (car à la compilation on ne peut pas connaître le type

reel d’un objet).

Etc…

Remarque :

- Lors de la création d’une classe on peu tout simplement redéfinir ces méthodes pour
qu’elle se comporte comme on le désire sans cependant changer l’entête de la méthode ni
le type de retour (principe de l’héritage).

27] Package :

= Un package Java est un ensemble de classes qui sont regroupées d’après une certaine logique.
Ce regroupement permet d'organiser des classes Java avec le même nom, par exemple.

a) L’utilisation du « package »

Pour utiliser un paquet dans votre code source Java, vous devez importer l'emballage ou utiliser
le nom de classe entièrement qualifié à chaque fois que vous utilisez une classe. Ca doit être la
première instruction du fichier et les identificateurs doivent être séparer par des point.

Ex :

Concrètement si je crée une classe Test et que mon package est « package
g32322.java.exemple »

Le fichier Test.class doit se trouver dans

/« valeur du CLASSPATH doit mener jusque la »/g32322/java/exemple

 Le package détermine donc ou le bytecode est chercher.

1 ère Informatique

b) Utilisation des noms de classe entièrement qualifié

Cet exemple utilise la classe de munitions en balistique de l'emballage:

ballistics.Ammunition caliber = new ballistics.Ammunition();

Comme vous pouvez l'imaginer, en utilisant le nom de classe entièrement qualifié peut devenir
un peu ennuyeux.

c) Importation de classes

= permet d’accéder aux classes d'un package à partir d'une classe ne faisant pas partie du
package
Ex :
package import java.util.*; // Import all public classes from the java.util package
import java.util.ArrayList; // Import the ArrayList class from the java.util

28] Polymorphisme:

=C’est le fait qu’une variable parent peut contenir un type enfant!

ClasseParent c = new ClasseEnfant() ;

 L’objet peut dont être vu et utilisé comme si il état de type parent. (en enfant contient
tout des parents (héritage))

 La méthode à appelé elle par contre est déterminée à l’exécution en fonction du type
réel de l’objet ca peut être une méthode hérité ou une méthode redéfinie. (Édition de
lien)
 le compilateur prend toujours la methode la plus porche(enfant)
 Le compilateur prend en compte que les methode déclaré
 Si on demande à la classe chien (enfant) s’il est un animal (parent) il dira oui
(getClasse())
Ex :
public class ClasseParent {
public void un() {...}
public void deux() {...}
}
public class ClasseEnfant extends ClasseParent {
public void deux() {...}
public void trois () {...}
}

On peut donc écrire :

ClasseParent c = new ClasseEnfant() ;
Le Castings :
Si on ecrit ((parent)c).deux()  on appel la methode deux du parent
Si on ecrit ((enfant)c).trois  ok
1 ère Informatique

29] Scanner :

= est une classe à part entière dont l’une des fonctions les plus utilisé est la lecture de donnée sur
l’entrée standard.

Pour utilisé la classe Scanner, on doit spécifier ou elle se trouve (on spécifie sont package « import
java.util.Scanner ; »).

Mais cette classe est beaucoup plus large.

La classe permet de parser une chaine de caractères ( l’a décomposé).

Les sources peuvent être diverse (stdin,String,fichier…). Le séparateur est l’espace.

Ex :

Scanner clavier = new Scanner(System.in); //déclaration

Scanner uneEntrée = new Scanner ("3 14 15 92 65"); // lecture sur base d’un String
Scanner uneAutreEntrée = new Scanner (new File ("monfichier" ));//sur base d’un fichier

Á la création on est au début et chaque next lit un « token ».

Si on écrit « nextType » ca converti la chaine en type selon le type.

Reprenons l’exemple précédant

Scanner clavier = new Scanner(System.in); //déclaration

Scanner uneEntrée = new Scanner("3 14 15 92 65"); // lecture sur base d’un String
int n = uneEntrée.nextInt (); //lit jusqu’au separateur donc lit 3 et le converti de String en int.

N est initialisé à 3 etc….

On peut aussi demandé de lire un type bien précis et lancer une exception si ce n’est pas le cas.
Ex lire un entier au clavier :

Scanner uneEntrée = new Scanner(System.in) ; //lecture clavier

int n = 0;
try {
n = uneEntrée.nextInt ();
} catch (InputMismatchException ex) {
uneEntrée.next(); // Nécessaire !
n = uneEntrée.nextInt ();
}

Dans ce cas si l’on rentre une lettre ou quelque chose différente d’un entier on lancera une exception
de type InputMismatchException jusqu'à ce que l’on rentre le type demandé !

Avec la classe Scanner on peut aussi lire toute une ligne via la méthode « nextLine », lire un seul
caractère, etc….
On peut aussi imposer de rentré certain quelque chose d’un certain type et on vérifie via les pattern.
Ex lire le login d’un étudiant s’écrira

String s = clavier .next (" [gG]\\d{5}" );

Et lancer une exception si ce n’est pas le cas.

1 ère Informatique

30] Serializable :

= est une interface qui permet de sérialisé les objets c.à.d. de convertir l’objet en suite de bytes
pour pouvoir être transporté dans un flux de fichier entrant ou sortant. Ainsi cela permet de stocker
les objets dans un fichier et/ou de les reconstruire a l’identique !
Toutes Les classes qui l’implémentent autorisent la sérialisation !!

Exemple d’écriture d’objet:

FileOutputStream out = new FileOutputStream("theTime"); //nom du fichier de sauvegarde

ObjectOutputStream s = new ObjectOutputStream(out); //
s.writeObject("Today"); //ecriture d’une chaine
s.writeObject(new Date()); //écriture de l’object
s.close ();//fermeture
out.close ();

Lorsqu’on lit un objet il faut le casté car la lecture retourne un Object

Ex :

FileInputStream in = new FileInputStream("theTime");

ObjectInputStream s = new ObjectInputStream(in);
String today = (String)s.readObject();
Date date = (Date)s.readObject();
s.close ();
in .close ();
1 ère Informatique

31] Set :

= Interface qui définit un ensemble (unicité des éléments et non triés).

 Hérite de la classe Collection mais ne définit pas de nouvelles méthodes.

 Dans un ensemble il n’y a pas d’accès direct à un élément ; le seul parcours possible est via un
foreach.

 Plusieurs implémentations courantes :

HashSet LinkedHashSet TreeSet

Table de hachage Table de hachage Arbre

+ liste chaînée

Le + rapide Un peu plus lent Encore plus lent

Pas d’ordre Ordre d’insertion Ordre naturel

| Le choix est lié à la nécessité de trier les éléments.

ITERABLE

COLLECTION (INTERFACES)

(INTERFACE) (INTERFACE) (INTERFACE)

SET (ensemble) LIST(liste) QUEUE (File)

Hashset Treeset LinkedHashSet ArrayList LinkedList

 Pour un simple affichage, on peut utiliser le toString.

1 ère Informatique

Ex :

import java. util .Set;

import java. util .HashSet;

public class TestHashSet {

public static void main ( String [] args ) {
Set<Rectangle> rectangles = new HashSet<Rectangle>();
Rectangle r1 = new Rectangle(3,14);
Rectangle r2 = new Rectangle(2,71);

rectangles.add(r1);
rectangles.add(r2);
rectangles.add(r1);

System.out.println( "Mes rectangles," + rectangles);

} // end − main
} // end – class

32] Static:

=S’applique aux membres (attributs, méthodes)

Par défaut, les variables et les méthodes sont liées à l’objet, mais, si leur déclaration le précise, à
l’aide du mot clé « static », elles sont alors liées à la classe  on peut donc les utiliser sans avoir
une instance de classe.

Attributs statiques :

- Existe en un seul exemplaire initialisé lors du chargement de la classe.

- Utilisation courante : pour les constantes (final).

Méthodes statiques :

- Ne possèdent ni ne peuvent modifier les attributs de l’objet.

- Utilisation courante : pour les méthodes non objet (ex : public static int abs).

Appel :

- Si on est à l’extérieur de la classe, on préfixe par le nom de la classe (Ex : int abs =
Outils.abs(…)).
- Si on est à l’intérieur de la classe il est possible d’y faire appel en préfixant par l’objet de
la classe MAIS ceci est non recommandé.

Import static :

- Crée un raccourci pour l’accès aux membres statiques.

1 ère Informatique

Illustration par un exemple :

1. Avec « static » (propre à la classe) :

Le Board ; à chaque création du plateau de jeu, toujours 8col et 7lig (toujours le même
plateau de jeu créé).

2. Sans « static » (propre à l’objet) :

Le Rectangle ; L et l peuvent être différentes à chaque création, c’est propre a chaque
rectangle.

33] Super :
1 ère Informatique

34] Switch :

= se traduit par Selon (ou suivant). L’instruction Switch permet de faciliter la programmation, en
effet si les choix sont supérieur a 2 on aura beaucoup de if / else if / else. La syntaxe est plus
approprié (et plus courte) que le if / else if / else. Le Switch ne permet pas le Selon que avec
condition(s).

Syntaxe :
switch (valeur) {
case étiquette 1 :
// une ou plusieurs instructions
break;
case étiquette 2 :
// une ou plusieurs instructions
break;
case étiquette 3 :
// une ou plusieurs instructions
break;
default :
// une ou plusieurs instructions
}

Ex :
switch (jour) {
case 0 : System.out.println( "Lundi"); break;
case 1 : System.out.println( "Mardi"); break;
case 2 : System.out.println( "Mercredi"); break;
case 3 : System.out.println( "Jeudi" ); break;
case 4 : System.out.println( "Vendredi"); break;
case 5 : System.out.println( "Samedi"); break;
case 6 : System.out.println( "Dimanche"); break;
default : System.out.println( "Erreur" );
}

Les accolades sont obligatoires avec le Switch.

L’expression qui est évaluée (dans l’exemple : jour) ne peut être que de type : char, byte, short ou int.
Le Break est utilisé pour finir un a ou plusieurs case. S’il en termine plusieurs on dit que les case sont
associés.

switch(jour) {
case 0:
case 1:
case 2:
case 3:
case 4:
case 5: System.out.println("En semaine"); break;
case 6:
case 7: System.out.println("Week-End"); break;
default: System.out.println( "numéro de jour incorrect");
}

Le default n’est pas obligatoire mais s’il est utilisé, il ne peut être mis qu’une seule fois et de
préférence en fin.
1 ère Informatique

35] Tableau 1 dimension :

= permet de manipuler plusieurs variables de même type. On gère ces variable grâce a un indice (en
Java le premier indice est 0 le dernier étant TAILLE-1).
Lors de la déclaration il ne réserve que la place nécessaire à une référence (idem objets).

Déclaration : int [] t ;
Création: new int[TAILLE];
(TAILLE = un entier > 0)

> Combinaison des 2 : int [] t = new int[TAILLE];

Lors de la création les valeurs par défauts sont :

Numérique : 0
Booléen : false
Référence : null

Déclaration en donnant directement des valeurs :

int [] entiers = {4,5,6};

Cela reviens a écrire :

int [] entiers ;
entiers = new int[3] ;
entiers[0] = 4 :
entiers[1] = 5 :
entiers[2] = 6 :

36] Tableau 2 dim :

Le nombre de dimensions dépends du nombre de []

⊲ int [][] : tableau de tableaux d’entiers
⊲ int [][][] : tableau d’entiers de dimension 3
1 ère Informatique

37] This :

= sert à référencé l'objet en cours (c’est donc référence à soi-même). S’il y a une utilisation directe
de l’objet le « this » n’est pas obligatoire.

public Etudiant( String nom ) {

setNom( nom );
// implicitement : this .setNom( nom );
}

public void setNom( String unNom ) {

nom = unNom;
// implicitement : this.nom = nom;
}

Si la variable passée en paramètre a le même nom que l’attribut de la classe il faut utiliser le this:

public Joueur (NordSud nom) {

this.nom = nom;
}

Il permet aussi à l’objet de se passer en paramètre:

public void effectuer(Action coup) throws IllegalActionException {

coup.effectuer(this);
}

Il peut être utilisé pour une meilleure lisibilité du code.

38] Throw :

= permet de déclencher une exception.

39] Throws :

= permet a une méthode de lancer une exception contrôlée. Le throws doit apparaitre dans l’entête
de la méthodes.

void f () throws IOException {

...
if (...)
...
}

Quand on appelle une méthode qui peut lancer une exception contrôlée, on doit soit la gérer par
un « try-catch» soit déclarer qu’on la lance par un « throws » (on laisse passer l’exception).

void g() throws IOException {

...
f ();
...
}

Lorsque Throws est utilisé, l’exception se propage jusqu'à ce que le programme se termine,
l’interpréteur retourne alors en résultat la liste des méthodes traversée par l’exception.
1 ère Informatique

40] toString :

= méthode héritée de la classe Objet. Son rôle est de permettre la représentation d’un objet (une
instance) sous la forme d’une chaine de caractère (par défaut, donne le type et le hash code). Elle
est souvent utilisée pour le déverminage. Elle doit être déclarée publique car elle est publique dans
Objet. Toutes Object a sa propre méthode toString() qui doit être implémenté pour qu’elle affiche
l’objet en une chaine de caractères.

public Etudiant ( int unNuméro, String unNom) {

numéro = unNuméro;
nom = unNom;
annéeEtude = 1;
}

Etudiant ada = new Etudiant(33800, "Lovelace");

System.out.println(ada);
ada.aRéussi();
System.out.println(ada);

Affiche :
(Lovelace,33800,1)
(Lovelace,33800,2)

41] Try :

= partie du « try-catch » qui sert à englober la partie qui est susceptible de provoquer une erreur (le
catch permet lui de gérer l’erreur survenue dans la zone du try).

public Pion getPion(Position position) {

try {
return plateau[position.getLigne()][position.getColonne()];
} catch (Exception e) {
throw new IllegalArgumentException("Position invalide");
}
}

Dans l’exemple, si la position dans le plateau est incorrecte alors une erreur sera lancée et gérée par
le catch.

Une exception est un objet qui est créé et lancé quand le problème apparaît
 « Attraper une exception » c’est attraper un objet que l’on pourra manipuler
1 ère Informatique

42] Type primitive vs référence :

On distingue deux grandes familles de type :
Les types primitifs (entier,réel,booléen(logique))

Liste des types numériques entiers :

byte : -128 a 127 (8 bit)

short : -32768 a 32667 (16 bit)
int : -2147483648 à 2147483647 (32 bit)
long : -9223372036854775808 à 9223372036854775807 (32 bit)

La capacité des ces types est limité donc possibilité d’avoir un out of range. En java, on travaille par
défaut en base 10, mais il est possible de préciser que l’on veux soit travailler en base 8(précédé le
nombre d’un 0) soit en hexadecimal(précédé le nombre d’un 0x).
utilisation de int.On n’utilisera rarement des ‘byte’ et des ‘short’
Le suffixe l correspond a un int tandis que le L correspond à un long.
Le type char :
Ecrit en Unicode et correspondant a un entier non signé codé sur 16 bit(calcul possible). Un char est
souvent noté entre deux simples quotes.
Séquences d’échappements :
\n : linefeed \r : retour chariot
\t : tabulation \f : form feed
\b : backspace (a completer)

autre notation possible : \u0F40 = notation spécifique de l’unicode.

Liste des types numériques à virgule flottantes :

Double : codé sur 32 bit
Float : codé sur 64 bit
on remarque une capacité limité (out of range possible) et perte de précision. Exemple : 10-30 est
représentable mais (1 + 10-30 )-1 = 0

Noté en 4 partie :
partie entiere . partie décimale E exposant suffixe
Exemple : 1.2E3, 1f
Si absence de suffixe, on aura un double par défaut.

Le type booléen :
Il n’a que 2 valeurs possible(true/false)
Il n’est pas considéré commeun type numérique !

Pour tous ces types, l’allocation mémoire lors de l’assignation à une variable est directe. La mémoire
contient directement la valeur de la variable
Les types références (String, tableaux..)

Le type String :
1 ère Informatique

Correspond à une séquence de caractère.

Dans une chaine, si on utilise la notation d’une séquence d’echappement comme des caractères, il
faut la précédé d’un \ spécifique.
Exemple : « Coucou les amis \\n » est égal à Coucou les amis \n et non pas à Coucou les amis suivi
d’un line feed.

Pour un type référence l’allocation mémoire lors de l’assignation à une variable est référentielle. La
mémoire va contenir une adresse référence pointant vers une autre partie mémoire(là où est
réellement stocké l’objet).

43] Types primitives et conversions :

Voir question sur les conversions

44] Visibilité (public,…) :

= détermine dans quel contexte le membre qui le porte est accessible.

Rappel encapsulation :
= l'encapsulation consiste donc à définir des étiquettes pour les données membres
et les méthodes afin de préciser si celles-ci sont accessibles à partir d'autres classes
ou non...

 En pratique, cela sert à contrôler ce qu'une classe expose aux autres. Une bonne
pratique consiste à n'exposer que le strict minimum nécessaire, pour des raisons de
maintenabilité et de découplage des classes.

C’est pourquoi, on utilise les mots clé : public, private, protected, package, selon ce
que l’on souhaite.

Il existe 4 niveaux de visibilité : public, package, protected, private

- Public : Un membre public est visible dans toutes les classes.

C’est le niveau le plus visible. Les méthodes (quelque soit la classe) peut
accéder aux attributs ou méthodes déclarées publique.

- Package : Un membre « paqueté » (pas de mot clé), est visible dans toutes les classes
du package.

- Protected : Un membre protégé est accessible de sa classe, du package et de ses classes

Enfants. Niveau de visibilité juste après package. Les attributs protégés ne
sont accessibles que par la classe elle-même, du package et les classes
enfants.

- Private : Un membre privé n’est accessible que de sa classe.

C’est le niveau le moins visible. Les attributs déclarés priver ne sont
accessibles que par les méthodes de sa classe. Ces éléments ne peuvent être
manipulés qu'à l'aide de méthode spécifique appelée accesseur et mutateur.

+ Accesseur :
1 ère Informatique

= est une méthode permettant de récupérer le contenu d'une donnée

membre protégée. Un accesseur, pour accomplir sa fonction :
 doit avoir comme type de retour le type de la variable à renvoyer
 ne doit pas nécessairement posséder d'arguments
Une convention de nommage veut que l'on fasse commencer de façon
préférentielle le nom de l'accesseur par le préfixe get, afin de faire ressortir
sa fonction première.

Mutateur :
=est une méthode permettant de modifier le contenu d'une donnée membre
protégée. Un mutateur, pour accomplir sa fonction :
 doit avoir comme paramètre la valeur à assigner à la donnée
membre. Le paramètre doit donc être du type de la donnée membre
 ne doit pas nécessairement renvoyer de valeur (il possède dans sa
plus simple expression le type void)
Une convention de nommage veut que l'on fasse commencer de façon
préférentielle le nom du mutateur par le préfixe set.

Petit tableau récapitulatif :

sur un membre
private package protected public
accès depuis
la classe elle-même OUI OUI OUI OUI
sous-classe même package NON OUI OUI OUI
pas une sous-classe, même package NON OUI OUI OUI
une sous-classe d'un package différent NON NON OUI OUI
pas une sous-classe d'un package différent NON NON NON OUI