En Java, une fonction void est une méthode qui ne renvoie aucune valeur. Elle est utilisée lorsque vous souhaitez exécuter un bloc de code sans retourner de résultat. Les fonctions void sont couramment utilisées pour effectuer des opérations ou des actions, telles que l’affichage de messages à l’utilisateur, la modification d’états d’objets, ou l’exécution de tâches sans valeur de retour spécifique.

Dans cet article, nous allons explorer différents exemples d’exercices détaillés sur les fonctions void en Java. Ces exercices couvriront divers aspects des fonctions void, y compris les paramètres, les boucles, les conditions, et l’utilisation de bibliothèques Java standard.

Exercice 1: Affichage de messages simples

Écrivons une fonction void en Java qui affiche un message simple à l’utilisateur.

public class MessagePrinter {
    public static void printMessage() {
        System.out.println("Bonjour! Ceci est un message simple.");
    }

    public static void main(String[] args) {
        // Appel de la fonction printMessage
        printMessage();
    }
}

Dans ce cas, la méthode printMessage est une fonction void qui affiche “Bonjour! Ceci est un message simple.” à la console.

Exercice 2: Affichage de nombres pairs jusqu’à un nombre donné

Écrivons une fonction void en Java qui affiche tous les nombres pairs jusqu’à un nombre donné passé en paramètre.

public class EvenNumbersPrinter {
    public static void printEvenNumbers(int maxNumber) {
        System.out.println("Nombres pairs jusqu'à " + maxNumber + ":");
        for (int i = 0; i <= maxNumber; i++) {
            if (i % 2 == 0) {
                System.out.print(i + " ");
            }
        }
        System.out.println(); // Pour sauter une ligne après l'affichage des nombres pairs
    }

    public static void main(String[] args) {
        // Appel de la fonction printEvenNumbers
        printEvenNumbers(10); // Affiche les nombres pairs jusqu'à 10
    }
}

Dans cet exemple, la méthode printEvenNumbers prend un paramètre maxNumber et affiche tous les nombres pairs jusqu’à ce nombre.

Exercice 3: Modifier les éléments d’un tableau

Écrivons une fonction void en Java qui prend un tableau d’entiers en paramètre et multiplie chaque élément par un facteur donné.

public class ArrayModifier {
    public static void multiplyArrayElementsByFactor(int[] arr, int factor) {
        System.out.println("Tableau original: " + Arrays.toString(arr));
        for (int i = 0; i < arr.length; i++) {
            arr[i] *= factor;
        }
        System.out.println("Tableau après multiplication: " + Arrays.toString(arr));
    }

    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};
        int multiplier = 2;
        multiplyArrayElementsByFactor(numbers, multiplier);
    }
}

Dans ce cas, la méthode multiplyArrayElementsByFactor prend un tableau arr et un facteur factor en paramètres, puis multiplie chaque élément du tableau par le facteur donné.

Ces exercices fournissent une base solide pour comprendre et pratiquer l’utilisation des fonctions void en Java. En pratiquant davantage et en explorant différentes applications, vous pourrez maîtriser cette fonctionnalité essentielle de Java.

Voici quelques cas d’application courants où les fonctions void en Java sont utilisées, accompagnés de solutions :

Gestion des employés

Problème: Vous avez une application de gestion des employés où vous devez ajouter, modifier ou supprimer des employés de la base de données.

Solution: Utilisez des fonctions void pour implémenter les méthodes d’ajout, de modification et de suppression des employés. Par exemple :

public class EmployeeManager {
    public void addEmployee(Employee emp) {
        // Logique pour ajouter un employé à la base de données
    }

    public void updateEmployee(Employee emp) {
        // Logique pour mettre à jour les informations d'un employé dans la base de données
    }

    public void deleteEmployee(Employee emp) {
        // Logique pour supprimer un employé de la base de données
    }
}

Système de réservation de billets

Problème: Vous développez un système de réservation de billets de cinéma en ligne où les utilisateurs peuvent consulter les films disponibles et réserver des billets.

Solution: Utilisez des fonctions void pour gérer les opérations telles que l’affichage des films disponibles, la réservation de billets et la génération de reçus.

public class TicketReservationSystem {
    public void displayAvailableMovies() {
        // Logique pour afficher les films disponibles
    }

