fin des tp

DEV3.1/mise_en_page/Boutons.java

@@ -0,0 +1,66 @@
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.*;
+import java.awt.event.WindowEvent;
+import java.awt.event.WindowAdapter;
+
+public class Boutons implements WindowListener{
+    @Override
+    public void windowClosing(WindowEvent evenement){
+        int confirmed=JOptionPane(null,"Voulez-vous fermer l'application ?","Confirmation de fermeture",JOptionPane.YES_NO_OPTION);
+        if (confirmed==JOptionPane.YES_OPTION){
+            evenement.dispose();
+        }
+    }
+
+    public static void main(String[] args) {
+        JFrame fenetre = new JFrame();
+        fenetre.setSize(500, 300);
+        fenetre.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
+        GridBagConstraints c = new GridBagConstraints();
+        fenetre.setLayout(new GridBagLayout());
+        c.fill=GridBagConstraints.BOTH;
+        JButton etiquette = new JButton("1");
+        c.gridx=0;
+        c.gridy=0;
+        c.gridwidth=2;
+        c.gridheight=1;
+        c.weightx=1;
+        c.weighty=1;
+        fenetre.add(etiquette,c);
+        JButton etiquette1 = new JButton("2");
+        c.gridx=2;
+        c.gridy=0;
+        c.gridwidth=1;
+        c.gridheight=2;
+        c.weightx=1;
+        c.weighty=1;
+        fenetre.add(etiquette1,c);
+        JButton etiquette2 = new JButton("3");
+        c.gridx=1;
+        c.gridy=2;
+        c.gridwidth=2;
+        c.gridheight=1;
+        c.weightx=1;
+        c.weighty=1;
+        fenetre.add(etiquette2,c);
+        JButton etiquette3 = new JButton("4");
+        c.gridx=0;
+        c.gridy=1;
+        c.gridwidth=1;
+        c.gridheight=2;
+        c.weightx=1;
+        c.weighty=1;
+        fenetre.add(etiquette3,c);
+        JButton etiquette4 = new JButton("5");
+        c.gridx=1;
+        c.gridy=1;
+        c.gridwidth=1;
+        c.gridheight=1;
+        c.weightx=0;
+        c.weighty=0;
+        fenetre.add(etiquette4,c);
+        fenetre.setVisible(true);
+        fenetre.addMouseListener(this);
+    }
+}

DEV3.1/organisation_du_code/galerie/Makefile

@@ -0,0 +1,7 @@
+JC = javac
+JV = java
+
+SRC = ./src
+BUILD = ./build
+RES = ./res
+

DEV3.1/organisation_du_code/galerie/src/fr/iutfbleau/galeri/Controller_galerie.java

@@ -0,0 +1,59 @@
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.*;
+
+public class Controller_galerie implements MouseListener{
+    private int indice;
+    private int max_indice;
+    private String[] tab;
+    private JFrame page;
+    private JLabel image;
+
+    public Controller_galerie(String[] tab){
+        this.tab = tab;
+        this.indice = 0;
+        this.max_indice = this.tab.length-1;
+    }
+
+    public void SetPage(JFrame page, JLabel image){
+        this.page = page;
+        this.image = image;
+    }
+    
+    @Override
+    public void mouseClicked(MouseEvent e) {
+        Component taille = (Component) e.getComponent();
+        if (e.getX()>taille.getWidth()/2){
+            if (this.indice == this.max_indice){
+                this.indice = 0;
+            }else{
+                this.indice++;
+            }
+        }else if (e.getX()<taille.getWidth()/2){
+            if (this.indice == 0){
+                this.indice = this.max_indice;
+            }else{
+                this.indice--;
+            }
+        }
+        System.out.println(this.indice);
+        System.out.println(taille.getWidth()/2);
+        this.page.remove(this.image);
+        this.image = new JLabel(new ImageIcon(this.tab[this.indice]));
+        this.image.addMouseListener(this);
+        this.page.add(this.image);
+        this.page.revalidate();
+    }
+
+    @Override
+    public void mouseEntered(MouseEvent e) {}
+
+    @Override
+    public void mouseExited(MouseEvent e) {}
+
+    @Override
+    public void mousePressed(MouseEvent e) {}
+
+    @Override
+    public void mouseReleased(MouseEvent e) {}
+}

DEV3.1/organisation_du_code/galerie/src/fr/iutfbleau/galeri/Galerie.java

