1h30 - 40 questions
> [!success] Consignes
> - 1 bonne réponse par question sauf mention contraire
> - Bonne réponse : 0.5 point
> - Réponse partielle : 0,25 points
> - Mauvaise réponse ou pas de réponse : 0 points
## 1 - Est-ce que java est un langage interprété ou compilé ?
Choisir **la seule** réponse correcte
1. [ ] Compilé
2. [ ] Interprété
3. [x] Les deux
## 2. - Quels sont les 4 piliers de la programmation orientée objet?
Choisir **la seule** réponse correcte
1. [ ] Encapsulation, monomorphisme, heritage, abstraction
2. [ ] Polymorphisme, prototypage, encapsulation, abstraction
3. [x] Abstraction, encapsulation, polymorphisme, héritage
4. [ ] Concretion, encapsulation, heritage, polymorphisme
## 3. - Caractéristiques de Java
> [!info] Plusieurs choix possibles
Cochez les affirmations **vraies**
Concernant le langage Java
1. [ ] Gestion manuelle de la mémoire
2. [x] Simplicité
3. [x] Portable
4. [x] Multitâches
5. [ ] Le langage a ses sources fermées
6. [x] Gestion automatique de la mémoire
7. [ ] Principalement programmation fonctionnelle
8. [ ] Compile directement en langage machine (même si on peut compiler en en natif avec GraalVM de façon optionnelle)
9. [ ] Monotâches
10. [x] Le langage est Open-source
11. [ ] Faiblement typé
12. [x] Fortement typé
## 4. - Écosystème JVM
> [!info] Plusieurs choix possibles
Cochez les affirmations **vraies**
1. [ ] La JVM sert uniquement à faire tourner le langage Java
2. [x] Le code Java est compilé en bytecode
3. [ ] Les packages java sont des fichiers `.tar`
4. [ ] JVM signifie : Java Visual Machine
5. [x] La JVM permet l'intéropérabilité entre langages
6. [x] La JVM permet de traduire le code Java compilé en instructions pour la machine
<div style="page-break-after: always;"></div>
## 5. - JDK
Cochez **la seule** affirmation **vraie**
Le JDK est composé de :
1. [ ] JRE
2. [ ] JVM
3. [ ] Bibliothèques
4. [ ] Outils de développement
5. [x] Toutes les réponses ci-dessus
## 6. - IDE
> [!info] Plusieurs choix possibles
Cochez les affirmations **vraies**
1. [ ] Est un éditeur de texte simple sans autre fonctionnalités
2. [x] Contient des outils interconnectés pour être utilisés au même endroit
3. [ ] Signifie : Environnement Déterministe Informatique
4. [ ] Fonctionne uniquement avec de l'IA
5. [x] Permet de débugger, et automatiser des modifications de code
## 7. - Syntaxe
### 7.1 - Mots-clés
> [!info] Plusieurs choix possibles
```text
public class Main {
public static void main(String[] args) {
System.out.println("Hello World");
}
}
```
Dans le code ci-dessus quels sont les mots-clés réservés ?
1. [x] `public`
2. [x] `class`
3. [ ] `Main`
4. [x] `void`
5. [ ] `main`
6. [ ] `System`
### 7.2 - Types primitifs
> [!info] Plusieurs choix possibles
Les types primitifs
1. [ ] Sont passés par référence
2. [x] Sont passés par valeur
3. [x] Sont alloués statiquement
4. [ ] Sont alloués dynamiquement
5. [ ] Peuvent être null
6. [x] Ont une valeur par défaut
7. [ ] Sont des classes
8. [x] Leur valeur peut être comparée avec `==`
9. [ ] Leur valeur peut être comparée avec `.equals()`
10. [ ] Ont un nom qui commence par une majuscule
11. [x] Ont un nom qui commence par une minuscule
<div style="page-break-after: always;"></div>
### 7.3 - Types référence
> [!info] Plusieurs choix possibles
Les types référence
1. [x] Sont passés par référence
2. [ ] Sont passés par valeur
3. [ ] Sont alloués statiquement
4. [x] Sont alloués dynamiquement
5. [x] Peuvent être null
6. [ ] Ont une valeur par défaut
7. [x] Sont des classes
8. [ ] Leur valeur peut être comparée avec `==`
9. [x] Leur valeur peut être comparée avec `.equals()`
10. [x] Ont un nom qui commence par une majuscule
11. [ ] Ont un nom qui commence par une minuscule
<div style="page-break-after: always;"></div>
## 8. - En Java 17
En Java **17**
> [!info] Plusieurs choix possibles
Cochez les codes **qui compilent**
1. [ ]
```java
public class Main{
public static void main(){
IO.println("Hello World!");
}
}
```
2. [x]
```java
public class Main{
public static void main(){
System.out.println("Hello World!");
}
}
```
3. [ ]
```java
void main(){
IO.println("Hello World!");
}
```
4. [ ]
```java
void main(){
System.out.println("Hello World!");
}
```
## 9. - En Java 25
En Java **25**
> [!info] Plusieurs choix possibles
Cochez les codes **qui compilent**
1. [x]
```java
public class Main{
public static void main(){
IO.println("Hello World!");
}
}
```
2. [x]
```java
public class Main{
public static void main(){
System.out.println("Hello World!");
}
}
```
3. [x]
```java
void main(){
IO.println("Hello World!");
}
```
4. [x]
```java
void main(){
System.out.println("Hello World!");
}
```
<div style="page-break-after: always;"></div>
## 10. - Gestion de dépendances
### 10.1 - Gestion de dépendances, Maven, Gradle
> [!info] Plusieurs choix possibles
Cochez les affirmations **vraies**
1. [x] Maven est équivalent pour java de `npm` ou `composer`
2. [ ] Maven permet **uniquement** de récupérer des dépendances
3. [x] Gradle et Maven peuvent utiliser le dépôt Maven Central
4. [ ] Maven utilise un descripteur de projet `pom.json`
### 10.2 - Dépendance maven
**Une seule** réponse vraie.
Pour déclarer une dépendance dans maven, il faut à minima :
1. [ ] `parentId` , `dependencyId`, `source`
2. [x] `groupId` , `artifactId`, `version`
3. [ ] `tokenId` , `packageId`, `target`
4. [ ] `pluginId` , `modelId`, `build`
### 10.3 - Possibilités de Maven
> [!info] Plusieurs choix possibles
Cochez les affirmations **vraies**
Avec Maven, on peut faire
1. [x] `mvn install` : pour construire un artefact et le publier dans un dépôt local (dans `$HOME/.m2/repository`)
2. [x] `mvn deploy` : pour déployer un artefact sur un dépôt distant comme Maven Central ou un Nexus
3. [x] `mvn clean` : pour supprimer le dossier `target`
4. [x] `mvn compile` : pour compiler les sources dans un sous-dossier de `target`
<div style="page-break-after: always;"></div>
## 11. - Collections
### 11.1 - Hiérarchie des collections
> [!info] Plusieurs choix possibles
Cocher **les codes** qui **compilent**
1. [x]
```java
Object o = new ArrayList<Integer>();
```
2. [x]
```java
Iterable<Integer> i = new ArrayList<Integer>();
```
3. [ ]
```java
List<int> l = new ArrayList<int>();
```
4. [x]
```java
Collection<String> c = new ArrayList<String>();
```
5. [ ]
```java
Set<Double> s = new ArrayList<Double>();
```
<div style="page-break-after: always;"></div>
### 11.2 - Fonctionnalités des collections
> [!info] Plusieurs choix possibles
Pour le code suivant
```java
List<String> lettres = List.of("A", "B", "C");
```
Cocher les codes qui **compilent** ET **s'exécutent correctement**.
1. [ ]
```java
for (int i = 0; i < lettres.size(); i++) {
// int lettre = lettres[i] ;
System.out.println(lettre);
}
```
2. [x]
```java
for (String lettre : lettres) {
System.out.println(lettre);
}
```
3. [ ]
```java
lettres.put("D");
```
4. [ ]
```java
lettres.addAll(List.of("D","E","F"));
```
5. [ ]
```java
lettres.putAll(List.of("D","E","F"));
```
### 11.3 - Set
```java
Set<String> chasseurs = new HashSet(List.of("Bébert", "Dédé", "Bébert","Roger"));
IO.println(chasseurs);
```
Cocher **le seul** affichage **correct**
1. [ ] `[Bébert, Dédé, Bébert, Roger]`
2. [x] `[Roger, Dédé, Bébert]`
3. [ ] `[Bébert, Bébert, Dédé, Roger]`
<div style="page-break-after: always;"></div>
## 12 - Classes
> [!info] Le code ci-dessous compile.
> Les questions qui suivent se réfèreront a ce code.
```java
public final class Cercle {
private final static double PI = 3.14159265;
private final Point centre;
private final double rayon;
public Cercle (Point centre, double rayon){
this.centre = centre;
this.rayon = rayon;
}
public double perimetre(){
return 2 * PI * rayon;
}
public double surface(){
return Math.pow( PI * rayon,2);
}
}
```
```java
public record Point(double x, double y){}
````
### 12.1 - Indiquez ce qui compile
Indiquer **le seul** code qui **compile** :
1. [ ]
```java
void main(){
double perimetre = new Cercle(centre, rayon).perimetre();
Point centre = new Point(0.0, 1.0);
double rayon = 2.6;
}
```
2. [x]
```java
void main(){
Point centre = new Point(0.0, 1.0);
double rayon = 2.6;
double perimetre = new Cercle(centre,rayon).perimetre();
}
```
3. [ ]
```java
void main(){
Point centre = new Point(0.0, 1.0);
double rayon = 2.6;
double perimetre = new Cercle().perimetre(centre, rayon);
}
```
4. [ ]
```java
void main(){
Point centre = new Point(0.0, 1.0);
double rayon = 2.6;
double perimetre = Cercle.perimetre(centre,rayon);
}
```
<div style="page-break-after: always;"></div>
### 12.2 - Mais au fait, le cercle c'est quoi ?
> [!info] Plusieurs choix possibles
Cochez **les propositions** qui sont **vraies**
1. [ ] `Cercle` est un objet
2. [ ] `Cercle` est une instance d’objet
3. [x] `Cercle` est le nom d’un type
4. [x] `Cercle` est l’identifiant d’une classe
5. [ ] `Cercle` est un record
### 12.3 - Une classe
1. [x] Est un type
2. [x] Peut étendre une autre classe
3. [x] Regroupe des données et des méthodes qui peuvent agir sur ces données
4. [x] Possède un constructeur
5. [ ] Doit avoir une méthode `public static void main(String[] args)`
6. [ ] Doit toujours avoir des getters et des setters
<div style="page-break-after: always;"></div>
## 13. - package
Voici l'arborescence de fichiers d'un projet Maven
```text
.
├── pom.xml
└── src
└── main
├── java
│ ├── module-info.java
│ └── school
│ └── coda
│ └── hellofxml
│ ├── HelloApplication.java
│ ├── HelloController.java
│ └── Launcher.java
└── resources
└── school
└── coda
└── hellofxml
└── hello-view.fxml
```
Cochez **la seule proposition** qui est **correcte**
1. [ ]
```
package school/coda/hellofxml;
public class HelloApplication extends Application {
// ...
}
```
2. [x]
```
package school.coda.hellofxml;
public class HelloApplication extends Application {
// ...
}
```
3. [ ]
```
package src/main/java/school/coda/hellofxml;
public class HelloApplication extends Application {
// ...
}
```
4. [ ]
```
package src.main.java.school.coda.hellofxml;
public class HelloApplication extends Application {
// ...
}
```
<div style="page-break-after: always;"></div>
## 14. - Encapsulation
> [!info] Plusieurs choix possibles
Cochez **les propositions** qui sont **vraies**
L'encapsulation
1. [x] Permet de modifier les détails d'implémentation sans modifier l'interface publique
2. [ ] Permet de modifier l'interface publique sans modifier les détails d'implémentation
3. [ ] N'existe que dans Java
4. [x] Sert à restreindre l'accès direct à certains des composants d'un objet
> [!note] La question 5 est ambigüe, elle ne sera pas comptée
> C'est à dire : si vous l'avez cochée ou pas, elle n'ajoute ou ne retire pas de points
## 15. - Interface
> [!info] Plusieurs choix possibles
Cochez **les propositions** qui sont **vraies**
Une interfaces en Java
1. [x] Sert à définir un contrat qui pourra être implémenté par des classes ou étendu par des interfaces
2. [x] Une classe peut implémenter plusieurs interfaces à la fois
3. [ ] Décrit les détails d'implémentation d'une classe
4. [ ] Peut être instanciée à l'aide du mot-clé `new`
5. [x] Décrit un type
## 16. - Polymorphisme
> [!info] Plusieurs choix possibles
Cochez **les propositions** qui sont **vraies**
Quels sont les différents types de polymorphismes en Java ?
1. [x] Le polymorphisme ad hoc : Surcharge de méthode
2. [ ] Le polymorphisme ad-hoc : Redéfinition de méthode
3. [ ] Le polymorphisme ad-hoc : Types génériques
4. [ ] Le polymorphisme par sous-typage : Surcharge de méthode
5. [x] Le polymorphisme par sous-typage : Redéfinition de méthode
6. [ ] Le polymorphisme par sous-typage : Types génériques
7. [ ] Le polymorphisme paramétré : Surcharge de méthode
8. [ ] Le polymorphisme paramétré : Redéfinition de méthode
9. [x] Le polymorphisme paramétré : Types génériques
<div style="page-break-after: always;"></div>
## 17. - Héritage
Les exercices 17.x portent sur le code suivant
```java
public abstract class Oiseau {
protected String pondre() {
return "🪺";
}
private String construireNid() {
return "🪹";
}
abstract public String crie();
}
```
```java
public class Canard extends Oiseau {
@Override
public String crie() {
return "coin coin";
}
public void nage() {
// ...
}
}
```
```java
public class Autruche extends Oiseau {
@Override
public String crie() {
return "Huik";
}
public void courir() {
//...
}
@Override
protected String pondre() {
return "🥚";
}
}
```
<div style="page-break-after: always;"></div>
### 17.1 - `Canard`
> [!info] Plusieurs choix possibles
Cochez **les propositions** qui sont **vraies**
Concernant la classe `Canard`
1. [ ] Peut redéfinir la méthode `String construireNid()`
2. [x] Est compatible avec la classe `Oiseau`
3. [x] `Oiseau canard = new Canard();` compile
4. [x] Est compatible avec `Object`
5. [x] Peut redéfinir la méthode `String pondre()`
6. [ ] `Autruche canard = new Canard();` compile
7. [x] `Canard canard = new Canard();` compile
### 17.2 - `Autruche`
> [!info] Plusieurs choix possibles
Cochez **les propositions** qui sont **vraies**
Concernant la classe `Autruche`
1. [ ] Peut redéfinir la méthode `String construireNid()`
2. [x] Est compatible avec la classe `Oiseau`
3. [x] `Oiseau autruche = new Autruche();` compile
4. [x] Est compatible avec `Object`
5. [ ] Peut redéfinir la méthode `String nage()`
6. [x] `Autruche autruche = new Autruche();` compile
7. [ ] `Canard autruche = new Autruche();` compile
<div style="page-break-after: always;"></div>
## 18. - Exceptions
### 18.1 - Cas d'utilisation des exceptions
> [!info] Plusieurs choix possibles
Cochez les affirmations **vraies**
Les exceptions en Java :
1. [x] Sont un mécanisme de gestion des erreurs
2. [x] Sont des classes
3. [ ] Sont levées avec le mot-clé `raise`
4. [ ] Contiennent **uniquement** un message d'erreur
5. [ ] Doivent toujours être gérées dans un `try` `catch`
### 18.2 - Propagation d'exception
> [!info] Plusieurs choix possibles
Cochez les affirmations **vraies**
Déléguer ou propager une exception
1. [x] Permet d'éviter de faire un `try` `catch` dans la méthode courante
2. [ ] Se fait avec le mot-clé `raises`
3. [ ] Se fait avec le mot-clé `raise`
4. [ ] Se fait avec le mot-clé `throw`
5. [x] Se fait avec le mot-clé `throws`
6. [x] Remonte la gestion de l'exception à la méthode appelante
### 18.3 - Les checked exception
> [!info] Plusieurs choix possibles
Cochez les affirmations **vraies**
Les checked exception
1. [x] Nécessitent obligatoirement un `try` `catch` ou la propager quand on appelle une méthode qui peut en lever une
2. [ ] Ne nécessitent pas obligatoirement de `try` `catch` ou de propagation quand on appelle une méthode qui peut en lever une
3. [x] Etend directement ou indirectement de l'interface `Throwable`
4. [ ] Etend directement ou indirectement de l'interface `Raisable`
5. [x] Peut être étendue
6. [x] Doivent obligatoirement être anticipées et gérées
7. [ ] Sont des erreurs externes à l'application et ne peuvent pas être anticipées
<div style="page-break-after: always;"></div>
### 18.4 - Les unchecked exception
> [!info] Plusieurs choix possibles
Cochez les affirmations **vraies**
Les unchecked exception
1. [ ] Nécessitent obligatoirement un `try` `catch` ou la propager quand on appelle une méthode qui peut en lever une
2. [x] Ne nécessitent pas obligatoirement de `try` `catch` ou de propagation quand on appelle une méthode qui peut en lever une
3. [x] Etend directement ou indirectement de l'interface `Throwable`
4. [ ] Etend directement ou indirectement de l'interface `Raisable`
5. [x] Peut être étendue
6. [ ] Doivent obligatoirement être anticipées et gérées
7. [ ] Sont des erreurs externes à l'application et ne peuvent pas être anticipées
### 18.5 - Les errors
> [!info] Plusieurs choix possibles
Cochez les affirmations **vraies**
Les errors
1. [ ] Nécessitent obligatoirement un `try` `catch` ou la propager quand on appelle une méthode qui peut en lever une
2. [x] Ne nécessitent pas obligatoirement de `try` `catch` ou de propagation quand on appelle une méthode qui peut en lever une
3. [x] Etend directement ou indirectement de l'interface `Throwable`
4. [ ] Etend directement ou indirectement de l'interface `Raisable`
5. [x] Peut être étendue
6. [ ] Doivent être anticipées et gérées
7. [x] Sont des erreurs externes à l'application et ne peuvent pas être anticipées
### 18.6 - Try catch
> [!info] Plusieurs choix possibles
Cochez les affirmations **vraies**
A propos de `try` `catch`
1. [ ] `try` `catch` nécessite forcément un bloc `finally`
2. [ ] `finally` permet d'exécuter du code seulement si une exception est interceptée dans le bloc `catch`
3. [x] Dans un bloc `catch` on peut gérer plusieurs types d'exceptions en même temps
### 18.7 - Pratiques de gestion des erreurs
Cochez **la seule** affirmation **vraie**
1. [ ] Il faut toujours afficher la stack trace complète à l'utilisateur en cas d'erreur pour aider le diagnostic des erreurs
2. [ ] Il est nécessaire d'arrêter le programme en cas d'exception
3. [x] Il est recommandé d'avoir un mécanisme pour attraper les `RuntimeException` dans le programme `main` pour afficher un message adapté à l'utilisateur en cas d'erreurs inattendues
4. [ ] Les exceptions peuvent et doivent être utilisées comme des `if` `else`
<div style="page-break-after: always;"></div>
### 18.8- Try with resources
A propos de try with resources
Cochez **le seul** code qui correspond à un try with resources
1. [ ]
```java
try {Connection connection = DriverManager.getConnection("jdbc:sqlite:test.db")} {
Statement statement = connection.createStatement();
// ...
} catch (SQLException e) {
// ...
}
```
2. [x]
```java
try (Connection connection = DriverManager.getConnection("jdbc:sqlite:test.db")) {
Statement statement = connection.createStatement();
// ...
} catch (SQLException e) {
// ...
}
```
3. [ ]
```java
Connection connection =null;
try {
Connection connection = DriverManager.getConnection("jdbc:sqlite:test.db")
Statement statement = connection.createStatement();
// ...
} catch (SQLException e) {
// ...
} finally {
if(connection!=null){
try{
connection.close();
} catch (SQLException e){
// ...
}
}
}
```
4. [ ]
```java
try with resource (Connection connection = DriverManager.getConnection("jdbc:sqlite:test.db")) {
Statement statement = connection.createStatement();
// ...
} catch (SQLException e) {
// ...
}
```
<div style="page-break-after: always;"></div>
## 19. - JDBC
### 19.1 - `CREATE TABLE`
> [!info] Plusieurs choix possibles
Cochez les affirmations **vraies**
```sql
CREATE TABLE IF NOT EXISTS rpg_character
(
id integer not null
constraint rpg_character_pk
primary key autoincrement,
name varchar(255) not null,
hp integer not null,
def integer not null,
money integer not null,
atk integer,
heal integer,
job varchar(20)
);
```
Pour effectuer la requête SQL ci-dessus avec JDBC
1. [x] Je dois disposer d'une connection ouverte
2. [ ] Je dois créer un `PreparedStatement`
3. [x] Je dois créer un `Statement`
4. [ ] Je dois de préférence utiliser `statement.executeQuery()`
5. [x] Je dois de préférence utiliser `statement.execute()`
6. [ ] Je dois de préférence utiliser `statement.executeUpdate()`
### 19.2 - `DELETE`
> [!info] Plusieurs choix possibles
Cochez les affirmations **vraies**
```sql
DELETE
FROM rpg_character
WHERE id = ?
```
Pour effectuer la requête SQL ci-dessus avec JDBC
1. [x] Je dois disposer d'une connection ouverte
2. [x] Je dois créer un `PreparedStatement`
3. [ ] Je dois créer un `Statement`
4. [ ] Je dois de préférence utiliser `statement.executeQuery()`
5. [ ] Je dois de préférence utiliser `statement.execute()`
6. [x] Je dois de préférence utiliser `statement.executeUpdate()`
<div style="page-break-after: always;"></div>
### 19.3 - `SELECT`
> [!info] Plusieurs choix possibles
Cochez les affirmations **vraies**
```sql
SELECT id, name, hp, def, money, atk, heal, job
FROM rpg_character
```
Pour effectuer la requête SQL ci-dessus avec JDBC
1. [x] Je dois disposer d'une connection ouverte
2. [ ] Je dois créer un `PreparedStatement`
3. [x] Je dois créer un `Statement`
4. [x] Je dois de préférence utiliser `statement.executeQuery()`
5. [ ] Je dois de préférence utiliser `statement.execute()`
6. [ ] Je dois de préférence utiliser `statement.executeUpdate()`
### 19.4 - `SELECT` bis
> [!info] Plusieurs choix possibles
Cochez les affirmations **vraies**
```sql
SELECT id, name, hp, def, money, atk, heal, job
FROM rpg_character
WHERE id = ?
```
Pour effectuer la requête SQL ci-dessus avec JDBC
1. [x] Je dois disposer d'une connection ouverte
2. [x] Je dois créer un `PreparedStatement`
3. [ ] Je dois créer un `Statement`
4. [x] Je dois de préférence utiliser `statement.executeQuery()`
5. [ ] Je dois de préférence utiliser `statement.execute()`
6. [ ] Je dois de préférence utiliser `statement.executeUpdate()`
<div style="page-break-after: always;"></div>
## 20. - JavaFx
### 20.1 - Généralités sur JavaFx
> [!info] Plusieurs choix possibles
Cochez les affirmations **vraies**
1. [ ] Fait partie du JDK
2. [x] Doit être importé comme dépendance
3. [x] Peut être stylé avec du CSS
4. [x] Peut être stylé avec du code
5. [x] Est constitué de `Stage` qui contient une `Scene` qui elle même contient un graphe de `Node`
### 20.2 - Réactivité
> [!info] Plusieurs choix possibles
Cochez les affirmations **vraies**
En javaFx, pour qu'un composant puisse partager des valeurs réactives avec un autre.
1. [ ] On utilise les attributs javaFx
2. [x] On utilise les propriétés javaFx
3. [ ] On utilise les instances javaFx
4. [ ] On utilise les applications javaFx