    public void bookTickets(int movieId, int numTickets) {
        // Logique pour réserver des billets pour un film donné
    }

    public void generateReceipt(int bookingId) {
        // Logique pour générer un reçu pour une réservation donnée
    }
}

Calculatrice

Problème: Vous concevez une calculatrice en Java qui peut effectuer des opérations arithmétiques telles que l’addition, la soustraction, la multiplication et la division.

Solution: Utilisez des fonctions void pour implémenter les opérations arithmétiques.

public class Calculator {
    public void add(int num1, int num2) {
        int result = num1 + num2;
        System.out.println("Résultat de l'addition: " + result);
    }

    public void subtract(int num1, int num2) {
        int result = num1 - num2;
        System.out.println("Résultat de la soustraction: " + result);
    }

    public void multiply(int num1, int num2) {
        int result = num1 * num2;
        System.out.println("Résultat de la multiplication: " + result);
    }

    public void divide(int num1, int num2) {
        if (num2 != 0) {
            double result = (double) num1 / num2;
            System.out.println("Résultat de la division: " + result);
        } else {
            System.out.println("Division par zéro impossible.");
        }
    }
}

Ces cas d’application démontrent comment les fonctions void peuvent être utilisées pour gérer diverses opérations dans des applications Java sans nécessiter de retour de valeurs spécifiques.

Voici les exercices avancés réécrits avec Void en Java :

Exercice 1: Tri d’un tableau d’entiers

Écrivez une fonction void en Java qui trie un tableau d’entiers dans l’ordre croissant en utilisant l’algorithme de tri à bulles.

Exercice 2: Conversion de chaîne en majuscules

Écrivez une fonction void en Java qui prend une chaîne de caractères en paramètre et convertit tous les caractères en majuscules.

Exercice 3: Comptage des occurrences de mots dans une phrase

Écrivez une fonction void en Java qui prend une phrase en paramètre et compte le nombre d’occurrences de chaque mot dans la phrase.

Exercice 4: Validation de mot de passe

Écrivez une fonction void en Java qui prend un mot de passe en paramètre et valide s’il satisfait à certaines conditions, telles que la longueur minimale, la présence de caractères spéciaux, de chiffres et de lettres majuscules et minuscules.

Exercice 5: Calcul de la somme des chiffres d’un nombre

Écrivez une fonction void en Java qui prend un nombre entier en paramètre et calcule la somme de ses chiffres.

Exercice 6: Affichage d’un motif

Écrivez une fonction void en Java qui prend un entier n en paramètre et affiche un motif, tel qu’un triangle, un carré ou un losange, composé de caractères spécifiques.

Exercice 7: Vérification de palindromes

Écrivez une fonction void en Java qui prend une chaîne de caractères en paramètre et vérifie si elle est un palindrome, c’est-à-dire si elle se lit de la même manière de gauche à droite et de droite à gauche.

Exercice 8: Calcul de la factorielle d’un nombre

Écrivez une fonction void en Java qui prend un entier positif n en paramètre et calcule sa factorielle.

Exercice 9: Recherche de nombres premiers

Écrivez une fonction void en Java qui prend un entier positif n en paramètre et affiche tous les nombres premiers jusqu’à n.

Exercice 10: Génération de nombres aléatoires

Écrivez une fonction void en Java qui génère un certain nombre de nombres aléatoires dans une plage donnée et les affiche à la console.

Ces exercices avancés vous aideront à approfondir votre compréhension des fonctions void en Java et à renforcer vos compétences de programmation.

Tri d’un tableau d’entiers (Tri à bulles)

public class BubbleSort {
    public static void bubbleSort(int[] arr) {
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    // Échange des éléments si arr[j] est plus grand que arr[j+1]
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] arr = {64, 34, 25, 12, 22, 11, 90};
        bubbleSort(arr);
        System.out.println("Tableau trié:");
        for (int i : arr) {
            System.out.print(i + " ");
        }
    }
}

Conversion de chaîne en majuscules

public class StringToUpper {
    public static void toUpperCase(String str) {
        System.out.println("Chaîne en majuscules: " + str.toUpperCase());
    }

