Université BenYoucef Benkhedda/FS/Dep MI S4, 2016-2017

Documents : interdits Examen : POO Durée : 1h30

Exercice 1 :

Un championnat de football est une suite de matchs de football, dans lesquels se confrontent plusieurs équipes sur plusieurs journées.
Chaque équipe joue plusieurs matchs contre plusieurs équipes. Les équipes cumulent des points dans un championnat selon les règles
suivantes :
• une équipe qui perd un match, cumule 0 point.
• une équipe qui gagne un match, cumule 3 points.
• un match nul (même nombre de buts dans pour les deux équipes) implique un cumul de 1 point pour les deux équipes.
A la fin de tous les matchs, L’équipe qui aura le nombre de point le plus élevé sera consacrée « équipe championne ».

Travail à faire :

On veut créer un programme pour le suivi d’un championnat de football, pour cela, on réalisera deux classes : MatchFoot et
Championnat

1. La classe MatchFoot modélise un match entre deux équipes A et B. Elle dispose des membres suivants :
• equipeA, equipeB de type chaine de caractères représentant les noms des deux équipes
• nbrButA, nbrButB, deux entiers qui représentent respectivement le nombre de buts de equipeA et equipeB
• un constructeur ayant comme paramètres deux chaines de caractères : le nom de l’équipe A et celui de l’équipe B.
• les méthodes getters nécessaires (pas de setter)
• La méthode marquerBut(String eq) : deux valeurs possibles pour eq : "A" pour rajouter un but pour EquipeA et "B" pour
rajouter un but EquipeB

2. La classe Championnat dispose des propriétés suivantes :

• tabMatchs : tableau d’objets de type MatchFoot
• nbrMatchs : le nombre de match dans tabMatchs
• tabEqPts : tableau de deux dimensions de type String qui contient dans chaque ligne, le nom d’une équipe et le nombre de
points de cette équipe dans le championnat, exemple :

Nom équipe Nombre de points

0 "Algérie" "4"
1 "France" "0"
2 "Brésil" "4"

La classe Championnat définie les méthodes suivantes :

• un constructeur sans paramètre qui initialise le tableau tabMatchs (40 matchs maximum), et tabEqPts (10 équipes maximum)
• une méthode void ajouterMatch(MatchFoot mf) : rajoute un objet match à tabMatchs, cette méthode doit gérer la taille
maximale du tableau tabMatchs
•
ère
une méthode void listeEquipes() : qui remplie la 1 colonne du tableau tabEqPts par les équipes participantes au
championnat sans répétition.
• int pointParEquipe (String eq) : qui pour une équipe eq donnée, calcule nombre de points cumulés dans le championnat.
(suivant les règles citées au début de l’exercice)
•
ème
Une méthode void calculeNbrePoint () : qui fait appel à la méthode pointParEquipe, pour remplir la 2 colonne du tableau
tabEqPts .
• Une méthode toString() qui retourne une chaine de caractère qui représente le tableau tabEqPts une fois remplie. Exemple :

|Equipe | Points |
------------------------------------------------
|Algérie |4 |
|France |0 |
|Brésil |4 |

• Pour tester la solution, dans la méthode main doit disposer de :

Un objet Championnat initialement vide.

1/2
Université BenYoucef Benkhedda/FS/Dep MI S4, 2016-2017
Documents : interdits Examen : POO Durée : 1h30

Trois (03) objets MatchFoot entre trois 3 équipes : "Algérie", "France", "Brésil" avec des scores (résultat de match)
de votre choix. Ces trois matchs composent le championnat
Affichage du tableau des points des équipes participantes au championnat

Exercice2 :
Donner, avec justification, le résultat de l’exécution du programme suivant :

1 class A{
2 int x=1;
3 A(){}
4 A(int t){x=t-1;}
5 void f(){System.out.println("Je suis f, je travaille pour A, x="+x);}
6 }

7 class B extends A{
8 int y;
9 B(){}
10 B(A aa){super(aa.x); y=aa.x-2;}
11 void f(){System.out.println("Je suis f, je travaille pour B, x="+x+", y="+y);}
12 void g(){}
13 }

14 public class TestAB {

15 public static void main(String[] args){
16 A a=new A();
17 a.f();
18 A b=new B(a);
19 b.f();
20 }
21 }

2/2
 Corrigé type de l’examen POO
Exercice n°1: (17/17)
class MatchFoot { 3/3
private String equipeA, equipeB; 0.25
private int nbrButA, nbrButB; 0.25
public MatchFoot(String equipeA, String equipeB){ 0.5
this.equipeA=equipeA;
this.equipeB=equipeB;
}

public String getEquipeA() { return equipeA;} 0.25

public String getEquipeB() { return equipeB;} 0.25
public int getNbrButA() { return nbrButA;} 0.25
public int getNbrButB() { return nbrButB;} 0.25

public void ajouterBut(String eq){

if (eq.equals("A")) nbrButA++; 0.5
else if (eq.equals("B")) nbrButB++; 0.5
}
}

