Modularität in Java Schritt für Schritt erklärt Beispiel [2022]
Veröffentlicht: 2021-01-02Wenn Sie Java-Programmierer werden möchten, stehen Ihnen zahlreiche Möglichkeiten offen. Im Durchschnitt verdient ein Java-Programmierer etwa 69.722 $ pro Monat, was eine ansehnliche Auszahlung ist . Erfahren Sie mehr über das Gehalt für Java-Entwickler in Indien. Wenn Sie eine solide Karriere in der Java-Programmierung anstreben, sollten Sie zuerst Modularität lernen. Es ist einer der wichtigsten Bestandteile der modernen Softwareprogrammierung. Lassen Sie uns zunächst verstehen, was ein Modul ist.
Was ist Modularität in Java?
Ein Modul ist eher wie eine unabhängige Softwarepartition, die über eine Schnittstelle kommuniziert wird. Modularität untersucht die Erstellung eines Programms durch die Verwendung verschiedener Module als eine einzelne Legacy-Architektur. Es ist eher wie Microservices in einer MVC-Architektur, wo das gesamte System eine Suite unabhängiger Dienste ist.
Bei der Modularität optimiert die Aufteilung der Softwareumgebung in verschiedene Module den gesamten Prozess und reduziert den Kopplungseffekt. Es hilft Java-Entwicklern, unterwegs Funktionstests durchzuführen, während der Entwicklungsprozess gleichzeitig läuft.
Die Modularität in Java stellt sicher, dass die Entwicklungszeit durch schnelles Testen und Debuggen verkürzt wird.
Jetzt, da wir über Modularität Bescheid wissen, wollen wir verstehen, warum Sie sie brauchen?
Lesen Sie: Fragen und Antworten zu Java-Interviews
Melden Sie sich für Software Engineering-Kurse an den besten Universitäten der Welt an. Verdienen Sie Executive PG-Programme, Advanced Certificate-Programme oder Master-Programme, um Ihre Karriere zu beschleunigen.
Warum brauchen wir Java-Modularität?
Modularität hilft einem Java-Entwickler auf drei Arten:
Wiederverwendbarkeit: Wiederverwendbarkeit kann Entwicklern helfen, Zeit zu sparen, indem sie denselben Code verwenden, während sie eine neuere Version der Software oder App erstellen. Mit der Modularität in Java können Sie die Module an anderer Stelle als die ursprünglich entwickelte Software wiederverwenden.
Stabilität: Modularität trägt dazu bei, die Stabilität der Software aufrechtzuerhalten, während Änderungen in einzelnen Abschnitten des Codes vorgenommen werden. Das bedeutet, dass die neuen Modifikationen den Verbrauchern verborgen bleiben und einfach getestet werden können, ohne die vorhandene Software zu beeinträchtigen.
Parallele Entwicklung: Java-Entwickler können schnell Module parallel zueinander entwickeln. Sind alle Module einmal entwickelt, können sie über eine Schnittstelle zu einer Suite kombiniert werden. Die parallele Entwicklung kann Zeit sparen.
Lassen Sie uns nun verschiedene Aspekte der Modularität in Java untersuchen.
Obwohl die Modularität in Java 9 eingeführt wurde, werden wir das Konzept für Java 11 anhand eines einfachen Beispiels für die Erstellung eines Taschenrechners untersuchen. Wir werden einen einfachen und dennoch fortschrittlichen Rechner erstellen, der Primzahlen überprüft, ihre Summe berechnet, ob eine Zahl gerade ist oder nicht.
Schritt 1: Erstellen des Moduls
Der erste Schritt besteht darin, Module zu erstellen, und Sie können je nach Komplexität mehrere Module erstellen. Hier erstellen wir zwei unterschiedliche Module,
- Mathematik. util-Modul
- Rechnermodul
Das erste Modul hat eine API oder Anwendungsprogrammschnittstelle zum Ausführen mathematischer Berechnungen. Gleichzeitig startet das zweite Modul den Rechner.
Schritt 2: Ausführen der Module
Wir werden das API-Modul im Browser ausführen, indem wir es in der Klasse com.upgrad.math.MathUtil implementieren.
public static Boolean isPrime(Ganzzahl){
if ( number == 1 ) { return false; }
return IntStream.range(2,num).noneMatch(i -> num % i == 0 );
}
Wir können das Modul mit einer Funktion überprüfen.
public static Boolean isEven(Ganzzahl){
Rückgabenummer % 2 == 0;
}
Wenn Sie daran denken, die Zahlen darauf zu überprüfen, ob sie gerade oder ungerade sind, können wir eine andere Funktion ausführen.
public static Integer sumOfFirstNEvens(Integer count){
return IntStream.iterate(1,i -> i+1)
.filter(j -> isEven(j))
.limit(count).sum();
}
public static Integer sumOfFirstNOdds(Integer count){ return IntStream.iterate(1,i -> i+1) .filter(j -> !isEven(j)) .limit(count).sum(); }
Bisher haben wir zwei Funktionen auf den API-Modellen ausgeführt und die folgenden Beobachtungen gemacht.
- Es gibt eine unendliche Folge, die bei Nummer 1 beginnt
- Die Filterung der Zahlen wird wiederholt.
- Der Zahlenstrom ist begrenzt.
- Die Summe der Zahlen finden
Basierend auf diesen Beobachtungen kann ein Entwickler die API umgestalten und ausführen.
Ganzzahl computeFirstNSum(Ganzzahlzahl,
IntPredicate-Filter){
return IntStream.iterate(1,i -> i+1)
.filter(Filter)
.limit(count).sum();
}
Hier müssen wir die Summe der Zahlen finden, die durch die Anzahl begrenzt ist. Wir müssen auch den Filter für Zahlen in Bedingungen finden, für die summiert werden soll.
Lassen Sie uns die APIs basierend auf den neuen Bedingungen, die wir untersucht haben, neu erstellen.
öffentliche statische Ganzzahl sumOfFirstNPrimes(Ganzzahlzahl){
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)));
Nachdem wir die APIs getestet und umgestaltet haben, platzieren wir die Klasse com.upgrad.math.MathUtil in einem Modul.
Schritt 3: Dienstprogrammklasse in ein Modul einfügen
Um eine kleine Utility-Klasse in das Modul namens math. util, müssen Sie einige Konventionen befolgen, wie z
- Legen Sie den gesamten Code für das API-Modul in einem Verzeichnis mit demselben Namen ab und verwenden Sie es als Stammverzeichnis.
- Fügen Sie module-info.java in den Stammordner ein
- Platzieren Sie alle Pakete und Codes im Stammverzeichnis.
Schritt 4: Erstellen einer Moduldefinition für den Taschenrechner
Wir werden ein Modul eines Taschenrechners erstellen, das math.utl benötigt.
Modulrechner{
benötigt math.util;
}
Wir können den Code folgendermaßen kompilieren:
javac -d mods –Modulquellpfad . $(finde . -name „*.java“)
Sobald wir die Codes aus den Modulen „calculator“ und „math.utl“ im Verzeichnis „mods“ kompiliert haben, enthält ein einziger Befehl Abhängigkeiten zwischen diesen beiden Modulen, was über einen Compiler erfolgt. Es ist nicht erforderlich, spezielle Tools zu erstellen, um Abhängigkeiten zwischen Taschenrechner und maths.utl herzustellen.
Schritt 5: Führen Sie den Code aus
Sobald Sie sowohl die Module im Mods-Verzeichnis als auch die Abhängigkeiten eingerichtet haben, ist es jetzt an der Zeit, den Code auszuführen. Die Ausführung bringt unseren einfachen und erweiterten Rechner zum Einsatz.
java –Modulpfad mods -m Rechner/com.upgrad.calculator.Calculator
Muss gelesen werden: Interessante Java-Projekte und -Themen
Fazit
Laut einer Umfrage ist Java die zweithöchste bevorzugte Sprache in Bezug auf eine neue Stellenausschreibung, was es zu einer großartigen Wahl für Anfänger macht.
Wenn Sie mehr über Java, OOPs und Full-Stack-Softwareentwicklung erfahren möchten, schauen Sie sich das Executive PG-Programm in Full-Stack-Softwareentwicklung von upGrad & IIIT-B an, das für Berufstätige konzipiert ist und mehr als 500 Stunden strenge Schulungen bietet. Über 9 Projekte und Aufgaben, IIIT-B-Alumni-Status, praktische praktische Abschlussprojekte und Arbeitsunterstützung bei Top-Unternehmen.