    public static void main(String[] args) {
        String input = "exemplE de chaîne";
        toUpperCase(input);
    }
}

Comptage des occurrences de mots dans une phrase

public class WordCount {
    public static void countWords(String sentence) {
        String[] words = sentence.split("\\s+");
        Map<String, Integer> wordCountMap = new HashMap<>();
        for (String word : words) {
            wordCountMap.put(word, wordCountMap.getOrDefault(word, 0) + 1);
        }
        System.out.println("Occurrences des mots:");
        for (Map.Entry<String, Integer> entry : wordCountMap.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }

    public static void main(String[] args) {
        String sentence = "Ceci est une phrase de test avec des mots répétés ceci test";
        countWords(sentence);
    }
}

Validation de mot de passe

public class PasswordValidator {
    public static void validatePassword(String password) {
        boolean isValid = true;
        if (password.length() < 8) {
            isValid = false;
        }
        if (!password.matches(".*\\d.*")) {
            isValid = false;
        }
        if (!password.matches(".*[A-Z].*")) {
            isValid = false;
        }
        if (!password.matches(".*[a-z].*")) {
            isValid = false;
        }
        if (!password.matches(".*[!@#$%^&*()_+\\-=\\[\\]{};':\"\\\\|,.<>\\/?].*")) {
            isValid = false;
        }
        if (isValid) {
            System.out.println("Mot de passe valide.");
        } else {
            System.out.println("Mot de passe invalide.");
        }
    }

    public static void main(String[] args) {
        String password = "Test@123";
        validatePassword(password);
    }
}

Calcul de la somme des chiffres d’un nombre

public class DigitSum {
    public static void sumOfDigits(int num) {
        int sum = 0;
        while (num != 0) {
            sum += num % 10;
            num /= 10;
        }
        System.out.println("Somme des chiffres: " + sum);
    }

    public static void main(String[] args) {
        int number = 12345;
        sumOfDigits(number);
    }
}

Affichage d’un motif

public class PatternPrinter {
    public static void printPattern(int n) {
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print("* ");
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        int rows = 5;
        printPattern(rows);
    }
}

Vérification de palindromes

public class PalindromeChecker {
    public static void checkPalindrome(String str) {
        String reversedStr = new StringBuilder(str).reverse().toString();
        if (str.equals(reversedStr)) {
            System.out.println("La chaîne est un palindrome.");
        } else {
            System.out.println("La chaîne n'est pas un palindrome.");
        }
    }

    public static void main(String[] args) {
        String input = "radar";
        checkPalindrome(input);
    }
}

Calcul de la factorielle d’un nombre

public class FactorialCalculator {
    public static void calculateFactorial(int n) {
        int factorial = 1;
        for (int i = 1; i <= n; i++) {
            factorial *= i;
        }
        System.out.println("Factorielle de " + n + ": " + factorial);
    }

    public static void main(String[] args) {
        int number = 5;
        calculateFactorial(number);
    }
}

Recherche de nombres premiers

public class PrimeNumberFinder {
    public static void findPrimeNumbers(int n) {
        System.out.println("Nombres premiers jusqu'à " + n + ":");
        for (int i = 2; i <= n; i++) {
            if (isPrime(i)) {
                System.out.print(i + " ");
            }
        }
    }

    public static boolean isPrime(int num) {
        if (num <= 1) {
            return false;
        }
        for (int i = 2; i <= Math.sqrt(num); i++) {
            if (num % i == 0) {
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) {
        int limit = 50;
        findPrimeNumbers(limit);
    }
}

Génération de nombres aléatoires

import java.util.Random;

public class RandomNumberGenerator {
    public static void generateRandomNumbers(int n, int min, int max) {
        System.out.println("Nombres aléatoires entre " + min + " et " + max + ":");
        Random rand = new Random();
        for (int i = 0; i < n; i++) {
            int randomNumber = rand.nextInt((max - min) + 1) + min;
            System.out.print(randomNumber + " ");
        }
    }

    public static void main(String[] args) {
        int count = 5;
        int minValue = 1;
        int maxValue = 100;
        generateRandomNumbers(count, minValue, maxValue);
    }
}

Ces solutions fournissent des implémentations fonctionnelles pour chaque exercice avancé, démontrant différentes applications des fonctions void en Java.