class Championnat{ 12/12

public static final int MAX_MATCH_IN_TAB=40;
private int nbrMatch; // Nombre de match dans le tableau tabMatchs 0.5
private MatchFoot[] tabMatchs; // tableaux des matchs du championnat 0.5
private String tabEqPts[][]; // tableau des équipes participantes au championnat 0.5

public Championnat(){ 1
tabMatchs=new MatchFoot[MAX_MATCH_IN_TAB];
tabEqPts=new String[10][2];
}

public void AjouterMatch(MatchFoot mf){ 1

int i=nbrMatch;
if(i<MAX_MATCH_IN_TAB){
tabMatchs[i]=mf;
nbrMatch++;
}
}

public void ListeEquipe(){ 3

int k=0;
for(int i=0;i<nbrMatch;i++){
boolean trouve1=false, trouve2=false;
int j=0;
while(tabEqPts[j][0]!=null && !trouve1){
if(tabMatchs[i].getEquipeA().equals(tabEqPts[j][0])) trouve1=true;
j++;
}
j=0;
while(tabEqPts[j][0]!=null && !trouve2){
if(tabMatchs[i].getEquipeB().equals(tabEqPts[j][0])) trouve2=true;
j++;
}
if (!trouve1) { tabEqPts[k][0]=tabMatchs[i].getEquipeA(); k++; }
if (!trouve2) { tabEqPts[k][0]=tabMatchs[i].getEquipeB(); k++; }
}
}

private int pointParEquipe(String eq){ 2.5

int nbrPoint=0;
for(int i=0;i<nbrMatch;i++){
if(tabMatchs[i].getEquipeA().equals(eq)) {
if(tabMatchs[i].getNbrButA()==tabMatchs[i].getNbrButB()) nbrPoint++;
else if(tabMatchs[i].getNbrButA()>tabMatchs[i].getNbrButB())nbrPoint+=3;
}

-1-
 if(tabMatchs[i].getEquipeB().equals(eq)) {
if(tabMatchs[i].getNbrButB()==tabMatchs[i].getNbrButA()) nbrPoint++;
else if(tabMatchs[i].getNbrButB()>tabMatchs[i].getNbrButA())nbrPoint+=3;
}

}
return nbrPoint;
}
public void calculeNbrePoint(){ 1.5
int i=0;
while(tabEqPts[i][0]!=null){
tabEqPts[i][1]=pointParEquipe(tabEqPts[i][0])+""; i++;
}
}

@Override
public String toString(){ 1.5
String s="";
s+="-------------------------\r\n";
s+="|Equipe |Points |\r\n";
s+="-------------------------\r\n";
int i=0;
while(tabEqPts[i][0]!=null){
s+="|"+tabEqPts[i][0]+" "; // case 0: Equipe
s+="|"+tabEqPts[i][1]+" "; // case 1: Nombre de Points
s+="|\r\n";
i++;
}
s+="-------------------------";
return s;
}
}

public class Examen_16_17 {

public static void main(String[] args) { 2/2

Championnat chp=new Championnat() ; 0.25
MatchFoot mf1=new MatchFoot("Algérie", "France");
MatchFoot mf2=new MatchFoot("Algérie", "Brésil"); 0.25
MatchFoot mf3=new MatchFoot("Brésil", "France");
mf1.ajouterBut("A") ;
mf2.ajouterBut("A") ; 0.25
mf3.ajouterBut("A") ;
chp.AjouterMatch(mf1) ;
chp.AjouterMatch(mf2) ; 0.25
chp.AjouterMatch(mf3) ;
chp.ListeEquipe() ; 0.25
chp.calculeNbrePoint() ; 0.5
System.out.print(chp) ; 0.25
}
}

Exercice n°2: (3/3)

Ligne 16:
appel au constructeur A() pour créer un objet référencé par a (ligne 3) :
->aucune instruction: valeur de x par défaut x=1 -------------------------------------0.5
Ligne 17:
Appel de la méthode f()(ligne 5) :
Affichage : je suis f, je travaille pour A, x=1 ------------------------------------0.5
Ligne 18:
appel au constructeur B(a) pour créer un objet référencé par b (ligne 10) :
1ere instruction->appel de super(a.x) donc le constructeur A(1) (ligne 4) :
-> x=1-1=0 ----------------------------------------------------------------------0.75
2eme instruction->y=1-2=-1 -----------------------------------------------------------0.75
Ligne 19:
b.f() -> appel de f() de la classe B (ligne 11)
Affichage : je suis f, je travaille pour B, x=0, y=-1 ----------------------------0.5

-2-