@@ -0,0 +1,11 @@
+import javax.swing.*;
+import java.awt.*;
+
+public class Galerie{
+    public static void main(String[] args){
+        String[] tab = {"Untitled.jpg", "chat.jpg", "hiboux.jpg"};
+        Controller_galerie controller = new Controller_galerie(tab);
+        View_galerie vue = new View_galerie();
+        vue.affichage(tab[0],controller);
+    }
+}

DEV3.1/organisation_du_code/galerie/src/fr/iutfbleau/galeri/View_galerie.java

@@ -0,0 +1,15 @@
+import javax.swing.*;
+import java.awt.*;
+
+public class View_galerie{
+    public void affichage(String nom, Controller_galerie controller){
+        JFrame fenetre = new JFrame();
+        fenetre.setSize(500, 300);
+        fenetre.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        JLabel image = new JLabel(new ImageIcon(nom));
+        controller.SetPage(fenetre,image);
+        image.addMouseListener(controller);
+        fenetre.add(image);
+        fenetre.setVisible(true);
+    }
+}

DEV3.2/Genericite/exo1.java

@@ -0,0 +1,44 @@
+import java.util.ArrayList; // Importation de la classe ArrayList
+
+public class exo1 {
+    public static void main(String[] args) {
+        // Création des listes pour stocker différents types
+        ArrayList<Integer> listeInteger = new ArrayList<>(); // Liste pour les Integer
+        ArrayList<Float> listeFloat = new ArrayList<>();     // Liste pour les Float
+        ArrayList<Number> listeNumber = new ArrayList<>();   // Liste pour les Number (peut contenir Integer, Float, etc.)
+
+        // Ajout d'éléments à la liste Integer
+        listeInteger.add(1);
+        listeInteger.add(2);
+        listeInteger.add(3);
+
+        // Ajout d'éléments à la liste Float
+        listeFloat.add(1.0f);
+        listeFloat.add(2.0f);
+        listeFloat.add(3.0f);
+
+        // Affichage des listes pour vérifier leur contenu
+        System.out.println("Liste Integer: " + listeInteger);
+        System.out.println("Liste Float: " + listeFloat);
+        
+        // Transvaser les éléments de listeInteger et listeFloat vers listeNumber
+        listeNumber.addAll(listeInteger); // Ajoute tous les Integer à listeNumber
+        listeNumber.addAll(listeFloat);   // Ajoute tous les Float à listeNumber
+
+        // Affichage de la liste Number après les ajouts
+        System.out.println("Liste Number après ajout: " + listeNumber);
+
+        // Test de l'ajout direct de listeInteger à listeFloat (commenté car cela provoquerait une erreur)
+        // listeFloat.addAll(listeInteger); // Cela provoquerait une erreur de compilation, car Integer n'est pas un Float
+    }
+}
+
+
+/*
+Imports : Expliquent l'importation de la classe ArrayList.
+Création de listes : Indiquent les types des listes créées.
+Ajouts d'éléments : Spécifient ce que l'on ajoute à chaque liste.
+Affichage : Indiquent l'affichage des listes pour vérifier le contenu.
+Transfert des éléments : Expliquent ce qui se passe lors de l'utilisation de addAll.
+Commentaire sur l'ajout direct : Clarifie pourquoi l'ajout d'une liste à une autre pourrait provoquer une erreur.
+*/

DEV3.2/Genericite/exo2.java

@@ -0,0 +1,30 @@
+import java.util.Arrays; // Importation de la classe Arrays
+import java.util.Comparator; // Importation de l'interface Comparator
+
+public class exo2 {
+    public static void main(String[] args) {
+        // Affichage de tous les arguments de la ligne de commande
+        System.out.println("Arguments de la ligne de commande : " + Arrays.toString(args));
+
+        // Affichage des cinq premiers arguments (ou moins s'il n'y en a pas)
+        String[] premiersArguments = Arrays.copyOf(args, Math.min(args.length, 5));
+        System.out.println("Cinq premiers arguments : " + Arrays.toString(premiersArguments));
+
+        // Tri des arguments dans l'ordre du dictionnaire
+        Arrays.sort(args); // Tri des arguments
+
+        // Affichage des arguments triés
+        System.out.println("Arguments triés : " + Arrays.toString(args));
+
+        // Exemple d'utilisation d'un Comparator pour trier par longueur
+        Arrays.sort(args, Comparator.comparingInt(String::length)); // Tri par longueur
+        System.out.println("Arguments triés par longueur : " + Arrays.toString(args));
+    }
+}
+
+/*
+Affichage des arguments : Utilise Arrays.toString(args) pour afficher tous les arguments passés en ligne de commande.
+Affichage des cinq premiers arguments : Utilise Arrays.copyOf pour copier les cinq premiers arguments ou moins.
+Tri des arguments : Utilise Arrays.sort(args) pour trier les arguments par ordre lexicographique.
+Tri par longueur : Utilise un Comparator pour trier les arguments selon leur longueur.
+*/

