diff --git a/DEV3.1/mise_en_page/Boutons.java b/DEV3.1/mise_en_page/Boutons.java new file mode 100644 index 0000000..41c3fa5 --- /dev/null +++ b/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); + } +} \ No newline at end of file diff --git a/DEV3.1/organisation_du_code/galerie/Makefile b/DEV3.1/organisation_du_code/galerie/Makefile new file mode 100644 index 0000000..8cd8979 --- /dev/null +++ b/DEV3.1/organisation_du_code/galerie/Makefile @@ -0,0 +1,7 @@ +JC = javac +JV = java + +SRC = ./src +BUILD = ./build +RES = ./res + diff --git a/DEV3.1/organisation_du_code/galerie/res/Untitled.jpg b/DEV3.1/organisation_du_code/galerie/res/Untitled.jpg new file mode 100644 index 0000000..2611302 Binary files /dev/null and b/DEV3.1/organisation_du_code/galerie/res/Untitled.jpg differ diff --git a/DEV3.1/organisation_du_code/galerie/res/chat.jpg b/DEV3.1/organisation_du_code/galerie/res/chat.jpg new file mode 100644 index 0000000..b46dc5e Binary files /dev/null and b/DEV3.1/organisation_du_code/galerie/res/chat.jpg differ diff --git a/DEV3.1/organisation_du_code/galerie/res/hiboux.jpg b/DEV3.1/organisation_du_code/galerie/res/hiboux.jpg new file mode 100644 index 0000000..5f6f3ea Binary files /dev/null and b/DEV3.1/organisation_du_code/galerie/res/hiboux.jpg differ diff --git a/DEV3.1/organisation_du_code/galerie/src/fr/iutfbleau/galeri/Controller_galerie.java b/DEV3.1/organisation_du_code/galerie/src/fr/iutfbleau/galeri/Controller_galerie.java new file mode 100644 index 0000000..8e95731 --- /dev/null +++ b/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() listeInteger = new ArrayList<>(); // Liste pour les Integer + ArrayList listeFloat = new ArrayList<>(); // Liste pour les Float + ArrayList 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. +*/ \ No newline at end of file diff --git a/DEV3.2/Genericite/exo2.class b/DEV3.2/Genericite/exo2.class new file mode 100644 index 0000000..f6fc19a Binary files /dev/null and b/DEV3.2/Genericite/exo2.class differ diff --git a/DEV3.2/Genericite/exo2.java b/DEV3.2/Genericite/exo2.java new file mode 100644 index 0000000..42b3e81 --- /dev/null +++ b/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. +*/ \ No newline at end of file diff --git a/DEV3.2/Genericite/exo3.class b/DEV3.2/Genericite/exo3.class new file mode 100644 index 0000000..721b695 Binary files /dev/null and b/DEV3.2/Genericite/exo3.class differ diff --git a/DEV3.2/Genericite/exo3.java b/DEV3.2/Genericite/exo3.java new file mode 100644 index 0000000..2c0f9b4 --- /dev/null +++ b/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 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. +*/ \ No newline at end of file diff --git a/DEV3.2/Genericite/exo4.class b/DEV3.2/Genericite/exo4.class new file mode 100644 index 0000000..ba4fb8f Binary files /dev/null and b/DEV3.2/Genericite/exo4.class differ diff --git a/DEV3.2/Genericite/exo4.java b/DEV3.2/Genericite/exo4.java new file mode 100644 index 0000000..b84c72b --- /dev/null +++ b/DEV3.2/Genericite/exo4.java @@ -0,0 +1,54 @@ +public class exo4 { + 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 association1 = new exo4<>("Test", 5); + System.out.println(association1); // Affichera : Element: Test, Frequency: 5 + + // Exemple d'utilisation avec un type Integer + exo4 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 + } +} diff --git a/DEV3.2/Recursiviote/Appel.class b/DEV3.2/Recursiviote/Appel.class new file mode 100644 index 0000000..6d071f9 Binary files /dev/null and b/DEV3.2/Recursiviote/Appel.class differ diff --git a/DEV3.2/Recursiviote/Appel.java b/DEV3.2/Recursiviote/Appel.java new file mode 100644 index 0000000..3262501 --- /dev/null +++ b/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); + } + } +} \ No newline at end of file diff --git a/DEV3.2/Recursiviote/Fibonacci.class b/DEV3.2/Recursiviote/Fibonacci.class new file mode 100644 index 0000000..9b0c6db Binary files /dev/null and b/DEV3.2/Recursiviote/Fibonacci.class differ diff --git a/DEV3.2/Recursiviote/Fibonacci.java b/DEV3.2/Recursiviote/Fibonacci.java new file mode 100644 index 0000000..21d170a --- /dev/null +++ b/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); + } + } +} \ No newline at end of file diff --git a/DEV3.2/Recursiviote/Tableaux.class b/DEV3.2/Recursiviote/Tableaux.class new file mode 100644 index 0000000..6251afb Binary files /dev/null and b/DEV3.2/Recursiviote/Tableaux.class differ diff --git a/DEV3.2/Recursiviote/Tableaux.java b/DEV3.2/Recursiviote/Tableaux.java new file mode 100644 index 0000000..3f50886 --- /dev/null +++ b/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)); + } + } +} \ No newline at end of file