Cours 2

Notes de cours #2
Correction des exercices du 1ième cours.
1) Programmer un objet calculatrice qui reçoit deux chiffres demandés à l’usager et qui
retourne le résultat de l’addition. Utiliser la méthode Lire, ici bas.
CCalculatrice.java
public class CCalculatrice
{ public static void main (String Arg [] )
{
while (true)
{
char N1 = Lire();
char N2 = Lire();
Calcul C = new Calcul (N1, N2);
C.Calculer();
C.Afficher();
}
}
public static char Lire()
{
char Retour = 'j';
try
{
Retour = (char)System.in.read();
while ((char)System.in.read() != '\n');
}
catch (java.io.IOException e)
{ //Ca arrive jamais!!!
}
return Retour;
}
}

CCalcul.java
public class CCalcul
{
private int Nombre1;
private int Nombre2;
private int Resultat;
public CCalcul (char No1, char No2)
{
Nombre1 = (int)(No1-'0');
Nombre2 = (int)(No2-'0');
}
public void Calculer ()
{
Resultat = Nombre1 + Nombre2;
}
public void Afficher()
{
System.out.println ("La somme est " + Resultat);
}
public int retResultat() //Accesseur de Resultat
{
return Resultat;
}
}

2) Programmer un simulateur de chronomètre qui demande le temps à l’usager, puis qui
affiche un décompte jusqu’à 0 de ce temps.
 Utilisez la méthode currentTimeMillis() de l’objet System. Elle
retourne le nombre de milli-seconde depuis 1970.
CPetard.java
public class CPetard
{
public static void main (String Arg [] )
{
while (true)
{
char Temps = Lire();
CChrono Bombe = new CChrono(Temps);
Bombe.depart();
}
}
public static char Lire()
{
char Retour = 'j';
try
{
Retour = (char)System.in.read();
while ((char)System.in.read() != '\n');
}
catch (java.io.IOException e)
{
//Ca arrive jamais!!!
}
return Retour;
}
}
CChrono.java
class CChrono
{
private int Temps;
public CChrono(char T) { Temps = T-'0'; }
public void depart()
{
while (Temps > 0)
{
System.out.println (""+ Temps);
long T1 = System.currentTimeMillis();
while ((System.currentTimeMillis() - T1) <1000);
Temps--;
}
System.out.println ("Booom!!!");
}
}

L’encapsulation et la modularité
L’encapsulation consiste à mettre le plus de membres possibles privés dans une classe et
de ne laisser ainsi que quelques membres publics. En général et sans exception dans le
cadre du cours, les attributs non constants d’une classe sont privés. L’ensembles de ce
qui est privé dans un objet s’appelle le noyau. Ce qui est publique s’appelle l’interface
de l’objet ou de la classe.
La modularité est une visée qui donne un sens à l’encapsulation. On essaie de
regrouper les variables et leurs traitements en une classe et de séparer ceux-ci du reste.
L’idée est de créer un objet qui sera simple à utiliser et qui sera indépendant.
On peut, par exemple, créer une Pile d’entier. On se crée donc une classe « Pile »
qui empile ou dépile des entiers. On s’attend à avoir une utilisation de la classe qui
ressemble à la classe Imprimante que vous voyez ci-bas.
Exemple :
CImprimante.java
import java.util.Random;
/**
* Classe qui utilise la CPile pour faire un exemple en classe.
*/
class CImprimante
{
/**
* Petit "main" qui permet de verifier la classe CPile.
*/
public static void main (String Arg[])
{
Random Choix = new Random();
CPile PileImpression = new CPile();
PileImpression.empiler(10);
PileImpression.empiler(14);
PileImpression.empiler(20);
PileImpression.empiler(70);
PileImpression.empiler(211);
for (int x=0; x < 5; x++)
PileImpression.empiler ((Choix.nextInt())%100);
System.out.println (" ********** ");
while (!(PileImpression.Vide()))
PileImpression.depiler() ;
System.out.println();
}
}

Il faut programmer la classe « Pile » pour qu’elle réponde à nos besoins (utilisation), pour
qu’elle se comporte comme nous voulons. Voici une classe Pile faisant l’affaire, il en
existe une infinité d’autres.
CPile.java
public class CPile
{
private int PileEntier[];
private int SommetEntier;
private int Pas;
private void Allonger()
{
int Tamp[] = PileEntier;
PileEntier = new int[Tamp.length+Pas];
for (int x=0; x<Tamp.length; x++)
PileEntier[x] = Tamp[x];
for (int x=Tamp.length; x < PileEntier.length; x++)
PileEntier[x] =0;
}
public CPile()
{
this (10);
}
public CPile (int Taille)
{
PileEntier = new int[Taille];
SommetEntier = 0;
Pas = Taille;
}