Sujet corrigé du contrôle de juin 2016

Licence Informatique 2ème année
Programmation Objet 1
Examen de seconde session – 20/06/2016 – 2h
Les notes de cours, TD et TP sont autorisées.
Exercice 0 (4 points)
Le code suivant compile t-il? Si non, indiquez les erreurs. Proposez éventuellement des corrections et
indiquez quel sera l'affichage lors de l'exécution une fois ces corrections effectuées.
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
public class A{
protected int a = 1;
public A(){
System.out.println("A");
}
public void a(){
System.out.println(a);
}
}
public interface C{
public final int a = 3;
public void a();
}
public class B extends A implements C{
private int a = 2;
public B(){
System.out.println("B");
}
public void a(){
System.out.println(a);
}
public static void main(String[] t){
A o1 = new A();
A o2 = new B();
B o3 = new B();
System.out.println(o1.a);
System.out.println(o2.a);
System.out.println(o3.a);
o1.a();
o2.a();
o3.a();
}
}
Exercice 1 (10 points)
On veut écrire un programme pour gérer des arbres où chaque noeud contient un entier. On veut pouvoir
représenter des arbres de n'importe quel type mais tout arbre doit cependant offrir des méthodes pour :
- ajouter un entier comme noeud de l'arbre (l'endroit où on l'ajoute dépend du type d'arbre)
- enlever un entier de l'arbre
- obtenir la hauteur de l'arbre
- déterminer si un entier donné est présent ou pas dans l'arbre
NB : La façon dont ces méthodes vont être implémentées dépend du type d'arbre. Par exemple, pour trouver
un entier dans un arbre, on devra faire un parcours exhaustif dans le cas d'un arbre général, alors qu'un
parcours dichotomique suffira pour un arbre binaire de recherche.
Question 1.1 Proposez du code objet pour représenter les arbres d'entiers en général. (1 points)
Question 1.2 Proposez du code objet pour représenter les arbres binaires, où chaque noeud a au
plus 2 fils . Ce code doit implémenter le calcul de la hauteur d'un arbre binaire. (2,5 points).
Question 1.3 Proposez du code objet pour représenter les arbres binaires de recherche, où sur
chaque noeud, le fils gauche a une valeur inférieure ou égale à celle du noeud, et le fils droit a une valeur
strictement supérieure à celle du noeud. Ce code doit implémenter l'ajout d'un entier comme noeud de
l'arbre et la recherche d'un entier donné dans l'arbre. On peut considérer que la méthode de suppression
d'un entier est également implémentée à ce niveau mais il n'est pas demandé d'écrire son corps. (4 points)
Question 1.4 Proposez du code objet pour représenter les arbres n-aires, où chaque noeud a un
nombre quelconque de fils . Ce code doit implémenter le calcul de la hauteur d'un arbre n-aire. (2,5 points)
Exercice 2 (6 points)
On veut réaliser un jeu vidéo dans lequel des personnages ou des animaux se déplacent de différentes
façons. Une interface décrivant les méthodes de déplacement a déjà été écrite. Elle est utilisée pour les
animaux et ne peut donc pas être modifiée :
1
public interface Localisable{
public final int PAS = 10;
public java.awt.Point getPosition();
public void avance(); // fait avancer l'objet
}
De plus, une classe implémentant un comportement de déplacement aléatoire a déjà été écrite :
public class Exploration implements Localisable{
private int x,y;
public Exploration(int x, int y){
this.x = x; this.y = y;
}
public java.awt.Point getPosition(){
return new java.awt.Point(x,y);
}
public void avance(){
double dx = Math.random();
double dy = Math.random();
this.x = (int) (this.x+dx*PAS/Math.sqrt(dx*dx+
dy*dy));
this.y = (int) (this.y+dy*PAS/Math.sqrt(dx*dx+
dy*dy));
}
}
Il faut maintenant écrire le code qui permet de gérer les personnages.
Question 2.1 Proposez du code objet pour implémenter les comportements de déplacement non
aléatoire, c'est-à-dire les déplacements qui se font selon une direction donnée. (3 points)
Question 2.2 Proposez du code objet pour représenter les personnages qui ont un nom et peuvent
adopter différents comportements de déplacement. On peut supposer qu'à la création d'un personnage, il se
déplace aléatoirement, mais il peut, au cours de l'exécution du jeu, changer de façon de se déplacer. Écrire
une méthode principale qui crée un personnage nommé Toto, positionné au point (0,0), puis lui donne un
mode de déplacement non aléatoire avec une direction de vecteur (6,8). (3 points)
1
La classe Point possède deux attributs publics x et y de type int
Exercice 0
Le code compile et affiche A,A,B,A,B, 1,1,2,1,2,2.
Exercice 1
1.1
public interface Tree{
public void addNode(int i);
public void removeNode(int i);
public int getHeight();
public boolean exists(int i);
}
1.2
public abstract class BinaryTree implements Tree{
protected int i;
protected BinaryTree left, right;
public BinaryTree(int i){
this.i = i;
}
public int getHeight(){
if(this.left == null){
if(this.right== null) return 1;
else return 1+this.right.getHeight();
}
else{
if(this.right == null) return 1+this.left.getHeight();
else return
1+Math.max(this.right.getHeight(),this.left.getHeight());
}
}
}
1.3
public class BinarySearchTree extends BinaryTree{
public BinarySearchTree(int i){
super(i);
}
public void addNode(int i){
if(i<=this.i){
if(this.left == null) this.left = new BinarySearchTree(i);
else this.left.addNode(i);
}
else{
if(this.right == null) this.right = new BinarySearchTree(i);
else this.right.addNode(i);
}
}
public void removeNode(int i){}
public boolean exists(int i){
if(this.i == i) return true;
else{
if(i<this.i){
if(this.left == null) return false;
else return this.left.exists(i);
}
else{
}
}
if(this.right == null) return false;
else return this.right.exists(i);
}
}
1.4
public abstract class NaryTree implements Tree{
private int i;
private ArrayList<NaryTree> children ;
public NaryTree(int i){
this.i = i;
}
public int getHeight(){
int h = 0;
for(NaryTree t:children){
if(t!=null){
int ht = t.getHeight();
if(ht>h) h = ht;
}
}
return 1+h;
}
}
Exercice 2
2.1
public class Voyage implements Localisable{
private int x,y,dx,dy;
public Voyage(int x, int y, int dx, int dy){
this.x = x; this.y = y; this.dx = dx; this.dy = dy;
}
public java.awt.Point getPosition(){
return new java.awt.Point(x,y);
}
public void avance(){
this.x = (int) (this.x+dx*PAS/Math.sqrt(dx*dx+dy*dy));
this.y = (int) (this.y+dy*PAS/Math.sqrt(dx*dx+dy*dy));
}
}
2.2
public class Personnage{
private Localisable l;
private String nom;
public Personnage(String n, int x, int y){
this.nom = n;
this.l = new Exploration(x,y);
}
public java.awt.Point getPosition(){
return this.l.getPosition();
}
public void setLocalisable(Localisable l){
this.l = l;
}
public static void main(String[] t){
Personnage p = new Personnage("Toto",0,0);
p.setLocalisable(new
Voyage(p.getPosition().x,p.getPosition().y,6,8));
}
}