Skip to content
Snippets Groups Projects
Commit 1b101a67 authored by Robin VAN DE MERGHEL's avatar Robin VAN DE MERGHEL :computer:
Browse files

Forgot to push

parent cc0e5e59
No related branches found
No related tags found
No related merge requests found
File added
File moved
......@@ -145,4 +145,3 @@ class VoitureA extends Voiture {
}
```
```java
\ No newline at end of file
......@@ -21,3 +21,11 @@ int b = list.get(1);
int c = list.get(2);
```
# Exercice 3
## Question 2
Comme on marche avec des types génériques, on ne peut pas avoir de fonction `put(K key, int value)`. Il faudrait cast de `int` vers `V`.
On pourrait vérifier que c'est un `int` avec `instanceof`.
package TP4.src;
public class Etudiant {
private String nom;
private String prenom;
private int age;
private int numeroEtudiant;
private int note;
public Etudiant(String nom, String prenom, int age, int numeroEtudiant, int note) {
this.nom = nom;
this.prenom = prenom;
this.age = age;
this.numeroEtudiant = numeroEtudiant;
this.note = note;
}
public String getNom() {
return nom;
}
public String getPrenom() {
return prenom;
}
public int getAge() {
return age;
}
public int getNumeroEtudiant() {
return numeroEtudiant;
}
public int getNote() {
return note;
}
}
package TP4.src;
import java.util.ArrayList;
public class HashMap<K, V> {
private int size;
private ArrayList<K> keys;
private ArrayList<V> values;
public HashMap() {
this.size = 0;
this.keys = new ArrayList<K>();
this.values = new ArrayList<V>();
}
public void put(K key, V value) {
if (this.keys.contains(key)) {
int index = this.keys.indexOf(key);
this.values.set(index, value);
} else {
this.keys.add(key);
this.values.add(value);
this.size++;
}
}
public V get(K key) {
if (this.keys.contains(key)) {
int index = this.keys.indexOf(key);
return this.values.get(index);
} else {
return null;
}
}
public void remove(K key) {
if (this.keys.contains(key)) {
int index = this.keys.indexOf(key);
this.keys.remove(index);
this.values.remove(index);
this.size--;
}
}
public int size() {
return this.size;
}
public boolean containsKey(K key) {
return this.keys.contains(key);
}
public boolean containsValue(V value) {
return this.values.contains(value);
}
// Si c'est un int, on autorise le get
public int getObject(K key) {
// On vérifie le type
if (this.values.get(0) instanceof Integer) {
// On vérifie si la clé existe
if (this.keys.contains(key)) {
int index = this.keys.indexOf(key);
return (int) this.values.get(index);
} else {
return -1;
}
} else {
return -1;
}
}
}
package TP4.src;
class Liste {
private int[] liste;
import java.util.Arrays;
class Liste<T> {
private T[] liste;
private int nbElements;
public Liste() {
this.liste = new int[10];
this.liste = newArray(10);
this.nbElements = 0;
}
public Liste(int taille) {
this.liste = new int[taille];
this.liste = newArray(taille);
this.nbElements = 0;
}
public Liste(Liste liste) {
this.liste = new int[liste.liste.length];
public Liste(Liste<T> liste) {
this.liste = newArray(liste.liste.length);
this.nbElements = liste.nbElements;
for (int i = 0; i < liste.nbElements; i++) {
......@@ -25,8 +27,8 @@ class Liste {
}
}
public Liste(int[] liste) {
this.liste = new int[liste.length];
public Liste(T[] liste) {
this.liste = newArray(liste.length);
this.nbElements = liste.length;
for (int i = 0; i < liste.length; i++) {
......@@ -36,10 +38,10 @@ class Liste {
}
}
public void ajouter(int element) {
public void ajouter(T element) {
if (this.nbElements == this.liste.length) {
int[] listeTemp = new int[this.liste.length * 2];
T[] listeTemp = newArray(this.liste.length * 2);
for (int i = 0; i < this.liste.length; i++) {
......@@ -55,7 +57,7 @@ class Liste {
this.nbElements++;
}
public void ajouter(int index, int element) {
public void ajouter(int index, T element) {
if (index < 0 || index > this.nbElements) {
System.out.println("Index invalide");
......@@ -65,7 +67,7 @@ class Liste {
if (this.nbElements == this.liste.length) {
int[] listeTemp = new int[this.liste.length * 2];
T[] listeTemp = newArray(this.liste.length * 2);
for (int i = 0; i < this.liste.length; i++) {
......@@ -103,6 +105,22 @@ class Liste {
}
this.nbElements--;
// Comme une ArrayList, on réduit la taille du tableau si il y a trop de place vide
if (this.nbElements < this.liste.length / 2) {
T[] listeTemp = newArray(this.liste.length / 2);
for (int i = 0; i < this.nbElements; i++) {
listeTemp[i] = this.liste[i];
}
this.liste = listeTemp;
}
}
public void afficher() {
......@@ -116,12 +134,12 @@ class Liste {
System.out.println();
}
public int get(int index) {
public T get(int index) {
if (index < 0 || index >= this.nbElements) {
System.out.println("Index invalide");
return -1;
return null;
}
......@@ -129,7 +147,7 @@ class Liste {
}
public void set(int index, int element) {
public void set(int index, T element) {
if (index < 0 || index >= this.nbElements) {
......@@ -145,7 +163,7 @@ class Liste {
return this.nbElements;
}
public boolean contient(int element) {
public boolean contient(T element) {
for (int i = 0; i < this.nbElements; i++) {
......@@ -162,7 +180,7 @@ class Liste {
public void reverse() {
int[] listeTemp = new int[this.nbElements];
T[] listeTemp = newArray(this.nbElements);
for (int i = 0; i < this.nbElements; i++) {
......@@ -173,4 +191,9 @@ class Liste {
this.liste = listeTemp;
}
@SafeVarargs
static <T> T[] newArray(int length, T... array) {
return Arrays.copyOf(array, length);
}
}
\ No newline at end of file
package TP4.src;
import java.util.Random;
public class Main {
public static void main(String[] args) {
......@@ -28,17 +30,340 @@ public class Main {
// triangulaire.afficheTriangulaire();
// ------------------------ Exercice 2 ------------------------
Liste liste = new Liste();
// Liste<Integer> liste = new Liste<Integer>();
// liste.ajouter(1);
// liste.ajouter(2);
// liste.ajouter(3);
// liste.afficher();
// liste.reverse();
// liste.afficher();
// ------------------------ Exercice 3 ------------------------
// HashMap<String, Integer> map = new HashMap<String, Integer>();
// map.put("a", 1);
// map.put("b", 2);
// map.put("c", 3);
// System.out.println(map.get("a"));
// ------------------------ Exercice 4 ------------------------
// On va faire une Liste, un HashMap et un tableau
// On va faire n insertions de 100 Étudiants dans les 3 structures, et comparer le temps d'exécution
long n = 1000000;
Liste<Etudiant> liste;
HashMap<Integer, Etudiant> map;
Etudiant[] tableau;
long debut, fin;
String nomAlea, prenomAlea;
int ageAlea, numeroEtudiantAlea, noteAlea;
Random random = new Random();
// On remplit la liste
debut = System.currentTimeMillis();
for (int i = 0; i < n; i++) {
liste = new Liste<Etudiant>();
for (int j = 0; j < 100; j++) {
nomAlea = "Nom" + random.nextInt(100);
prenomAlea = "Prenom" + random.nextInt(100);
ageAlea = random.nextInt(100);
numeroEtudiantAlea = random.nextInt(100);
noteAlea = random.nextInt(100);
liste.ajouter(new Etudiant(nomAlea, prenomAlea, ageAlea, numeroEtudiantAlea, noteAlea));
}
}
fin = System.currentTimeMillis();
System.out.println("Temps d'insertion pour la liste: " + (double) (fin - debut) / 1000 + "s");
// On remplit le HashMap
debut = System.currentTimeMillis();
for (int i = 0; i < n; i++) {
map = new HashMap<Integer, Etudiant>();
for (int j = 0; j < 100; j++) {
nomAlea = "Nom" + random.nextInt(100);
prenomAlea = "Prenom" + random.nextInt(100);
ageAlea = random.nextInt(100);
numeroEtudiantAlea = random.nextInt(100);
noteAlea = random.nextInt(100);
map.put(j, new Etudiant(nomAlea, prenomAlea, ageAlea, numeroEtudiantAlea, noteAlea));
}
}
fin = System.currentTimeMillis();
System.out.println("Temps d'insertion pour le HashMap: " + (double) (fin - debut) / 1000 + "s");
// On remplit le tableau
debut = System.currentTimeMillis();
for (int i = 0; i < n; i++) {
tableau = new Etudiant[100];
for (int j = 0; j < 100; j++) {
nomAlea = "Nom" + random.nextInt(100);
prenomAlea = "Prenom" + random.nextInt(100);
ageAlea = random.nextInt(100);
numeroEtudiantAlea = random.nextInt(100);
noteAlea = random.nextInt(100);
tableau[j] = new Etudiant(nomAlea, prenomAlea, ageAlea, numeroEtudiantAlea, noteAlea);
}
}
fin = System.currentTimeMillis();
System.out.println("Temps d'insertion pour le tableau: " + (double) (fin - debut) / 1000 + "s");
long tempsTotal; // On va calculer le temps QUE pour le calcul de la moyenne
// On calcule la moyenne des notes des étudiants (on regénère les étudiants à chaque fois)
tempsTotal = 0;
for (int i = 0; i < n; i++) {
liste = new Liste<Etudiant>();
for (int j = 0; j < 100; j++) {
nomAlea = "Nom" + random.nextInt(100);
prenomAlea = "Prenom" + random.nextInt(100);
ageAlea = random.nextInt(100);
numeroEtudiantAlea = random.nextInt(100);
noteAlea = random.nextInt(100);
liste.ajouter(new Etudiant(nomAlea, prenomAlea, ageAlea, numeroEtudiantAlea, noteAlea));
}
debut = System.currentTimeMillis();
for (int j = 0; j < 100; j++) {
liste.get(j).getNote();
}
fin = System.currentTimeMillis();
tempsTotal += fin - debut;
}
System.out.println("Temps de calcul de la moyenne pour la liste: " + (double) tempsTotal / 1000 + "s");
tempsTotal = 0;
for (int i = 0; i < n; i++) {
map = new HashMap<Integer, Etudiant>();
for (int j = 0; j < 100; j++) {
nomAlea = "Nom" + random.nextInt(100);
prenomAlea = "Prenom" + random.nextInt(100);
ageAlea = random.nextInt(100);
numeroEtudiantAlea = random.nextInt(100);
noteAlea = random.nextInt(100);
map.put(j, new Etudiant(nomAlea, prenomAlea, ageAlea, numeroEtudiantAlea, noteAlea));
}
liste.ajouter(1);
liste.ajouter(2);
liste.ajouter(3);
liste.afficher();
debut = System.currentTimeMillis();
liste.reverse();
liste.afficher();
for (int j = 0; j < 100; j++) {
map.get(j).getNote();
}
fin = System.currentTimeMillis();
tempsTotal += fin - debut;
}
System.out.println("Temps de calcul de la moyenne pour le HashMap: " + (double) tempsTotal / 1000 + "s");
tempsTotal = 0;
for (int i = 0; i < n; i++) {
tableau = new Etudiant[100];
for (int j = 0; j < 100; j++) {
nomAlea = "Nom" + random.nextInt(100);
prenomAlea = "Prenom" + random.nextInt(100);
ageAlea = random.nextInt(100);
numeroEtudiantAlea = random.nextInt(100);
noteAlea = random.nextInt(100);
tableau[j] = new Etudiant(nomAlea, prenomAlea, ageAlea, numeroEtudiantAlea, noteAlea);
}
debut = System.currentTimeMillis();
for (int j = 0; j < 100; j++) {
tableau[j].getNote();
}
fin = System.currentTimeMillis();
tempsTotal += fin - debut;
}
System.out.println("Temps de calcul de la moyenne pour le tableau: " + (double) tempsTotal / 1000 + "s");
// Maintenant on va rechercher un étudiant dans la liste
tempsTotal = 0;
for (int i = 0; i < n; i++) {
liste = new Liste<Etudiant>();
for (int j = 0; j < 100; j++) {
nomAlea = "Nom" + random.nextInt(100);
prenomAlea = "Prenom" + random.nextInt(100);
ageAlea = random.nextInt(100);
numeroEtudiantAlea = random.nextInt(100);
noteAlea = random.nextInt(100);
liste.ajouter(new Etudiant(nomAlea, prenomAlea, ageAlea, numeroEtudiantAlea, noteAlea));
}
debut = System.currentTimeMillis();
liste.contient(new Etudiant("Nom50", "Prenom50", 50, 50, 50));
fin = System.currentTimeMillis();
tempsTotal += fin - debut;
}
System.out.println("Temps de recherche pour la liste: " + (double) tempsTotal / 1000 + "s");
// Maintenant on va rechercher un étudiant dans le HashMap
tempsTotal = 0;
for (int i = 0; i < n; i++) {
map = new HashMap<Integer, Etudiant>();
for (int j = 0; j < 100; j++) {
nomAlea = "Nom" + random.nextInt(100);
prenomAlea = "Prenom" + random.nextInt(100);
ageAlea = random.nextInt(100);
numeroEtudiantAlea = random.nextInt(100);
noteAlea = random.nextInt(100);
map.put(j, new Etudiant(nomAlea, prenomAlea, ageAlea, numeroEtudiantAlea, noteAlea));
}
debut = System.currentTimeMillis();
map.containsValue(new Etudiant("Nom50", "Prenom50", 50, 50, 50));
fin = System.currentTimeMillis();
tempsTotal += fin - debut;
}
System.out.println("Temps de recherche pour le HashMap: " + (double) tempsTotal / 1000 + "s");
// Maintenant on va rechercher un étudiant dans le tableau
tempsTotal = 0;
for (int i = 0; i < n; i++) {
tableau = new Etudiant[100];
for (int j = 0; j < 100; j++) {
nomAlea = "Nom" + random.nextInt(100);
prenomAlea = "Prenom" + random.nextInt(100);
ageAlea = random.nextInt(100);
numeroEtudiantAlea = random.nextInt(100);
noteAlea = random.nextInt(100);
tableau[j] = new Etudiant(nomAlea, prenomAlea, ageAlea, numeroEtudiantAlea, noteAlea);
}
debut = System.currentTimeMillis();
for (int j = 0; j < 100; j++) {
if (tableau[j].equals(new Etudiant("Nom50", "Prenom50", 50, 50, 50))) {
break;
}
}
fin = System.currentTimeMillis();
tempsTotal += fin - debut;
}
System.out.println("Temps de recherche pour le tableau: " + (double) tempsTotal / 1000 + "s");
}
}
File added
POO/annales/fig1.png

2.15 MiB

---
title: Annales POO
author: Robin VAN DE MERGHEL
lang: fr
geometry: margin=1in
---
*Note : Il se peut que je ne soit pas sûr de certaines réponses, n'hésitez pas à me contacter si vous pensez que je me suis trompé. Je noterai les questions où je ne suis pas sûr d'une étoile.*
# Annale 2020-2021
## Exercice 1
### Question 1
> **En programmation orientée objet, qu'est-ce qu'un objet ?**
Un objet est une entité qui possède des attributs et des méthodes. Il peut être instancié et possède un état. Il peut être modifié par des méthodes.
On peut le voir comme une sorte de "boîte" qui contient des informations et des fonctions.
### Question 2
> **Expliquez le but et le fonctionnement des exceptions.**
Les exceptions sont des erreurs qui peuvent survenir lors de l'exécution d'un programme comme une division par zéro. Elles sont gérées par des blocs `try`/`catch` qui permettent de gérer les erreurs (pouvoir choisir un comportement en cas d'erreur).
### Question 3
> **Pourquoi faut-il toujours redéfinir hashCode (ou équivalent) quand on redéfini equals (ou équivalent) ?**
Si on redéfinit `equals`, on doit redéfinir `hashCode` pour que les deux méthodes soient cohérentes. En effet, si deux objets sont égaux (sans avoir la même référence), ils doivent avoir le même `hashCode`.
Il en est de même si on redéfinit `compareTo`.
### Question 4
> **Quelle est la différence entre la redéfinition de méthodes et la surcharge?**
La redéfinition de méthodes est une spécialisation d'une méthode d'une classe parente, par exemple un `Animal` qui redéfinit la méthode `manger` pour qu'elle soit plus spécifique à un `Chat`.
La surcharge est une méthode qui a le même nom mais qui a des paramètres différents. Par exemple, on peut avoir une méthode `manger` qui prend en paramètre un `Animal` et une autre qui prend en paramètre un `Nourriture`.
### Question 5
> **Quel est l'intérêt d'une machine virtuelle (dans le contexte de Java)?**
La machine virtuelle permet d'exécuter du code Java sur n'importe quel système d'exploitation. Par exemple, un programme Java écrit sur Windows peut être exécuté sur Linux, voire même sur un téléphone Android.
Elle permet aussi une portabilité du code Java, car le code compilé est le même peu importe l'OS.
### Question 6
> **En Java, quelle est la différence entre l'opérateur == et la méthode equals?**
L'opérateur `==` compare les références des objets (leur emplacement en mémoire). La méthode `equals` compare les valeurs des objets (leur contenu) et peut-être redéfinie.
Donc deux `Etudiant` peuvent avoir la même valeur (même nom, prénom, etc.) mais ne pas être égaux (car ils ont des références différentes $\leftrightarrow$ ils ne sont pas de la même famille).
### Question 7*
*Note : je ne suis pas sûr.*
> **Pourquoi est-il préférable de ne dépendre que des interfaces?**
Cela permet de ne pas dépendre d'une implémentation particulière. Par exemple, on peut avoir une classe `Etudiant` qui dépend de l'interface `Personne` et qui peut donc être utilisée avec n'importe quelle implémentation de `Personne` (une classe `Etudiant` ou une classe `Professeur` par exemple).
### Question 8
> **Donner les critères permettant de garantir la substituabilité d'un sous-type.**
Un sous-type doit pouvoir être utilisé à la place de son type parent. Pour cela, il doit implémenter toutes les méthodes de son type parent et ne pas en ajouter.
De plus, il doit pouvoir être utilisé dans un contexte où le type parent est attendu. Exemple : Un triangle est une forme, si une forme est dessinable, alors un triangle est dessinable.
### Question 9
> **Que signifie le mot-clé Java `final` utilisé sur : un attribut, une méthode, une classe.**
#### Attribut
Un attribut `final` ne peut pas être modifié après sa création. Il doit être initialisé dans le constructeur. C'est une constante.
#### Méthode
Une méthode `final` ne peut pas être redéfinie dans une classe fille.
#### Classe
Une classe `final` ne peut pas être étendue (héritée). On peut dire que c'est une classe "scellée" ou "élémentaire".
### Question 10*
*Note : peut-être mieux formuler ?*
> **Qu'est-ce que l'héritage? Quelles alternatives peut-on utiliser?**
L'héritage est une relation entre deux classes où une classe fille hérite des attributs et méthodes de sa classe parente. Cela permet de réutiliser du code et d'organiser le code en classes plus petites.
On peut utiliser la composition à la place de l'héritage. Cela consiste à créer une classe qui contient une instance d'une autre classe. Par exemple, on peut avoir une classe `Etudiant` qui contient une instance de la classe `Personne`.
### Question 11
> **Expliquez ce que sont les classes génériques.**
Les classes génériques sont des classes qui peuvent prendre en paramètre un type. Par exemple, on peut avoir une classe `Liste` qui peut prendre en paramètre un type `T` et qui contient une liste de `T`.
On peut ainsi faire une `Liste` de `String`, de `Integer`, de `Etudiant`, etc. sans avoir à créer une classe pour chaque type.
### Question 12
> **Quels sont les intérêts d'utiliser des accesseurs?**
Les accesseurs permettent de contrôler l'accès aux attributs d'une classe. Par exemple, on ne veut pas donner l'accès à la référence d'un étudiant, donc on peut créer un accesseur qui renvoie juste une information (le nom par exemple).
## Exercice 2
> **Soient les deux classes Java suivante:**
```java
class A {
private int a;
A (int v) {
a = v;
}
public int foo(A other) {
return a + other.a;
}
}
class B extends A {
private int b;
B (int v) {
super(v);
}
@Override
public int foo(B other) {
return 42;
}
}
```
> **Ce programme affiche une erreur à la compilation. Pourquoi?**
La méthode `foo` de la classe `B` écrase la méthode `foo` de la classe `A`. Or les types passé en paramètre sont différents. La méthode `foo` de la classe `A` prend en paramètre un objet de type `A`, alors que la méthode `foo` de la classe `B` prend en paramètre un objet de type `B`.
## Exercice 3
> **Soit le diagramme de classe conceptuel suivant :**
![Diagramme](fig1.png)
> **Donnez le code Java correspondant, en respectant les conventions du langage (attention, le diagramme n'est pas au niveau d'abstraction de l'implémentation). Vous pourrez utiliser la class `java.time.LocalDate` pour représenter la date. La méthode statique now de cette classe retourne la date courrante. Le détail de son utilisation n'est cependant pas important ici.**
<!--
Classes :
- Personne
- A un nom
- Peut adopter un animal
- Animal
- Classe abstraite
- A un nom
- A une date de naissance
- A un age calculé
- Peut crier
- Un chien
- Hérite d'animal
- Redéfinit la méthode crier
- Un chat
- Hérite d'animal
- Redéfinit la méthode crier
-->
```java
import java.time.LocalDate;
class Personne {
private String nom;
private Animal animal;
public Personne(String nom) {
this.nom = nom;
}
public void adopter(Animal animal) {
this.animal = animal;
}
}
abstract class Animal {
private String nom;
private LocalDate dateNaissance;
public Animal(String nom, LocalDate dateNaissance) {
this.nom = nom;
this.dateNaissance = dateNaissance;
}
public String getNom() {
return nom;
}
public LocalDate getDateNaissance() {
return dateNaissance;
}
public int getAge() {
return LocalDate.now().getYear() - dateNaissance.getYear();
}
public abstract String crier();
}
class Chien extends Animal {
public Chien(String nom, LocalDate dateNaissance) {
super(nom, dateNaissance);
}
@Override
public String crier() {
return "Wouaf";
}
}
class Chat extends Animal {
public Chat(String nom, LocalDate dateNaissance) {
super(nom, dateNaissance);
}
@Override
public String crier() {
return "Miaou";
}
}
class Main {
public static void main(String[] args) {
Personne personne = new Personne("Jean");
Animal chien = new Chien("Rex", LocalDate.of(2010, 1, 1));
Animal chat = new Chat("Felix", LocalDate.of(2015, 1, 1));
personne.adopter(chien);
personne.adopter(chat);
System.out.println(personne.animal.crier());
}
}
```
\ No newline at end of file
File added
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment