Dieser Artikel beschreibt die zehn wichtigsten Gebote, die Java-Entwickler kennen müssen. Teilen Sie es als Referenz mit allen. Die Details lauten wie folgt:
Als Java-Entwickler ist die Verbesserung der Qualität und Wartbarkeit des eigenen Codes ein ständiges Thema. Ich habe diesen Artikel online gesehen und ihn dazu genutzt, mich selbst zu ermutigen.
Es gibt viele Standards und Best Practices für Java-Entwickler. In diesem Artikel werden die zehn Grundregeln aufgeführt, die jeder Entwickler befolgen muss. Wenn es Regeln gibt, die befolgt, aber nicht befolgt werden können, wird dies zu einem sehr tragischen Ende führen.
1. Fügen Sie Ihrem Code Kommentare hinzu
Jeder weiß das, vergisst aber irgendwie, es zu befolgen. Zählen Sie, wie oft Sie „vergessen“ haben, eine Anmerkung hinzuzufügen? Es stimmt: Kommentare tragen nicht wesentlich zur Funktionalität des Programms bei. Sie müssen jedoch immer wieder, möglicherweise ein Leben lang, auf den Code zurückgreifen, den Sie vor zwei Wochen geschrieben haben, und dürfen sich nicht daran erinnern, warum sich der Code so verhält. Wenn diese Codes Ihnen gehören, haben Sie relativ viel Glück. Weil es Erinnerungen wecken könnte. Aber leider gehört der Code oft jemand anderem und es besteht eine gute Chance, dass er das Unternehmen verlassen hat.
2. Machen Sie die Dinge nicht komplizierter
Ich habe es schon einmal gemacht, und ich bin sicher, dass es jeder getan hat. Entwickler finden oft eine Lösung für ein einfaches Problem. Wir haben EJBs für eine Anwendung mit nur 5 Benutzern eingeführt. Wir verwenden ein Framework für eine Anwendung, die es nicht einmal benötigt. Wir haben der Anwendung Eigenschaftendateien, objektorientierte Lösungen und Threads hinzugefügt, sie benötigte diese jedoch überhaupt nicht. Warum machen wir das? Einige von uns tun es, weil wir nicht wissen, wie wir es besser machen können, aber einige von uns tun es, um neues Wissen zu erlernen und die Anwendung für uns selbst interessanter zu machen.
3． Denken Sie daran: „Weniger ist mehr“ ist nicht immer gut
Codeeffizienz ist eine tolle Sache, aber in vielen Fällen wird der Code nicht effizienter, wenn weniger Codezeilen geschrieben werden. Bitte lassen Sie mich Ihnen ein einfaches Beispiel zeigen.
if(newStatusCode.equals("SD") && (sellOffDate == null || todayDate.compareTo(sellOffDate)<0 || (lastUsedDate != null && todayDate.compareTo(lastUsedDate)>0)) || (newStatusCode.equals ("OBS") && (OBSDate == null || todayDate.compareTo(OBSDate)<0))){ newStatusCode = "NYP";} Ich möchte fragen: Ist es leicht zu sagen, was die if-Bedingung des obigen Codes bewirken möchte? Nehmen wir nun an, dass derjenige, der diesen Code geschrieben hat, Regel Nummer eins nicht befolgt hat: Fügen Sie Kommentare zu Ihrem Code hinzu.
Wäre es nicht einfacher, wenn wir diese Bedingung in zwei separate if-Anweisungen aufteilen würden? Betrachten Sie nun den folgenden korrigierten Code:
if(newStatusCode.equals("SD") && (sellOffDate == null || todayDate.compareTo(sellOffDate)<0 || (lastUsedDate != null && todayDate.compareTo(lastUsedDate)>0))){ newStatusCode = "NYP ";}else if(newStatusCode.equals("OBS") && (OBSDate == null || todayDate.compareTo(OBSDate)<0)){ newStatusCode = "NYP";}Wäre es nicht besser lesbar? Ja, wir haben die Anweisungsbedingung wiederholt. Ja, wir haben ein zusätzliches „IF“ und zwei zusätzliche Klammerpaare. Aber der Code ist besser lesbar und verständlich.
4. Bitte keinen harten Code
Entwickler vergessen oder ignorieren diese Regel oft bewusst, weil wir wie immer in Eile sind. Wenn wir diese Regel befolgen, geraten wir möglicherweise in Verzug. Möglicherweise können wir unseren gegenwärtigen Zustand nicht beenden. Aber wie viel Zeit würde es uns kosten, eine zusätzliche Codezeile zu schreiben, die statische Konstanten definiert?
Hier ist ein Beispiel.
public class A { public static final String S_CONSTANT_ABC = "ABC"; public boolean methodA(String sParam1){ if(A.S_CONSTANT_ABC.equalsIgnoreCase(sParam1)){ return true }}Jetzt müssen wir jedes Mal, wenn wir die Zeichenfolge „ABC“ mit einer Variablen vergleichen müssen, nur auf S_CONSTANT_ABC verweisen, anstatt uns an den tatsächlichen Code zu erinnern. Es hat auch den Vorteil, dass es einfacher ist, eine Konstante an einer Stelle zu ändern, anstatt im gesamten Code danach zu suchen.
5. Erfinden Sie keine eigenen Frameworks
Tausende Frameworks wurden eingeführt, die meisten davon sind Open Source. Viele dieser Frameworks sind hervorragende Lösungen und werden in Tausenden von Anwendungen verwendet. Sie müssen mit diesen neuen Rahmenbedingungen Schritt halten, zumindest oberflächlich. Unter diesen hervorragenden und weit verbreiteten Frameworks ist Struts eines der besten und direktesten Beispiele. Von allen Frameworks, die Sie sich vorstellen können, ist dieses Open-Source-Webframework ein perfekter Kandidat für webbasierte Anwendungen. Aber Sie müssen sich an die zweite Regel erinnern: Machen Sie die Dinge nicht kompliziert. Wenn Sie eine Anwendung mit nur drei Seiten entwickeln, verwenden Sie bitte keine Struts. Bei einer solchen Anwendung gibt es nichts, um die Anforderungen zu „kontrollieren“.
6. Drucken Sie keine Zeilen und fügen Sie keine Zeichenfolgen hinzu
Ich weiß, dass Entwickler zu Debugging-Zwecken System.out.println gerne überall dort hinzufügen, wo wir es für richtig halten, und wir sagen uns, dass wir diesen Code später löschen werden. Aber wir vergessen oft, diese Codezeilen zu löschen, oder wir wollen sie einfach nicht löschen. Warum können wir nach Abschluss des Tests immer noch auf sie zugreifen? Möglicherweise löschen wir eine Codezeile, die wir tatsächlich benötigen, einfach weil Sie den durch System.out.println verursachten Schaden unterschätzt haben. Betrachten Sie den folgenden Code:
public class BadCode { public static void BerechnungWithPrint(){ double someValue = 0D; for (int i = 0; i < 10000; i++) { System.out.println(someValue = someValue + i); ){ double someValue = 0D; for (int i = 0; i < 10000; i++) { someValue = someValue + i; } } public static void main(String [] n) { BadCode.calculationWithOutPrint();In der folgenden Tabelle können Sie sehen, dass die Ausführung der Methode „calculationWithOutPrint()“ 0,001204 Sekunden dauerte. Im Vergleich dazu dauerte die Ausführung der Methode „calculationWithPrint()“ erstaunliche 10,52 Sekunden.
(Wenn Sie nicht wissen, wie Sie eine solche Tabelle erhalten, lesen Sie bitte meinen Artikel „Java Profiling with WSAD“ Java Profiling with WSAD)
Der beste Weg, eine solche CPU-Verschwendung zu vermeiden, ist die Einführung einer Wrapper-Methode wie der folgenden
public class BadCode { public static final int DEBUG_MODE = 2; public static voidCalculationWithPrint(int logMode){ double someValue = 0D; i < 10000; i++) { someValue = someValue + i; myPrintMethod(logMode, someValue); public static void myPrintMethod(int logMode, double value) { if (logMode > BadCode.DEBUG_MODE) { return; } System.out.println(value); } public static void main(String [] n) { BadCode.calculationWithPrint(BadCode.PRODUCTION_MODE) ; }}In der Abbildung unten sehen Sie, dass die Ausführung der Methode mit StringBuffer nur 0,01 Sekunden dauerte, während die Ausführung der Methode mit String-Addition 0,08 Sekunden dauerte. Die Wahl liegt auf der Hand.
7． Folgen Sie der GUI
So lächerlich das auch klingen mag, ich sage es immer wieder: GUI ist für Geschäftskunden genauso wichtig wie Funktionalität und Leistung. Die GUI ist ein wesentlicher Bestandteil eines erfolgreichen Systems. (Allerdings neigen IT-Magazine oft dazu, die Bedeutung von GUIs zu ignorieren. Viele Unternehmen sparen Geld, indem sie keine Designer einstellen, die über umfassende Erfahrung im Entwerfen „benutzerfreundlicher“ GUIs verfügen. Java-Entwickler sind auf ihre eigenen HTML-Kenntnisse angewiesen, allerdings sind ihre Kenntnisse in diesem Bereich sehr begrenzt. Ich habe viele solcher Apps gesehen: Sie sind „computerfreundlich“, nicht „benutzerfreundlich“. Ich sehe selten einen Entwickler, der sich sowohl mit Softwareentwicklung als auch mit GUI-Entwicklung auskennt. Wenn Sie der unglückliche Entwickler sind, der mit der Entwicklung einer Benutzeroberfläche beauftragt wurde, sollten Sie diese drei Grundsätze befolgen:
1. Erfinden Sie das Rad nicht neu. Suchen Sie nach vorhandenen Systemen mit ähnlichen Anforderungen an die Benutzeroberfläche.
2. Erstellen Sie zunächst einen Prototyp. Dies ist ein sehr wichtiger Schritt. Kunden möchten gerne sehen, was sie bekommen. Es ist auch großartig für Sie, weil Sie deren Feedback einholen, bevor Sie alles daran setzen, eine Benutzeroberfläche zu erstellen, die sie verärgert.
3. Tragen Sie den Hut des Benutzers. Mit anderen Worten: Untersuchen Sie die Anforderungen der Anwendung aus der Sicht des Benutzers. Beispielsweise, ob eine Zusammenfassungsseite paginiert werden soll. Als Softwareentwickler neigen Sie dazu, die Paginierung in einem System zu ignorieren, da Sie dadurch weniger Entwicklungskomplexität haben. Aus Benutzersicht ist dies jedoch nicht die beste Lösung, da die zusammengefassten Daten Hunderte oder Tausende von Zeilen umfassen werden.
8. Bereiten Sie stets dokumentierte Anforderungen vor
Jede Geschäftsanforderung muss dokumentiert werden. Das mag in einigen Märchen zutreffen, in der realen Welt ist es jedoch nicht möglich. Egal wie knapp die Zeit für Ihre Entwicklung ist oder ob der Liefertermin bald naht, Sie müssen immer wissen, dass jede Geschäftsanforderung dokumentiert ist.
9. Unit-Tests, Unit-Tests, Unit-Tests
Ich werde nicht näher darauf eingehen, wie Sie Ihren Code am besten einem Unit-Test unterziehen. Was ich sagen werde ist, dass Unit-Tests durchgeführt werden müssen. Dies ist die grundlegendste Regel der Programmierung. Dies ist das wichtigste aller oben genannten Gesetze, das nicht ignoriert werden darf. Am besten ist es, wenn Sie Kollegen haben, die Unit-Tests für Ihren Code erstellen und testen können. Aber wenn es niemand für Sie tut, müssen Sie es selbst tun. Befolgen Sie beim Erstellen Ihres Unit-Testplans die folgenden Regeln:
1. Schreiben Sie Komponententests, bevor Sie Code schreiben.
2. Schreiben Sie Kommentare in Unit-Tests.
3. Testen Sie alle öffentlichen Methoden, die „interessante“ Funktionen ausführen („interessant“ sind Methoden, die keine Setter oder Getter sind, es sei denn, sie führen Set- und Get-Methoden auf besondere Weise aus).
10． Denken Sie daran: Qualität, nicht Quantität.
Bleiben Sie nicht zu lange im Büro (wenn Sie es nicht müssen). Ich verstehe, dass Produktprobleme, knappe Fristen und unerwartete Ereignisse uns manchmal daran hindern können, pünktlich von der Arbeit zu kommen. Unter normalen Umständen wird der Manager jedoch Mitarbeiter, die zu spät die Arbeit verlassen, nicht wertschätzen und belohnen. Er schätzt sie aufgrund der Qualität der von ihnen hergestellten Produkte. Wenn Sie die oben genannten Regeln befolgen, werden Sie feststellen, dass Ihr Code weniger Fehler aufweist und wartbarer ist. Und das ist der wichtigste Teil Ihres Jobs.
Zusammenfassen
In diesem Artikel gebe ich zehn wichtige Regeln für Java-Entwickler. Es ist wichtig, diese Regeln nicht nur zu kennen, sondern sie auch während des Codierungsprozesses zu befolgen. Hoffentlich helfen uns diese Regeln, bessere Programmierer und Profis zu werden.
Ich hoffe, dass dieser Artikel für alle in der Java-Programmierung hilfreich sein wird.