DEV3.2/Genericite/exo3.java

@@ -0,0 +1,55 @@
+import java.util.HashMap; // Importation de HashMap
+import java.util.Map; // Importation de Map
+
+public class exo3 {
+    public static void main(String[] args) {
+        // Exemple de tableau d'objets
+        Object[] tableau = {1, "apple", 2, "banana", "apple", 3, 2, "banana", "banana"};
+        
+        // Appel de la méthode pour trouver l'élément le plus fréquent
+        Object elementFrequent = trouverElementFrequent(tableau);
+        
+        // Affichage du résultat
+        System.out.println("L'élément le plus fréquent est : " + elementFrequent);
+    }
+
+    public static Object trouverElementFrequent(Object[] tableau) {
+        Map<Object, Integer> compte = new HashMap<>(); // Dictionnaire pour compter les occurrences
+        int maxCount = 0; // Compteur maximal
+        Object elementFrequent = null; // Élément le plus fréquent
+
+        for (int i = 0; i < tableau.length; i++) {
+            Object element = tableau[i];
+            // Incrémenter le compteur pour l'élément actuel
+            compte.put(element, compte.getOrDefault(element, 0) + 1);
+
+            // Vérifier si cet élément a une fréquence plus élevée ou est le premier en cas d'égalité
+            if (compte.get(element) > maxCount || (compte.get(element) == maxCount && elementFrequent == null)) {
+                maxCount = compte.get(element);
+                elementFrequent = element;
+            }
+        }
+
+        return elementFrequent; // Retourner l'élément le plus fréquent
+    }
+}
+
+/*
+mportations :
+
+    HashMap pour stocker les occurrences des éléments.
+    Map pour la déclaration de la variable.
+
+Méthode principale :
+
+    Un tableau d'exemple tableau est créé contenant différents types d'objets.
+    La méthode trouverElementFrequent est appelée pour obtenir l'élément le plus fréquent.
+
+Méthode trouverElementFrequent :
+
+    Crée un HashMap pour compter les occurrences de chaque élément.
+    Utilise une boucle pour parcourir le tableau, mettre à jour les compteurs et vérifier si l'élément actuel est le plus fréquent.
+    En cas d'égalité, le premier élément rencontré avec cette fréquence est privilégié.
+
+Retourne l'élément le plus fréquent : La méthode renvoie l'élément qui apparaît le plus souvent dans le tableau.
+*/

DEV3.2/Genericite/exo4.java

@@ -0,0 +1,54 @@
+public class exo4<E> {
+    private E element;
+    private int frequence;
+
+    // Constructeur
+    public exo4(E element, int frequence) {
+        this.element = element;
+        this.frequence = frequence;
+    }
+
+    // Accesseur pour 'element'
+    public E getElement() {
+        return element;
+    }
+
+    // Modificateur pour 'element'
+    public void setElement(E element) {
+        this.element = element;
+    }
+
+    // Accesseur pour 'frequence'
+    public int getFrequence() {
+        return frequence;
+    }
+
+    // Modificateur pour 'frequence'
+    public void setFrequence(int frequence) {
+        this.frequence = frequence;
+    }
+
+    // Surcharge de la méthode toString()
+    @Override
+    public String toString() {
+        return "Element: " + element + ", Frequency: " + frequence;
+    }
+
+    // Méthode main pour tester la classe
+    public static void main(String[] args) {
+        // Exemple d'utilisation avec un type String
+        exo4<String> association1 = new exo4<>("Test", 5);
+        System.out.println(association1);  // Affichera : Element: Test, Frequency: 5
+
+        // Exemple d'utilisation avec un type Integer
+        exo4<Integer> association2 = new exo4<>(10, 2);
+        System.out.println(association2);  // Affichera : Element: 10, Frequency: 2
+
+        // Modification des valeurs
+        association1.setElement("Updated");
+        association1.setFrequence(10);
+
+        // Vérification de la modification
+        System.out.println(association1);  // Affichera : Element: Updated, Frequency: 10
+    }
+}

