David Hoffman [Hoffman - Java: The Simple Guide to Learn Java Programming In No Time (Programming,Database, Java for dummies, coding books, java programming) (HTML,Javascript,Programming,Developers,Coding,CSS,PHP Book 2)

Most importantly, use common sense. When unable to find a rule or guideline. When the rule clearly does not apply. When all else fails: Please make use of common sense, check the fundamental principles of Java and coding. This rule overrides all of the others. Common sense is a requirement.

1. Program for people, not the machine. Use naming conventions. Document your code. Paragraph it. If no one else can figure it out, then it isn't any good.

1. Design first, then code. Take the time to figure out how the code is going to be written before coding starts, you will definitely spend less time writing it. You reduce the impact of future changes on the code simply thinking about them first.

1. Develop in small steps. It is much easier and faster to test and fix ten lines of code than 1000; one could program, test, and fix 100 lines of code in ten, 10-line increments in half the time that you could write one single 100 line block of code that did the same work.
   
2. Keep your code simple. Coding that needs to be redone later is nothing to be proud of, so follow the KISS rule: Keep It Simple, Stupid.

1. Learn common patterns, anti-patterns, and idioms. There is a wealth of analysis available to guide you in increasing your development productivity, design, and process patterns and anti-patterns, as well as programming idioms.

We will begin this tutorial by discussing general principles of good programming style as well as those that define robust design in Java. Most of these principles have been touched on in the introduction to Java Programming, however many new practical advices shall be introduced in this chapter to improve your skills as a Java developer.

Variable scope

within the Java programming language, each local variable, once it has been declared, has a definitive scope. The variable then becomes visible from the place where it is declared to the ending of the method, or code block that it is now declared in. Therefore, only one single rule is necessary to follow; declare the local variable as close as possible to the place where it is used. Below are some typical examples:

With each code snippet the local variables scope is limited only to what execution blocks they are now declared in. When the block ends, the local variable is not visible anymore and goes out of scope. The look is clean and concise but with the introduction of lambdas and the release of Java 8, Much of the well-known idioms for using local variables are becoming totally obsolete.

Here is a rewrite of the forEach loop from the above example utilizing lambdas instead:

Notice that the local variable becomes the argument of this function which then itself is passed as the argument of the forEach method.

Class fields and local variables

Every method in Java will belong to some distinct class (or, in some cases some interface, like Java 8 where the method is declared as default). There is a probability of some name conflicts with local variables that are used in method implementations and as class members. The Java compiler will pick the correct variable from the scope, however it may not be the exact one the developer intended to use. Many modern Java IDEs do much work to alert the developer when conflicts such as these are taking place (red script, highlighting and warnings) however, it is still better to be proactive while in the development.

Below is an example:

This example appears to be very simple but there is one catch. The method called calculateValue introduces a local variable named value and hides the class member with the same name by doing that. Code line 08 should sum the class member and the local variable but in application it does something different. A corrected version would look like that (with keyword this):

This simple implementation highlights an important issue that in some cases would take more than a few hours to troubleshoot and debug.

Method arguments and local variables

A different scenario that many beginning developers fall into is using method arguments as local variables. Java allows reassignment of non-final method arguments with an alternate value (but this has no effect on the original value).

In example: