1. Calcul des carrés

Voici un programme qui calcule et affiche les carrés des entiers de 1 à 10.

public class CalculCarre {
    public static void main(String[] args) {
        int resultat;
        
        for (int i = 1; i <= 10; i++) {
            resultat = carre(i);
            System.out.println("Le carré de " + i + " est " + resultat);
        }
    }

    public static int carre(int nombre) {
        return nombre * nombre;
    }
}

2. Génération de nombres aléatoires avec Math.random()

Ce programme génère 20 nombres aléatoires entre 1 et 6 et les affiche dans une boîte de dialogue.

import javax.swing.JOptionPane;

public class GenerateurAleatoire {
   public static void main(String[] args) {
      int valeur;
      String sortie = "";

      for (int compteur = 1; compteur <= 20; compteur++) {
         valeur = 1 + (int) (Math.random() * 6);
         sortie += valeur + "  ";
         
         if (compteur % 5 == 0)
            sortie += "\n";
      }

      JOptionPane.showMessageDialog(null, sortie,
         "20 nombres aléatoires entre 1 et 6",
         JOptionPane.INFORMATION_MESSAGE);

      System.exit(0);
   }
}

3. Utilisation de la classe Random

Démonstration des différentes méthodes de génération de valeurs aléatoires avec la classe Random.

import java.util.*;

public class DemoRandom {
    public static void main(String[] args) {
        Random generateur = new Random();
        
        System.out.println("Booléen : " + generateur.nextBoolean());
        
        byte[] tampon = new byte[16];
        generateur.nextBytes(tampon);
        System.out.println("Octets : " + Arrays.toString(tampon));
        
        System.out.println("Double : " + generateur.nextDouble());
        System.out.println("Float : " + generateur.nextFloat());
        System.out.println("Gaussien : " + generateur.nextGaussian());
        System.out.println("Entier : " + generateur.nextInt());
        System.out.println("Entier < 26 : " + generateur.nextInt(26));
        System.out.println("Long : " + generateur.nextLong());
    }
}

4. Simulation de lancers de dé

Simluation de 6000 lancers d'un dé à six faces avec comptage des fréquences.

import javax.swing.*;

public class LancerDe {
   public static void main(String[] args) {
      int freq1 = 0, freq2 = 0, freq3 = 0, 
          freq4 = 0, freq5 = 0, freq6 = 0, face;
   
      for (int lance = 1; lance <= 6000; lance++) {
         face = 1 + (int) (Math.random() * 6);
   
         switch (face) {
            case 1: freq1++; break;
            case 2: freq2++; break;
            case 3: freq3++; break;
            case 4: freq4++; break;
            case 5: freq5++; break;
            case 6: freq6++; break;
         }
      }

      JTextArea zoneSortie = new JTextArea(7, 10);
      zoneSortie.setText(
         "Face\tFréquence" +
         "\n1\t" + freq1 +
         "\n2\t" + freq2 +
         "\n3\t" + freq3 +
         "\n4\t" + freq4 +
         "\n5\t" + freq5 +
         "\n6\t" + freq6);

      JOptionPane.showMessageDialog(null, zoneSortie,
         "6000 lancers de dé",
         JOptionPane.INFORMATION_MESSAGE);
      
      System.exit(0);
   }
}

5. Méthodes avec arguments variables

Implémentation d'une méthode qui trouve le maximum parmi un nombre varibale d'arguments.

public class ArgumentsVariables {
    public static double maximum(double... valeurs) {
        double max = Double.NEGATIVE_INFINITY;
        for (double val : valeurs) {
            if (val > max) max = val;
        }
        return max;
    }

    public static void main(String[] args) {
         System.out.println("Maximum : " + maximum(1, 11, 300, 2, 3));
    }
}

6. Surcharge de méthodes

Exemple de surcharge de méthode pour calculer le carré de différents types numériques.

public class SurchargeMethode {
    public static void main(String[] args) {
        System.out.println("Carré de l'entier 7 : " + carre(7));
        System.out.println("Carré du décimal 7.5 : " + carre(7.5));
    }

    public static int carre(int x) {
        return x * x;
    }

    public static double carre(double y) {
        return y * y;
    }
}

Pricnipes de surcharge :

• Les méthodes surchargées sont sélectionnées selon le type des paramètres passés
• Conditions requises :
  • Même nom de méthode
  • Différence dans les types, le nombre ou l'ordre des paramètres

7. Calcul factoriel par récursivité

Deux implémentations du calcul factoriel : avec long et avec BigInteger pour les grands nombres.

import java.math.BigInteger;
import java.util.Scanner;

public class Factorielle {
    public static void main(String[] args) {
        Scanner lecteur = new Scanner(System.in);
        int n = lecteur.nextInt();
        System.out.println(n + "! = " + calculFactorielBig(n));
    }
    
    public static long calculFactoriel(int n) {
        if (n <= 1) return 1;
        return n * calculFactoriel(n - 1);
    }

    public static BigInteger calculFactorielBig(int n) {
        if (n <= 1) return BigInteger.ONE;
        return BigInteger.valueOf(n).multiply(calculFactorielBig(n - 1));
    }
}