La modularité en Java expliquée avec un exemple étape par étape [2022]
Publié: 2021-01-02Lorsque vous vous lancez dans le métier de programmeur Java, il existe de nombreuses opportunités. En moyenne, un programmeur Java gagne environ 69 722 dollars par mois, ce qui représente une belle rémunération . En savoir plus sur le salaire des développeurs Java en Inde. Si vous envisagez de faire une solide carrière dans la programmation Java, la modularité est quelque chose que vous devez d'abord apprendre. C'est l'une des parties essentielles de la programmation logicielle moderne. Alors, commençons par comprendre ce qu'est un module ?
Qu'est-ce que la modularité en Java ?
Un module ressemble plus à une partition indépendante de logiciel qui est communiquée via une interface. La modularité explore la création d'un programme en utilisant des modules différents d'une seule architecture héritée. Cela ressemble plus à des microservices dans une architecture MVC, où l'ensemble du système est une suite de services indépendants.
Avec la modularité, le cloisonnement de l'environnement logiciel en différents modules permet d'optimiser l'ensemble du processus et de réduire l'effet de couplage. Il aide les développeurs Java à effectuer des tests de fonctionnalité en déplacement pendant que le processus de développement se déroule simultanément.
La modularité de Java garantit que le temps de développement est réduit avec des tests et un débogage à la volée.
Maintenant que nous connaissons la modularité, comprenons pourquoi vous en avez besoin ?
Lire: Questions et réponses d'entrevue Java
Inscrivez-vous à des cours de génie logiciel dans les meilleures universités du monde. Gagnez des programmes Executive PG, des programmes de certificat avancés ou des programmes de maîtrise pour accélérer votre carrière.
Pourquoi avons-nous besoin de la modularité Java ?
La modularité aide un développeur Java de trois manières,
Réutilisabilité : la réutilisabilité peut aider les développeurs à gagner du temps en utilisant le même code lors de la création d'une version plus récente du logiciel ou de l'application. Avec la modularité en Java, vous pouvez réutiliser les modules ailleurs que dans le logiciel initialement développé.
Stabilité : la modularité aide à maintenir la stabilité du logiciel tout en apportant des modifications aux sections individuelles du code. Cela signifie que les nouvelles modifications restent cachées aux consommateurs et peuvent être facilement testées sans affecter le logiciel existant.
Développement parallèle : les développeurs Java peuvent développer rapidement des modules parallèles les uns aux autres. Une fois tous les modules développés, ils peuvent être combinés via une interface pour créer une suite. L'utilisation du développement parallèle peut faire gagner du temps.
Explorons maintenant différents aspects de la modularité en Java.
Bien que la modularité ait été introduite dans Java 9, nous explorerons le concept de Java 11 avec un exemple simple de création d'une calculatrice. Nous allons créer une calculatrice simple mais avancée qui vérifie les nombres premiers, calcule leur somme, qu'un nombre soit pair ou non.
Etape 1 : Création du module
La première étape consiste à créer des modules, et vous pouvez choisir de créer plusieurs modules selon la complexité. Ici, nous créons deux modules distincts,
- Math. module utilitaire
- Module calculatrice
Le premier module a une API ou une interface de programme d'application pour exécuter des calculs mathématiques. En même temps, le deuxième module lance la calculatrice.
Etape 2 : Exécution des modules
Nous allons exécuter le module API dans le navigateur en l'implémentant dans la classe com.upgrad.math.MathUtil,
public static Boolean isPrime(Nombre entier){
si ( nombre == 1 ) { renvoie faux ; }
return IntStream.range(2,num).noneMatch(i -> num % i == 0 );
}
Nous pouvons vérifier le module avec une fonction.
public static Boolean isEven(nombre entier){
nombre de retour % 2 == 0 ;
}
Si vous envisagez de vérifier si les nombres sont pairs ou impairs, nous pouvons exécuter une autre fonction.
public static Integer sumOfFirstNEvens(Integer count){
return IntStream.iterate(1,i -> i+1)
.filter(j -> estPair(j))
.limit(count).sum();
}
public static Integer sumOfFirstNOdds(Integer count){ return IntStream.iterate(1,i -> i+1) .filter(j -> !isEven(j)) .limit(count).sum(); }
Jusqu'à présent, nous avons exécuté deux fonctions sur les modèles d'API et fait les observations suivantes.
- Il existe une suite infinie à partir du numéro 1
- Le filtrage des nombres est répété.
- Le flux de chiffres est limité.
- Trouver la somme de nombres
Sur la base de ces observations, un développeur peut refactoriser l'API et l'exécuter.
Nombre entier computeFirstNSum(nombre entier,
filtre IntPredicate){
return IntStream.iterate(1,i -> i+1)
.filter(filtre)
.limit(count).sum();
}
Ici, nous devons trouver la somme des nombres qui est limitée par le nombre. Nous devrons également trouver le filtre pour les nombres dans les conditions pour lesquelles la sommation sera exécutée.
Recréons les API en fonction des nouvelles conditions que nous avons explorées.
public static Integer sumOfFirstNPrimes(Integer count){
return computeFirstNSum(count, (i -> isPrime(i)));
}
public static Integer sumOfFirstNEvens(Integer count){ return computeFirstNSum(count, (i -> isEven(i))); }
public static Integer sumOfFirstNOdds(Integer count){ return computeFirstNSum(count, (i -> !isEven(i)));
Maintenant que nous avons testé les API et les avons refactorisées, plaçons la classe com.upgrad.math.MathUtil dans un module.
Étape 3 : Insertion d'une classe utilitaire dans un module
Pour insérer une petite classe utilitaire dans le module nommé math. util, vous devez suivre certaines conventions comme
- Placez tout le code lié au module API dans un répertoire du même nom et utilisez-le comme répertoire racine.
- Insérez module-info.java dans le dossier racine
- Placez tous les packages et codes dans le répertoire racine.
Étape 4 : Création d'une définition de module pour la calculatrice
Nous allons créer un module d'une calculatrice qui nécessite math.utl.
calculateur de module{
nécessite math.util ;
}
Nous pouvons compiler le code en suivant,
javac -d mods –module-source-path . $(trouver . -nom "*.java")
Une fois que nous avons compilé les codes des modules calculateur et math.utl dans le répertoire mods, une seule commande inclura les dépendances entre ces deux modules, ce qui se fait via un compilateur. Il n'est pas nécessaire de créer des outils dédiés pour créer des dépendances entre la calculatrice et maths.utl.
Étape 5 : Exécutez le code
Une fois que vous avez à la fois les modules dans le répertoire mods et les dépendances en place, il est maintenant temps d'exécuter le code. L'exécution mettra en action notre calculateur simple et avancé.
java –module-path mods -m calculateur/com.upgrad.calculator.Calculator
Doit lire: Projets et sujets Java intéressants
Conclusion
Selon une enquête , Java est le deuxième langage préféré en termes de nouvelles offres d'emploi, ce qui en fait un excellent choix pour les débutants.
Si vous souhaitez en savoir plus sur Java, les OOP et le développement de logiciels à pile complète, consultez le programme Executive PG de upGrad & IIIT-B en développement de logiciels à pile complète qui est conçu pour les professionnels et offre plus de 500 heures de formation rigoureuse, Plus de 9 projets et affectations, statut d'ancien de l'IIIT-B, projets de synthèse pratiques et aide à l'emploi avec les meilleures entreprises.
