Section 3.2 Static Methods
Subsection 3.2.1 public static void main(…)
In the last section we authored, compiled, and executed our first Java program. To make a complete program suitable for executaion, one of our requirements was to wrap our Java statements in a method named
main(…). In fact, the main(…) method must have the exact signature public static void main(String[] args). This signature is what Java looks for as the starting point for a program’s execution. When we entered the shell commands java ComputeDistance, we were telling Java to look in the ComputeDistance class for the method with the signature public static void main(String[] args) and begin execution there.The
main() method uses several keywords. The following figure shows the purpose for each. You will learn about each of these as we progress through the topics that follow. For now, understand that it is necessary to create a main(…) method with this exact signature so Java knows where to begin execution.
main(…) method
Subsection 3.2.2 Other static Methods
Grouping Java statements in named methods is a very useful technique that will benefit us as our programs grow in size. It is a form of encapsulation that supports abstraction. Abstracting away the details of a particular computation, exposing it as the name of the concept, is an important way of reducing complexity, which gives us a fighting chance at writing large and complex programs.
As an example, consider our
ComputeDistance() method from the last section. Rather than memorizing the distance formula and retyping it every time we wanted to compute a distance, a better approach would be to encapsulate that computation in its own method and give that method a meaningful name, like distanceBetween(). This new method would take the four double parameters x1, y1, x2, y2, and return the computed distance as a new double. Following the pattern of Figure 3.2.1, we can construct the following updated program having an additional method that encapsulates the distance formula. This lets us reuse the method without reentering the distance formula repeatedly.public class ComputeDistance {
public static void main(String[] args) { // Computation starts here
// Reuse distanceBetween() to calculate and sum two distances
double dist1 = distanceBetween(0.0, 20.0, 30.0, 0.0);
double dist2 = distanceBetween(30.0, 0.0, 40.0, 10.0);
System.out.println("Total distance: " + (dist1+dist2));
}
// New method that encapsulates the distance formula computation
// Parameters are four doubles representing the two point coordinates
public static double distanceBetween(double x1, double y1,
double x2, double y2 ) {
double term1 = Math.pow(x1-x2, 2); // Compute temporary terms
double term2 = Math.pow(y1-y2, 2);
// Apply the distance formula
double distance = Math.sqrt( term1 + term2 );
// Return the computed distance
return distance;
}
}
ComputeDistance.java (version 2)Compile and run your updated program from a shell.
javac ComputeDistance.java java ComputeDistance Total distance: 50.19764837837084
Now we really have something very nice. In our second version of the
ComputeDistance program, we have our class defined with a name that matches its file (ComputeDistance.java). Within the class we declare a main(…) method with the proper signature so Java knows were to start exectuion. And we have a helper method named distanceBetween(…) which encapsulates and abstracts away the details associated with computing the distance between two points. Because we encapsulated the distance formula in its own method, we can invoke the method twice using only its name and passing the four doubles. Never again do we need to remember the details of the distance formula nor how to write it in Java. This is the power of abstraction and encapsulation.Subsection 3.2.3 Source Code Formatting
Another item to note about our updated program is how the code itself is laid out. You’ll notice that the two methods are indented within the set of curly braces that enclose the class declaration, and the statements that define each method are indented further. The parameter declarations of
distanceBetween(…) are even indented so the second pair of parameters is right under the first pair. This formatting helps us see and understand how a program is organized at a glance, but it is not necessary, at least as far as the Java compiler is concerned. In fact, the Java compiler will compile the following listing with no trouble at all. But I don’t recommend it.public class ComputeDistanceMessy{public static void main(String[] args){
double dist1=distanceBetween(0.0,20.0,30.0,0.0);double dist2=
distanceBetween(30.0,0.0,40.0,10.0);System.out.println("Total distance: "
+(dist1+dist2));}public static double distanceBetween(double x1,double y1,
double x2,double y2){double term1=Math.pow(x1-x2,2);double term2 =
Math.pow(y1-y2,2);double distance=Math.sqrt(term1+term2);return distance;}}
ComputeDistance.java (messy version)This illustrates an important fact about Java. That is, whitespace rarely matters. We do need a space or linefeed here or there to separate certain language tokens, but not too many. But that doesn’t mean your programs should look like the one above. In fact, part of your job while programming is to write your code so that it is understandable by others. To that end, always format and comment your code. This is your way of communicating your program organization and how it works, even if you are communicating only to your future self. It’s best not to be the person who looks back at a program they wrote in the past and has no idea about what it does.
