Coding specification for Java programs
All procedures development brochures contain various rules. Some customary free proceeders may not be adapted to these rules, but these rules are required in the case of working with multiple developers. This is not only for development efficiency, but also for later maintenance considerations.
Naming conventions
Defining the purpose of this specification is to let all documents in the project look like a person written, increase readability, and reduce the loss caused by the project group. (These norms are not necessarily abolished, but must have a good readability)
● Naming of Package
The name of Package should be composed of a lowercase word.
● Naming of CLASS
The name of the Class must be made of uppercase of uppercase letters and other letters.
● Naming of Class variables
The name of the variable must be started with a lowercase letter. The latter words begin with uppercase letters.
● Naming of Static Final variable
The name of the Static Final variable should be capitalized and point out the full meaning.
● Naming of parameters
The name of the parameter must be consistent with the naming specification of the variable.
● Array name
Arrays should always be named in the following ways:
BYTE [] BUFFER
Instead:
BYTE BUFFER [];
● Parameters of the method
Name the meaningful parameters, if possible, use the name of the field to assign the value:
SetCounter (int size) {
THIS.SIZE = Size;
}
Java file style
All Java (*. Java) files must comply with the following style rules:
● Copyright information
Copyright information must begin at the beginning of the Java file, such as:
/ **
* Copyright? 2000 Shanghai XXX Co. Ltd.
* All right reserved.
* /
Others do not need to appear in Javadoc, can also be included here. ● Package / ImportsPackage Row To be in the IMPORT line, the standard package name in the Import is previously in the local package name and is arranged in alphabetical order. If the IMPORT line contains different subdirectory in the same package, you should use * to process.
Package hotlava.net.stats;
Import java.io. *;
Import java.util.observable;
Import Hotlava.util.Application;
Here Java.IO. * is used instead of InputStream and OutputStream. ● Class next is the annotation of the class, usually used to interpret the class.
/ **
* A class representing a set of packet and byte counters
* It is observable to allow it to be watch, but only
* Reports Changs WHEN THE CURRENT SET IS Complete
* /
Next is a class definition, including extends and imports in different rows:
Public Class Counterset
Extends Observable
Implements Cloneable
● Class Fields Next is the member variable of the class:
/ **
* Packet Counters
* /
protected int [] packets;
Public member variables must generate a document (javadoc). Member variables defined by Proceted, Private and Package If the name meaning is clear, you can not comment. ● Access method Next is the method of access to class variables. It is just simple to get values to assign values to the class variable, you can simply write on one line. / **
* Get the counter
* @Return an array containing the statistical data. this Array Has Been
* Freshly allocated and can be modified by the caller.
* /
Public int [] getpackets () {return copyArray (packets, offset);
Public int [] getBytes () {return copyArray (bytes, offset);
Public int [] getpackets () {return packets;}
Public void setpackets (int [] packets) {this.packets = packets;}
Other methods don't write on a line.
● Constructor Next is a constructor, it should be written in an incremental manner (such as: writing more). Access Type ("Public", "Private", etc.) and any "static", "firm" or "synchronized" should be written in one line, and the methods and parameters can be written separately, which makes the method and parameters easier to read.
public
Counterset (int size) {
THIS.SIZE = Size;
}
● Cloning method
If this class can be cloned, then the next step is Clone method:
public
Object clone () {
Try {
Counterset obj = (counterset) super.clone ();
Obj.packets = (int []) packets.clone ();
Obj.size = size;
Return Obj;
} catch (clonenotsupportedexception e) {
Throw New Internalerror ("Unexpected ClonyNotSupportedException:" E.GetMessage ());
}
}
● Class method
The method of writing classes below:
/ **
* Set the packet counter
* (Such as When Restoring from a database)
* /
Protected final
Void setArray (int [] r1, int [] r2, int [] R3, int [] R4)
Throws IllegalargumentException
{
//
// ensure the arrays area of equal size
//
IF (r1.length! = r2.length || r1.length! = r3.length || r1.length! = r4.length)
Throw New IllegalargumentException ("Arrays Must Be of the Same Size);
System.ArrayCopy (R1, 0, R3, 0, R1.LENGTH);
System.Arraycopy (R2, 0, R4, 0, R1.LENGTH);
}
● TOSTRING method
In any case, every class should define the toString method:
public
String toString () {
String Retval = "Counterset:";
For (int i = 0; i RetVal = data.bytes.tostring (); Retval = data.packets.tostring (); } Return RetVal; } } ● MAIN method If the main (String []) method is defined, it should be written at the bottom of the class. Code writing format ● Code style The code should use UNIX's format instead of Windows (for example: Enter the carriage return wrap). ● Documentation You must generate a document for class with javadoc. Not only because it is standard, this is also a method recognized by various Java compilers. Using the @Author tag is not recommended because the code should not be owned by the individual. ● indent The indentation should be 2 spaces per row. Do not save Tab characters in your source file. Tab characters will extend to different widths due to different source code management tools. If you use Ultredit as your Java source editor, you can prohibit saving Tab characters by using Ultredit, using the length of the length of the tab used in the ULTREDIT, then use the Format | Tabs to Spaces menu Convert TAB to spaces. ● Page width Page width should be set to 80 characters. Sourcecodes generally do not exceed this width and causing unable to display, but this setting can also be flexible. In any case, the long statement should be folded after a comma or an operator. After a statement is folded, 2 characters should be retracted more than the original statement. ● {} The statement in {} should be alone as a line. For example, the first line below is the correct line 2 is correct: IF (i> 0) {i }; // error, {and} in the same line IF (i> 0) { i }; // correct, {separate as a line } The statement is always separate as a line. If the} statement should be indented to the {that row relatively aligned with it. ● Brackets There should be a space between the left bracket and the latter character, and there should be a space between the right brackets and the previous characters. The following example shows the errors of parentheses and spaces and use correctly: CallProc (APARAMETER); / / Error CallProc (aparameter); / / correct Don't use the meaningless parentheses in the statement. Brackets should only be in the source code to achieve some purpose. The following example illustrates errors and correct usage: IF ((i) = 42) {// error - parentheses meaningless IF (i == 42) or (j == 42) Then // correct - indeed parentheses Program writing specification ● EXIT () Exit In addition to being called in main, other places should not be called. Because this does not give any code code opportunities to intercept exit. A similar background service ground program should not be exited because a library module determines to exit. ● abnormal The declared error should throw a runtimeException or derived exception. The top () function of the top layer should intercept all exceptions and print (or record it in the log) on the screen. ● Garbage collection Java uses mature background garbage collection techniques instead of reference count. But this will result in a problem: You must work after the instance of the object is used. For example, a PREL programmer may write: ... { FileOutputStream Fos = New FileoutputStream (Projectfile); Project.save (FOS, "Ide Project File"; } ... Unless the output stream is turned off, it is not a reference to the program language, such as Java, is a clearing work of the variable. Must be written as follows: FileOutputStream Fos = New FileoutputStream (Projectfile); Project.save (FOS, "Ide Project File"; Fos.close (); ● Clone Here are a useful way: Implements Cloneable public Object clone () { Try { THISCLASS OBJ = (thisclass) super.clone (); Obj.field1 = (int []) Field1.clone (); Obj.field2 = field2; Return Obj; } catch (clonenotsupportedexception e) { Throw New Internalerror ("Unexpected ClonyNotSupportedException:" E.GetMessage ()); } } ● Final class Never define the class as Final (unless the framework requirements) of the program due to performance. If a class is not ready to be inherited, it is best to indicate in class documents, not to define it to Final. This is because no one can guarantee that it will not be inherited because of what reason. ● Access to members variables Most of the class member variables should be defined as protected to prevent inheritance classes from using them. Note, use "int [] packets" instead of "int packets []", the latter is never used. Public void setpackets (int [] packets) {this.packets = packets;} Counterset (int size) { THIS.SIZE = Size; } Program skill Byte array transition to Characters In order to convert the Byte array to Characters, you can do this: "Hello World!". GetBytes (); ● The Utility class UTILITY class (class only provides a method) should be declared as abstract to prevent inheritance or initialization. ● Initialization The following code is a good way to initialize array: Objectarguments = new object [] {arguments}; ● Enumeration Type Java's support for enumeration, but the following code is a very useful template : Class color { Public Static Final Colour Black = New Colour (0, 0, 0); Public Static Final Colour Red = New Colour (0xFF, 0, 0); Public Static Final Color Green = New Colour (0, 0xFF, 0); Public Static Final Color Blue = New Colour (0, 0, 0xFF); Public Static Final Colour White = New Colour (0xFF, 0xFF, 0xFF); } This technology implements constants that can be used like the types of enumerations such as other languages. They can compare with '==' operators. But this uses a defect: if a user uses such a method to create a color Black New color (0,0,0) Then this is another object, '==' operator generates an error. Her equal () method is still valid. For this reason, the defect of this technology is best to indicate in the document, or only in your own package. Swing Avoid using AWT components ● Mix the AWT and SWING components If you want to use the AWT components and Swing components, use it. In fact, try not to mix them up. ● Scrolling AWT components The AWT component is definitely not to use the JScrollPane class to be scrolled. When scrolling the AWT component, you must use the AWT SCROLLPANE component to be implemented. ● Avoid using AWT components in the InternalFrame component Try not to do this, or there will be unpredictable consequences. ● Z-Order problem The AWT component is always displayed on the Swing component. Be careful when using the POP-UP menu containing the AWT component, try not to use it like this. debugging Debugging is a very important part of software development, exists in various parts of the software lifecycle. Debug can be opened with configuration, the key is the most basic. A very commonly used debugging method is to use a PrintStream class member, when not defined the trial flow, the class wants to define a DEBUG method to set the stream of debugging. performance ● When writing code, performance issues should be considered from head to tails. This is not to say that time should be wasted on the optimization code, but we always remind yourself to pay attention to the efficiency of the code. For example, if there is no time to implement an efficient algorithm, then we should record in the document so that you will come again in the future. Not all people agree to optimize the performance of this view when writing code, and they think that performance optimization should be considered in the later stage of the project, that is, after the outline of the program has been implemented. ● Unnecessary object construct Do not construct and release objects in the loop. Use StringBuffer objects: Try to use the StringBuffer class as possible when processing String, and the StringBuffer class is the basis for constituting the String class. The String class encapsulates the StringBuffer class, (at the expense of more time) provides a secure interface to developers. When we are constructing a string, we should use StringBuffer to implement most of the work, and convert the StringBuffer object to the required String object when the work is completed. For example, if there is a string that must be constantly adding a lot of characters to complete the construct, we should use the StringBuffer object and her append () method. If we use the String object instead of the StringBuffer object, you will spend a lot of unnecessary CPU time to create and release the object. ● Avoid too much use of Synchronized Replace text Avoid unnecessary use of keyword synchronized, should use her when necessary, this is a good way to avoid deadlocks. portability Borland Jbulider does not like this keyword, if your breakpoint is located in the scope of these keywords, when debugging, the breakpoint you will find will jump everywhere, so that you don't know what it is. Minimize not to use unless you must ● Renewal If you need to wrap, try to use PrintLn instead of using "/ n" in a string. You don't want this: System.out.print ("Hello, World! / N"); To be this: System.out.println ("Hello, World!"); Or you construct a string with changing lines, at least like this: String newline = system.getProperty ("line.separator"); System.out.Println ("Hello World" Newline; ● PrintStream PRINTSTREAM has been used in conjunction, with PrintWrite instead of her.
