Notes de cours #2
Correction des exercices du 1
ièmecours.
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;
public void empiler(int Nouv) {
PileEntier[SommetEntier] = Nouv;
SommetEntier++;
System.out.println ("Empiler: " + Nouv);
if (SommetEntier+1 > PileEntier.length) Allonger();
}
public int depiler() {
int Retour=0;
if (SommetEntier >0) {
SommetEntier--;
Retour = PileEntier[SommetEntier];
PileEntier[SommetEntier] = 0;
} else
Retour = -1;
System.out.println ("Depiler: " + Retour);
return Retour;
}
public boolean Vide () {
if (SommetEntier <= 0) return true;
else return false;
La notion d’héritage
L’héritage est un mécanisme de la programmation orienté objet qui consiste à bâtir une classe à partir d’une autre. Cette nouvelle classe possède toutes les caractéristiques de la classe parente. Les méthodes de la classe enfant peuvent affecter les membres publics et protégés de la classe parente, mais pas les membres privés.
C’est le mécanisme le plus puissant de la programmation orientée objet, en plus de permettre la réutilisation, il permet de modéliser et de généraliser la conception d’objets. En Java, pour faire de l’héritage, il suffit d’utiliser le mot « extends » dans la définition de la classe, suivit du nom de la classe parente. L’héritage est transitif, c’est à dire que si un objet hérite d’une classe qui hérite elle même d’une autre classe, la classe petit-enfant hérite de tous les membres de son père et de son grand-père.
CZoo.java
public class CZoo {
public static void main (String Arg[]) {
CChien Bob = new CChien ("Blanc");
CLevrier Lev = new CLevrier ();
CLevrier Lev2 = new CLevrier ("King");
CCaniche Boul = new CCaniche ();
Bob.Crie();
Lev.Crie();
Lev2.Crie();
Boul.Crie();
System.out.println ("******************************");
CMammifere Maturin[] = new CMammifere [4];
Maturin[0] = new CChat ();
Maturin[1] = new CChien ("Snoopy", 5);
Maturin[2] = new CLevrier ("P'tit rene au nez rouge");
Maturin[3] = new CCaniche ("Frimousse", 9);
for (int Annee = 0; Annee < 10; Annee ++) {
System.out.println ("**** Annee : " + Annee + " *********");
for (int y=0; y < 4; y++) Maturin[y].Vieilli();
} }
CMammifere.java
abstract public class CMammifere {
private int Age; // Age courante de l'animal
private int Max; // Age de la mort écrite dans les gènes
public CMammifere () {
this (0, 5);
}
public CMammifere (int Max) { this (0, Max); }
public CMammifere (int A, int M) {
Age = A;
Max = M;
}
public void Vieilli () {
Age ++;
if (Age == Max) Crie();
if (Age > Max) {
System.out.print ("Dejà " + (Age - Max) + " an");
if (Max-Age > 1)
System.out.print ("s");
System.out.println ();
} }
abstract public void Crie ();
}
CChat.java
public class CChat extends CMammifere {
CChat() { super (3); }
public void Crie() {
System.out.println ("Miaou!");
CChien.java
public class CChien extends CMammifere {
String Couleur;
public CChien() {
this ("Brun");
}
public CChien(String C) {
this (C,4);
}
public CChien (String C, int M) {
this (C,0,M);
}
public CChien (String C, int A, int M) {
super (A, M);
Couleur = C;
}
public void Crie () {
System.out.println ("Ouaf!");
}
CCaniche.java
public class CCaniche extends CChien {
private String Nom;
public CCaniche() { this ("Fido", 4);
}
public CCaniche(String C) { this (C, 4);
}
public CCaniche(String C, int M) { this("Fido",C,0,M);
}
public CCaniche(String N, String C, int A, int M) { super(C,A,M);
Nom = N;
}
public void Crie()
{ System.out.println ("Cui, Cui...");
} }
CLevrier.java
public class CLevrier extends CChien {
private String Nom;
public CLevrier() { this("Fido"); }
public CLevrier(String N) { Nom = N; }
public CLevrier(String C, int M) { this("Fido", C, 0, M); } public CLevrier(String N, String C, int A, int M)
{
super(C,A,M);
Nom = N;
}
public void Crie () {
System.out.println ("Win!!");
} }
