Show page

Differences

This shows you the differences between two versions of the page.

--- alf:laboratoare:01_fr_java [2023/03/04 21:02]
alexandra.negoita02 created
+++ alf:laboratoare:01_fr_java [2023/03/07 02:51] (current)
alexandra.negoita02 [Assignment]
@@ Line 1: / Line 1: @@
-====== TP 1 - Structures de données ======
+====== TP 1 - Structures de données en Java ======
+====== Assignment ======
+<note warning>
+Vous devez **accepter** l'assignment d'ici est travailler avec ce **repository**: [[https://classroom.github.com/a/_ydXjvmv|Lab 1]]
+</note>
 ===== Tableaux =====
 Un tableau (**array**) est une collection homogène qui stocke des valeurs avec le même type de données.
-  * ils sont //statiques//: une fois initialisés, leur dimension ne peut pas être modifiée
+  * Ils sont //statiques//: une fois initialisés, leur dimension ne peut pas être modifiée;
-  * chaque élément est identifié par un entier unique appelé //index//
+  * Chaque élément est identifié par un entier unique appelé //index//;
-  * ils doivent être déclarés avant l'utilisation
+  * Ils doivent être déclarés avant l'utilisation;
-  * l'initialisation fait référence au remplissage du tableau avec des éléments
+  * L'initialisation fait référence au remplissage du tableau avec des éléments;
     <code java>
        String[] values = {"1", "2", "3", "4"};
-       System.out.println(values[0]); //1
+       System.out.println(values[0]); // 1
-       System.out.println(values[1]); //2
+       System.out.println(values[1]); // 2
      </code>
-  * il y a aussi la classe [[https://docs.oracle.com/en/java/javase/18/docs/api/java.base/java/util/ArrayList.html|ArrayList]]. Ce classe n'a pas besoin de donner une dimension concrete comme dans le cas d'un array simple, et les elements peuvent etre ajoutees et eliminees sans limites.
+  * Il y a aussi la classe [[https://docs.oracle.com/en/java/javase/18/docs/api/java.base/java/util/ArrayList.html|ArrayList]]. Ce classe n'a pas besoin de donner une dimension concrète comme dans le cas d'un array simple, et les éléments peuvent être ajoutées et éliminées sans limites.
     <code java>
        ArrayList<Integer> numbers = new ArrayList<Integer>();
@@ Line 19: / Line 24: @@
        numbers.add(8);
        numbers.add(10);
-       System.out.println(numbers); //[3, 8, 10]
+       System.out.println(numbers); // [3, 8, 10]
     </code>
 === Fonctions prédéfinies pour les tableaux ===
-== Array ==
+== Pour ArrayList ==
-== ArrayList ==
   * //[[https://docs.oracle.com/javase/8/docs/api/java/util/ArrayList.html#size--|list.size()]]// - numéro d'éléments du tableau;
-  * //[[https://docs.oracle.com/javase/8/docs/api/java/util/ArrayList.html#get-int-|list.get(index)]]// - l'objet situe sur la position //index//;
+  * //[[https://docs.oracle.com/javase/8/docs/api/java/util/ArrayList.html#get-int-|list.get(index)]]// - l'objet situé sur la position //index//;
   * //[[https://docs.oracle.com/javase/8/docs/api/java/util/ArrayList.html#indexOf-java.lang.Object-|list.indexOf(Object o)]]// - numéro de l'indice correspondant à la premiere occurence de l'objet //element//;
-  * //[[https://docs.oracle.com/javase/8/docs/api/java/util/ArrayList.html#lastIndexOf-java.lang.Object-|list.lastIndexOf(element)]]// - indice pour la derniere occurence de l'objet //element//;
+  * //[[https://docs.oracle.com/javase/8/docs/api/java/util/ArrayList.html#lastIndexOf-java.lang.Object-|list.lastIndexOf(element)]]// - indice pour la dernière occurence de l'objet //element//;
   * //[[https://docs.oracle.com/javase/8/docs/api/java/util/ArrayList.html#add-E-|list.add(element)]]// - ajouter la variable //element// au tableau;
   * //[[https://docs.oracle.com/javase/8/docs/api/java/util/ArrayList.html#remove-int-|list.remove(index)]]// - supprimer et retourner l'élément sur la position //index//;
-  * //[[https://docs.oracle.com/javase/8/docs/api/java/util/ArrayList.html#contains-java.lang.Object-|list.contains(element)]]// - retourne **vrai** si l'objet //element// est present dans la liste;
+  * //[[https://docs.oracle.com/javase/8/docs/api/java/util/ArrayList.html#contains-java.lang.Object-|list.contains(element)]]// - retourne **vrai** si l'objet //element// est présent dans la liste;
-  * //[[https://docs.oracle.com/javase/8/docs/api/java/util/ArrayList.html#set-int-E-|list.set(index, element)]]// - remplace l'objet situe sur la position //index// de la liste avec //element//;
+  * //[[https://docs.oracle.com/javase/8/docs/api/java/util/ArrayList.html#set-int-E-|list.set(index, element)]]// - remplace l'objet situé sur la position //index// de la liste avec //element//;
-  * [[https://docs.oracle.com/javase/8/docs/api/java/util/ArrayList.html#toArray--|list.toArray()]] - retourne un array qui contient tous les element de la liste;
+  * [[https://docs.oracle.com/javase/8/docs/api/java/util/ArrayList.html#toArray--|list.toArray()]] - retourne un array qui contient tous les éléments de la liste;
 ===== String =====
 La classe **[[https://docs.oracle.com/javase/7/docs/api/java/lang/String.html|String]]** est un constructeur de chaînes de caractères.
-Les littéraux de chaînes de caractères peuvent avoir l'une des formes suivantes :
+Les chaînes de caractères peuvent avoir l'une des formes suivantes :
 <code java>
-        String a = "text"; //un chaine de characteres
+        String a = "text"; // un chaine de caractères
         String b = "'text' in text";
-        char c = 't'; //un seul charactere
+        char c = 't'; // un seul charactere
-        String d = "He said \"Hello World\"!"; //character escaping
+        String d = "He said \"Hello World\"!"; // character escaping
 </code>
 === Fonctions prédéfinies pour les chaînes de caractères ===
-  * //[[https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#length()|str.length]]// - la longueur d'une chaîne de characteres
+  * //[[https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#length()|str.length]]// - la longueur d'une chaîne de caractères
+  * //[[https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#charAt(int)|str.charAt(index)]]// - retourne le caractère qui se trouve a la position //index//
   * //[[https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#substring(int,%20int)|str.substring(start, end)]]// - retourne le sous-string à partir de la position //start// jusqu'à la position //end// (si le dernier paramètre manque - jusqu'a le fin du chaine)
   * //[[https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#split(java.lang.String)|str.split(regex)]]// - divise le string dans un array avec des éléments séparés correspondant a l'expression reguliere //regex//
   * //[[https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#toUpperCase()|str.toUpperCase()]]// - retourne un nouveau string avec toutes les lettres majuscules
   * //[[https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#toLowerCase()|str.toLowerCase()]]// - retourne un nouveau string avec toutes les lettres minuscules
-  * //[[https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#indexOf(int)|str.indexOf(chr)]]// - retourne l'index de la premiere occurence du charactere //chr//
+  * //[[https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#indexOf(int)|str.indexOf(chr)]]// - retourne l'index de la premiere occurence du caractère //chr//
-  * //[[https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#lastIndexOf(int)|str.lastIndexOf(chr)]]// - retourne l'index de la derniere occurence du charactere //chr//
+  * //[[https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#lastIndexOf(int)|str.lastIndexOf(chr)]]// - retourne l'index de la dernière occurence du caractères //chr//
-  * //str.trim()//([[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/Trim|EN]], [[https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/String/trim|FR]]) - on supprime tous les espaces du début et de la fin du string
+  * //[[https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#trim()|str.trim()]]// - on supprime tous les espaces du début et de la fin du string
-  * //str.startsWith(search, index)//([[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith|EN]], [[https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/String/startsWith|FR]]) - détermine si une chaîne commence par les caractères de //search//
+  * //[[https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#startsWith(java.lang.String)|str.startsWith(search, index)]]// - détermine si une chaîne commence par les caractères de //search//
-  * //str.endsWith(search, index)//([[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith|EN]], [[https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/String/endsWith|FR]]) - détermine si une chaîne se termine par les caractères de //search//
+  * //[[https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#endsWith(java.lang.String)|str.endsWith(search, index)]]// - détermine si une chaîne se termine par les caractères de //search//
-  * //str.replace(subStr, newSubStr)//([[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace|EN]], [[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace|FR]]) - retourne un nouveau string avec //newSubStr// au lieu de //subStr//
+  * //[[https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#replace(java.lang.CharSequence,%20java.lang.CharSequence)|str.replace(subStr, newSubStr)]]// - retourne un nouveau string avec //newSubStr// au lieu de //subStr//
-  * //str.charAt(index)//([[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/charAt|EN]], [[https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/String/charAt|FR]]) - retourne le caractère qui se trouve a la position //index//
+===== Fonctions =====
+En Java, toutes les méthodes (ausi nommées //fonctions// doivent être dans classes.
+<code java>
+       public class Main {
+            static void print() {
+                 System.out.println("Hello World!");
+            }
+            public static void main(String[] args) {
+                 print();
+            }
+       }
+</code>
+===== Arguments de la ligne de commande =====
+Les arguments de la ligne de commande pour Java sont passés au programme dans un array **args**. Le tableau est un paramètre pour la fonction //main//.
+<code java>
+       class Main {
+            public static void main(String[] args) {
+                 for(int i = 0; i < args.length; i++){
+                       System.out.println(args[i]);
+                 }
+            }
+       }
+</code>
+Pour donner des arguments dans la ligne de commande, on doit compiler (avec la commande **javac**) et executer (avec la commande **java**) le programme Java dans le **Terminal**. Pour l'exemple précèdent, après execution, le programme affichera les arguments données.
+<code bash>
+        > javac Main.java
+        > java Main.java A B 23 C
+        A
+        B
+
+        C
+</code>
+===== Fonctions parseInt et parseFloat =====
+=== parseInt() ===
+La fonction //[[https://docs.oracle.com/javase/7/docs/api/java/lang/Integer.html#parseInt(java.lang.String)|parseInt()]]// analyse une chaîne de caractère fournie comme parametre et renvoie un entier.
+<code java>
+        String a = "42";
+        int b = Integer.parseInt(a);
+        System.out.println(b); // 42
+</code>
+=== parseFloat() ===
+La fonction //[[https://docs.oracle.com/javase/7/docs/api/java/lang/Float.html#parseFloat(java.lang.String)|parseFloat()]]// permet de transformer une chaîne de caractères en un nombre réel.
+<code java>
+        String a = "42.93";
+        float b = Float.parseFloat(a);
+        System.out.println(b); // 42.93
+</code>
+===== Exercices =====
+<note warning>
+N’oubliez pas de **télécharger sur GitHub** ce que vous avez résolu jusqu'à la **fin** du TP!
+</note>
+  - Créez un programme et exécutez-le avec des paramètres dans la ligne de commande. Affichez : (**1p**)
+    - la liste des paramètres avec //System.out.println()//;
+    - le nombre de paramètres;
+    - les paramètres indexés, affichés avec un //for//;
+  - Faites un programme qui contient une fonction //power// qui reçoit deux nombres comme paramètres, qui calcule la puissance et qui : (**1p**)
+    - affiche le résultat
+    - retourne le résultat
+    - stocke le résultat dans une variable et l'affiche
+  - A l'aide des classes, créez un nouveau type de données nommé Employé, qui contienne les champs : //nom//, //prénom//, //département//, //expérience// (numéro) et les méthodes suivantes: (**2p**)
+    - Créez un objet de type Employée qui recoit ses paramètres de la ligne de commande (''java Main.java NomEmp PrenomEmp ALF 3'')
+    - Affichez chaque attribut de l'objet
+    - Faites un array avec 3 objets de type //Employee//
+    - Affichez l'étudiant avec la plus grande expérience
+    - Affichez la moyenne géométrique des années d'expérience de tous les employés
+    - Affichez la personne avec le prénom le plus longue
+    - Affichez tous les objets en ordre alphabétique apres le nom de famille
+  - Utilisez la même classe Employé de l'exercice précedent (**1.5p**)
+    - Créez une sous-classe Manager, dérivée de la classe Employé, qui contient un champ supplémentaire //noSubordonnés// (number)
+    - Créez un objet de type Manager
+    - Créez une fonction qui recoit comme paramètre un string (nom d'une propriété) et qui vérifie si l'objet de type Manager a la propriété indiquée
+  - Écrivez un programme qui retourne un tableaux avec les sous-strings d'un string donnée. (ex: ['c', 'co', 'cod', 'o', 'od', 'd'] pour le string //cod//) (**1p**)
+  - Soit un objet de type Manager. Ecrivez un programme pour le convertir dans une liste de paires [key, value]. Par example: (**1.5p**)<code java>
+        Manager newManager = new Manager("LastName", "FirstName", "Departement", 10, 30);
+        // Implementez la methode toMap()
+        System.out.println(newManager.toMap()); // {nom=LastName, prenom=FirstName, departement=Departement, experience=10, noSubordonnes=30}</code>
+  - Soit les classes suivantes. Définissez la classe Person et apportez les modifications nécessaires de sorte que le programme affiche la liste des objets de type Person (**1.5p**) <code java>
+        // User.java
+        public interface User {
+           public void logPerson();
+        }
+        // Admin.java
+        public abstract class Admin {
+           public String name;
+           public int age;
+           public String role;
+        }
+        // Person.java
+        /* TODO */
+        // Main.java
+        public static void main(String[] args) {
+            Person[] persons = {
+                new Person("John Doe", 25, "Administrator"),
+                new Person("Jane Doe", 32, "Manager")
+            };
+            for (Person p : persons)
+            {
+                p.logPerson(); // Name: John Doe, Age: 25, Role: Administrator; Name: Jane Doe, Age: 32, Role: Manager
+            }
+        }</code>
+  - On dit qu'une phrase est //pangram// si elle utilise toutes les lettres d'un alphabet donné. En utilisant la classe ci-dessous, définissez les éléments manquants afin de vérifier si une phrase choisie par vous est //pangram//. Testez aussi le code dans //main//. (**1.5p**) <code java>
+   public class Pangram {
+       private String alphabet = "abcdefghijklmnopqrstuvwxyz";
+       private String phrase;
+       public Pangram(String phrase){
+            /* TODO */
+       }
+       public boolean isPangram(){
+            /* TODO */
+            return true;
+       }
+   }
+</code>

Cours

TP

Simplifiee

Seminaires

Devoir

Ressources

alf/laboratoare/01_fr_java.1677956532.txt.gz · Last modified: 2023/03/04 21:02 by alexandra.negoita02

Show page Old revisions

Media Manager Back to top