This seems so simple. It just states that line 1 should execute before line 2. But many programs and conventions do not follow this simple guideline.
public void myMethod() {
System.out.println("Line 1");
System.out.println("Line 2");
}Should output:
"Line 1"
"Line 2"Autoincrement operator
Following this guideline allows the reader to assume the sequence of execution. In assembler, most code is forced to execute in sequence. Once we ‘move up’ to C language and all its descendants (C++, C#, Java, …) this guideline is ignored and forgotten.
For example, take the code:
int a = 5;
int b = 2;
int j = a++ * b;
What is the value of ‘j’? Most coders *know* the convention that the auto-increment operator (‘++’) will execute last. So the answer is ‘j’ equals 10; The same code can be written as:
int j = a * b;
a = a + 1;
This looks a bit funny to experienced programmers, but any first-year programmer and most managers will understand it. I will grant you this is a near trivial example, and there are cases where using auto-increment makes the code easier to read, but it demonstrates that programmers get very accustomed to such mental gymnastics. Bottom line: cramming two lines of code into one line jumbles the top to bottom readability and increases the complexity of the code.
Anonymous Inner Classes
The example code in many tutorials for Java Swing button handlers uses an anonymous inner class (lines 4-7) and is some variation of:
JButton button = new JButton("Do Something");
//Add action listener to button
button.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e) {
System.out.println("You clicked the button");
}
});When is line 6 executed? The answer is some time after line 4 and not before line 9. The answer is line 6 is executed some time distant, possibly minutes or hours later when the user clicks the button. Line 5 will never be executed if the user does not press the button. Thus the order of execution is confusing and not apparent.
Also, The syntax is just ugly, especially line 8. Some book writers say you get used to it, but I haven’t yet.
A first step to make the code simpler and easier to read:
JButton button = new JButton("Do Something");
//Add action listener to button
button.addActionListener( new ButtonPressedListener() );
// Executed when the user presses the "Do Something" button
class ButtonPressedListener implements ActionListener {
public void actionPerformed(ActionEvent e) {
System.out.println("You clicked the button");
}
}This code is somewhat better at least the code is executed top to bottom. The inner class is a bit unsettling, but you could refactor it to its own file, which can be useful if the class is used in multiple files. Moving away from anonymous inner classes also makes the class ButtonPressedListener a ‘first class’ class, now freed from the constraints of being crammed into the button constructor, the path to use inheritance, state variables, constructors, and all the goodness of classes is now cleared and unfettered.
The new trend in tutorials is to not use anonymous inner classes, the Oracle web site, and other more recent sites, do not use them. This is good news.
Take away
The main point to remember is that when you are writing code try to write it so the lines are executed from top to bottom, this will make the code easier and less complex to read. Don’t write confusing code where the order of execution is not obvious.
When you are reading code mentally recognize when the code is not executed from top to bottom. In these cases note if this has made you confused and if so take steps to refactor the code to be more clear.