DEV3.2/Recursiviote/Appel.java

@@ -0,0 +1,28 @@
+public class Appel{
+    public static int fact(int a, int indentation) {
+        int i;
+        for (i = 0; i < indentation; i++)
+            System.out.print("  ");
+        System.out.println("argument ="+a);
+        if (a == 1) {
+            return 1;
+        } else {
+            int res = a * fact(a-1, indentation+1);
+            for (i = 0; i < indentation; i++)
+                System.out.print("  ");
+            System.out.println("resultat ="+res);
+            return res;
+        }
+    }
+
+    public static void main(String[] argv){
+        if (argv.length < 1){
+            System.err.println("manque un nombre pour le calcul");
+        } else {
+            int ind = 0;
+            int n = Integer.parseInt(argv[argv.length-1]);
+            int res = fact(n, ind);
+            System.out.println(n+"! = "+res);
+        }
+    }
+}

DEV3.2/Recursiviote/Fibonacci.java

@@ -0,0 +1,38 @@
+public class Fibonacci{
+    public static int fibonacci(int x0, int x1, int val, int indentation) {
+        int i;
+        for (i = 0; i < indentation; i++)
+            System.out.print("  ");
+        System.out.println("u0 ="+x0+"u1 ="+x1);
+        if (val == -2) {
+            return x0;
+        } else if (val == -1) {
+            return x1;
+        } else if (val == 0) {
+            return x1;
+        }else {
+            int v = x0;
+            x0 = x1;
+            x1 = v + x1;
+            val--;
+            int res = fibonacci(x0, x1, val, indentation+1);
+            for (i = 0; i < indentation; i++)
+                System.out.print("  ");
+            System.out.println("resultat ="+x1);
+            return res;
+        }
+    }
+
+    public static void main(String[] argv){
+        if (argv.length < 1){
+            System.err.println("manque un nombre pour le calcul de la suite");
+        } else {
+            int x0 = 0;
+            int x1 = 1;
+            int ind = 0;
+            int val = Integer.parseInt(argv[argv.length-1]) - 2;
+            int res = fibonacci(x0, x1, val, ind);
+            System.out.println("Fibonacci de "+(val+2)+"ième terme = "+res);
+        }
+    }
+}

DEV3.2/Recursiviote/Tableaux.java

@@ -0,0 +1,63 @@
+import java.util.Arrays;
+
+public class Tableaux{
+    public static int[] remplir_tab(int val, String[] argv, int[] tab) {
+        if (argv.length == val) {
+            return tab;
+        } else {
+            tab[val] = Integer.parseInt(argv[val]);
+            val++;
+            return remplir_tab(val, argv, tab);
+        }
+    }
+
+    public static int pair_tab(int val, int pair, int[] tab) {
+        if (tab.length == val) {
+            return pair;
+        } else {
+            if (tab[val] % 2 == 0)
+                pair++;
+            val++;
+            return pair_tab(val, pair, tab);
+        }
+    }
+
+    public static int max_tab(int val, int max, int[] tab) {
+        if (tab.length == val) {
+            return max;
+        } else {
+            if (tab[val] > max)
+                max = tab[val];
+            val++;
+            return max_tab(val, max, tab);
+        }
+    }
+
+    public static int[] inverse_tab(int val, int[] tab, int[] inv_tab) {
+        if (tab.length == val) {
+            return inv_tab;
+        } else {
+            inv_tab[val] = tab[tab.length-1-val];
+            val++;
+            return inverse_tab(val, tab, inv_tab);
+        }
+    }
+
+    public static void main(String[] argv){
+        if (argv.length < 1){
+            System.err.println("il faut un nombre au minimum pour le tableau");
+        } else {
+            int[] tab = new int[argv.length];
+            int[] inv_tab = new int[argv.length];
+            int val = 0;
+            int pair = 0;
+            int max = 0;
+            tab = remplir_tab(val, argv, tab);
+            System.out.println(Arrays.toString(tab));
+            System.out.println("nombre de pair ="+pair_tab(val, pair, tab));
+            System.out.println("nombre le plus grand ="+max_tab(val, max, tab));
+            inv_tab = inverse_tab(val, tab, inv_tab);
+            System.out.println(Arrays.toString(inv_tab));
+        }
+    }
+}