View source for Java Programming/Understanding a Java Program

<noinclude>{{Displaytitle|title=Understanding a Java Program}}
{{Nav}}
{{Java Programming/GettingStartedTopic/Nav}}
__NOTOC__</noinclude>

This article presents a small Java program which can be run from the console. It computes the distance between two points on a plane. You do not need to understand the structure and meaning of the program just yet; we will get to that soon. Also, because the program is intended as a simple introduction, it has some room for improvement, and later in the module we will show some of these improvements. But let's not get too far ahead of ourselves!

== The Distance Class: Intent, Source, and Use ==

This class is named ''Distance'', so using your favorite editor or [[Java Programming/Java IDEs|Java IDE]], first create a file named <code>Distance.java</code>, then copy the source below, paste it into the file and save the file.
{{XCode|1=<span id="code-listing-1">'''Code listing 2.1: Distance.java'''</span>
<syntaxhighlight lang="Java" line start="1">
 public class Distance {
   private java.awt.Point point0, point1;
 
   public Distance(int x0, int y0, int x1, int y1) {
     point0 = new java.awt.Point(x0, y0);
     point1 = new java.awt.Point(x1, y1);
   }
 
   public void printDistance() {
     System.out.println("Distance between " + point0 + " and " + point1
                     + " is " + point0.distance(point1));
   }
 
   public static void main(String[] args) {
     Distance dist = new Distance(
              intValue(args[0]), intValue(args[1]),
              intValue(args[2]), intValue(args[3]));
     dist.printDistance();
   }
 
   private static int intValue(String data) {
     return Integer.parseInt(data);
   }
 }
</syntaxhighlight>}}

At this point, you may wish to review the source to see how much you might be able to understand. While perhaps not being the most literate of programming languages, someone with understanding of other procedural languages such as C, or other object oriented languages such as C++ or C#, will be able to understand most if not all of the sample program.

Once you save the file, [[Java Programming/Compilation|compile]] the program:
{{XCode|1='''Compilation command'''
<pre style="background-color:#000; color:#fff;">
$ javac Distance.java
</pre>}}
(If the <code>javac</code> command fails, review the [[Java Programming/Installation|installation instructions]].)

To run the program, you supply it with the ''x'' and ''y'' coordinates of two points on a plane separated by a space. For this version of Distance, only integer points are supported. The command sequence is ''<code>java Distance <x<sub>0</sub>> <y<sub>0</sub>> <x<sub>1</sub>> <y<sub>1</sub>></code>'' to compute the distance between the points (''x<sub>0</sub>, y<sub>0</sub>'') and (''x<sub>1</sub>, y<sub>1</sub>'').
{{XWarning|If you get a <code>java.lang.NumberFormatException</code> exception, some arguments are not a number. If you get a <code>java.lang.ArrayIndexOutOfBoundsException</code> exception, you did not provide enough numbers.}}

Here are two examples:
{{XCode|1='''Output for the distance between the points (0, 3) and (4, 0)'''
<pre style="background-color:#000; color:#fff;">
$ java Distance 0 3 4 0
Distance between java.awt.Point[x=0,y=3] and java.awt.Point[x=4,y=0] is 5.0
</pre>}}

{{XCode|1='''Output for the distance between the points (-4, 5) and (11, 19)'''
<pre style="background-color:#000; color:#fff;">
$ java Distance -4 5 11 19
Distance between java.awt.Point[x=-4,y=5] and java.awt.Point[x=11,y=19] is 20.518284528683193
</pre>}}

We'll explain this strange looking output, and also show how to improve it, later.

== Detailed Program Structure and Overview ==

As promised, we will now provide a detailed description of this Java program. We will discuss the syntax and structure of the program and the meaning of that structure.

=== Introduction to Java Syntax ===

{{XCode|1=<span id="code-listing-1">'''Code listing''' 
<syntaxhighlight lang="Java" line start="1">
public class Distance {
   private java.awt.Point point0, point1;

   public Distance(int x0, int y0, int x1, int y1) {
     point0 = new java.awt.Point(x0, y0);
     point1 = new java.awt.Point(x1, y1);
   }

   public void printDistance() {
     System.out.println("Distance between " + point0 + " and " + point1
                     + " is " + point0.distance(point1));
   }

   public static void main(String[] args) {
     Distance dist = new Distance(
              intValue(args[0]), intValue(args[1]),
              intValue(args[2]), intValue(args[3]));
     dist.printDistance();
   }

   private static int intValue(String data) {
     return Integer.parseInt(data);
   }
}
</syntaxhighlight></span>}}


:<span id="figure-1">Figure 2.1</span>: Basic Java syntax.
::''For a further treatment of the syntax elements of Java, see also [[Java Programming/Syntax|Syntax]].''

The ''syntax'' of a Java class is the characters, symbols and their structure used to code the class. Java programs consist of a sequence of tokens. There are different kinds of tokens. For example, there are word tokens such as {{java:class}} and {{java:public}} which represent ''[[Java Programming/Keywords|<span style="color: purple">'''keywords'''</span>]]'' <span style="color: purple">'''(in purple'''</span> [[#figure-1|<span style="color: purple">'''above'''</span>]]<span style="color: purple">''')'''</span> &mdash; special words with reserved meaning in Java. Other words such as <code>Distance</code>, <code>point0</code>, <code>x1</code>, and <code>printDistance</code> are not keywords but <span style="color: grey">''identifiers'' (in grey)</span>. Identifiers have many different uses in Java but primarily they are used as names. Java also has tokens to represent numbers, such as <code>1</code> and <code>3</code>; these are known as ''[[Java Programming/Literals|<span style="color: orange">literals</span>]]'' <span style="color: orange">(in orange)</span>. ''[[Java Programming/Literals/String Literals|<span style="color: blue">String literals</span>]]'' <span style="color: blue">(in blue)</span>, such as  <code>"Distance between "</code>, consist of zero or more characters embedded in double quotes, and ''[[Java Programming/Operators|<span style="color: red">operators</span>]]'' <span style="color: red">(in red)</span> such as <code>+</code> and <code>=</code> are used to express basic computation such as addition or String concatenation or assignment. There are also left and right braces (<code>{</code> and <code>}</code>) which enclose ''blocks''. The body of a class is one such block. Some tokens are punctuation, such as periods <code>.</code> and commas <code>,</code> and semicolons <code>;</code>. You use ''whitespace'' such as spaces, tabs, and newlines, to separate tokens. For example, whitespace is required between keywords and identifiers: <code>publicstatic</code> is a single identifier with twelve characters, not two Java keywords.

=== Declarations and Definitions ===

<div style="border: blue solid 3px; background-color: #ccf">
<code>public class Distance {</code>

<div style="border: green solid 3px; background-color: #cfc">
<code>&nbsp;&nbsp;private java.awt.Point point0, point1;</code>
</div>


<div style="border: orange solid 3px; background-color: #fdc">
<code>&nbsp;&nbsp;public Distance(int x0, int y0, int x1, int y1) {</code><br/>
<code>&nbsp;&nbsp;&nbsp;&nbsp;point0 = new java.awt.Point(x0, y0);</code><br/>
<code>&nbsp;&nbsp;&nbsp;&nbsp;point1 = new java.awt.Point(x1, y1);</code><br/>
<code>&nbsp;&nbsp;}</code>
</div>


<div style="border: red solid 3px; background-color: #fcc">
<code>&nbsp;&nbsp;public void printDistance() {</code><br/>
<code>&nbsp;&nbsp;&nbsp;&nbsp;System.out.println("Distance between " + point0 + " and " + point1</code><br/>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;+ " is " + point0.distance(point1));</code><br/>
<code>&nbsp;&nbsp;}</code>
</div>


<div style="border: red solid 3px; background-color: #fcc">
<code>&nbsp;&nbsp;public static void main(String[] args) {</code><br/>
<code>&nbsp;&nbsp;&nbsp;&nbsp;Distance dist = new Distance(</code><br/>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;intValue(args[0]), intValue(args[1]),</code><br/>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;intValue(args[2]), intValue(args[3]));</code><br/>
<code>&nbsp;&nbsp;&nbsp;&nbsp;dist.printDistance();</code><br/>
<code>&nbsp;&nbsp;}</code>
</div>


<div style="border: red solid 3px; background-color: #fcc">
<code>&nbsp;&nbsp;private static int intValue(String data) {</code><br/>
<code>&nbsp;&nbsp;&nbsp;&nbsp;return Integer.parseInt(data);</code><br/>
<code>&nbsp;&nbsp;}</code>
</div>


<code>}</code>
</div>
:<span id="figure-2">Figure 2.2</span>: Declarations and Definitions.

Sequences of tokens are used to construct the next building blocks of Java classes as shown [[#figure-2|above]]: declarations and definitions. A class declaration provides the name and visibility of a class. In our example, <code>public class Distance</code> is the class declaration. It consists (in this case) of two keywords, <code>{{java:public}}</code> and <code>{{java:class}}</code> followed by the identifier <code>Distance</code>.

This means that we are defining a class named <code>Distance</code>. Other classes, or in our case, the command line, can refer to the class by this name. The <code>public</code> keyword is an [[Java Programming/Scope|access modifier]] which declares that this class and its members may be accessed from other classes. The <code>class</code> keyword, obviously, identifies this declaration as a class. Java also allows declarations of ''[[Java Programming/Interfaces|interfaces]]'' and ''[[Java Programming/Annotations|annotations]]''.

The class declaration is then followed by a block (surrounded by curly braces) which provides the class's definition <span style="color: blue">(in blue in [[#figure-2|figure 2.2]])</span>. The definition is the implementation of the class &ndash; the declaration and definitions of the class's members. This class contains exactly six members, which we will explain in turn.
# Two field declarations, named <code>point0</code> and <code>point1</code> <span style="color: green">(in green)</span>
# A constructor declaration <span style="color: orange">(in orange)</span>
# Three method declarations <span style="color: red">(in red)</span>

==== Example: Instance Fields ====

The declaration
{{XExample|1='''Code section 2.1: Declaration.'''
<syntaxhighlight lang="Java5" line start="1">
private java.awt.Point point0, point1;
</syntaxhighlight>}}

...declares two ''instance fields''. Instance fields represent named values that are allocated whenever an instance of the class is constructed. When a Java program creates a <code>Distance</code> instance, that instance will contain space for <code>point0</code> and <code>point1</code>. When another <code>Distance</code> object is created, it will contain space for its ''own'' <code>point0</code> and <code>point1</code> values. The value of <code>point0</code> in the first <code>Distance</code> object can vary independently of the value of <code>point0</code> in the second <code>Distance</code> object.

This declaration consists of:

#The <code>[[Java Programming/Keywords/private|private]]</code> access modifier,<br/>which means these instance fields are not visible to other classes.
#The type of the instance fields. In this case, the type is <code>java.awt.Point</code>.<br/>This is the class <code>Point</code> in the <code>java.awt</code> package.
#The names of the instance fields in a comma separated list.


These two fields could also have been declared with two separate but more verbose declarations,

{{XExample|1='''Code section 2.2: Verbose declarations.'''
<syntaxhighlight lang="Java5" line start="1">
 private java.awt.Point point0;
 private java.awt.Point point1;
</syntaxhighlight>}}

Since the type of these fields is a reference type (i.e. a field that ''refers to'' or can hold a ''reference to'' an object value), Java will implicitly initialize the values of <code>point0</code> and <code>point1</code> to null when a <code>Distance</code> instance is created. The null value means that a reference value does not refer to an object. The special Java literal {{java:null}} is used to represent the null value in a program. While you can explicitly assign null values in a declaration, as in

{{XExample|1='''Code section 2.3: Declarations and assignments.'''
<syntaxhighlight lang="Java5" line start="1">
 private java.awt.Point point0 = null;
 private java.awt.Point point1 = null;
</syntaxhighlight>}}

It is not necessary and most programmers omit such default assignments.

==== Example: Constructor ====

A ''[[Java Programming/Methods#Special method, the constructor|constructor]]'' is a special method in a class which is used to construct an instance of the class. The constructor can perform initialization for the object, beyond that which the Java VM does automatically. For example, Java will automatically initialize the fields <code>point0</code> and <code>point1</code> to null.

{{XExample|1='''Code section 2.4: The constructor for the class'''
<syntaxhighlight lang="Java5" line start="1">
public Distance(int x0, int y0, int x1, int y1) {
   point0 = new java.awt.Point(x0, y0);
   point1 = new java.awt.Point(x1, y1);
}
</syntaxhighlight>}}

The constructor above consists of five parts:
# The optional [[Java Programming/Scope|access modifier(s)]]. <br/> In this case, the constructor is declared <code>public</code>
# The constructor name, which must match the class name exactly: <code>Distance</code> in this case.
# The constructor parameters.<br/> The parameter list is required. Even if a constructor does not have any parameters, you must specify the empty list <code>()</code>. The parameter list declares the type and name of each of the method's parameters.
# An optional {{java:throws}} clause which declares the [[Java Programming/Exceptions|exceptions]] that the constructor may throw. This constructor does not declare any exceptions.
# The constructor body, which is a Java block (enclosed in <code>{}</code>).  This constructor's body contains two statements.

This constructor accepts four parameters, named <code>x0, y0, x1</code> and <code>y1</code>. Each parameter requires a parameter type declaration, which in this example is <code>{{java:int}}</code> for all four parameters. The parameters in the parameter list are separated by commas.

The two assignments in this constructor use Java's ''{{java:new}} operator'' to allocate two <code>java.awt.Point</code> objects. The first allocates an object representing the first point, <code>(x0, y0)</code>, and assigns it to the <code>point0</code> instance variable (replacing the null value that the instance variable was initialized to). The second statement allocates a second <code>java.awt.Point</code> instance with <code>(x1, y1)</code> and assigns it to the <code>point1</code> instance variable.

This is the constructor for the Distance class. Distance implicitly extends from <code>java.lang.Object</code>. Java inserts a call to the super constructor as the first executable statement of the constructor if there is not one explicitly coded. The above constructor body is equivalent to the following body with the explicit super constructor call:

{{XExample|1='''Code section 2.5: Super constructor.'''
<syntaxhighlight lang="Java5" line start="1">
{
   super();
   point0 = new java.awt.Point(x0, y0);
   point1 = new java.awt.Point(x1, y1);
}
</syntaxhighlight>}}

While it is true that this class could be implemented in other ways, such as simply storing the coordinates of the two points and computing the distance as <math>\sqrt{(x_1-x_0)^2 + (y_1-y_0)^2}</math>, this class instead uses the existing <code>java.awt.Point</code> class. This choice matches the abstract definition of this class: to print the distance between two points on the plane. We take advantage of existing behavior already implemented in the Java platform rather than implementing it again. We will see later how to make the program more flexible without adding much complexity, because we choose to use object abstractions here. However, the key point is that this class uses information hiding. That is, ''how'' the class stores its state or how it computes the distance is hidden. We can change this implementation without altering how clients use and invoke the class.

==== Example: Methods ====

[[Java Programming/Methods|Methods]] are the third and most important type of class member. This class contains three ''methods'' in which the behavior of the <code>Distance</code> class is defined: <code>printDistance()</code>, <code>main()</code>, and <code>intValue()</code>

==== The printDistance() method ====

The <code>printDistance()</code> method prints the distance between the two points to the standard output (normally the console).
{{XExample|1='''Code section 2.6: <code>printDistance()</code> method.'''
<syntaxhighlight lang="Java5" line start="1">
public void printDistance() {
  System.out.println("Distance between " + point0
    + " and " + point1
    + " is " + point0.distance(point1));
}
</syntaxhighlight>}}

This ''instance method'' executes within the context of an implicit <code>Distance</code> object. The instance field references, <code>point0</code> and <code>point1</code>, refer to instance fields of that implicit object. You can also use the special variable <code>this</code> to explicitly reference the current object. Within an instance method, Java binds the name <code>this</code> to the object on which the method is executing, and the type of <code>this</code> is that of the current class. The body of the <code>printDistance</code> method could also be coded as
{{XExample|1='''Code section 2.7: Explicit instance of the current class.'''
<syntaxhighlight lang="Java5" line start="1">
  System.out.println("Distance between " + this.point0
    + " and " + this.point1
    + " is " + this.point0.distance(this.point1));
</syntaxhighlight>}}

to make the instance field references more explicit.

This method both computes the distance and prints it in one statement. The distance is computed with <code>point0.distance(point1)</code>; <code>distance()</code> is an instance method of the <code>java.awt.Point</code> class (of which <code>point0</code> and <code>point1</code> are instances). The method operates on <code>point0</code> (binding <code>this</code> to the object that <code>point0</code> refers to during the execution of the method) and accepting another Point as a parameter. Actually, it is slightly more complicated than that, but we'll explain later. The result of the <code>distance()</code> method is a double precision floating point number.

This method uses the syntax

{{XExample|1='''Code section 2.8: String concatenation.'''
<syntaxhighlight lang="Java5" line start="1">
 "Distance between " + this.point0
 + " and " + this.point1
 + " is " + this.point0.distance(this.point1)
</syntaxhighlight>}}

to construct a String to pass to the <code>System.out.println()</code>. This expression is a series of ''String concatenation'' methods which concatenates Strings or the String representation of primitive types (such as doubles) or objects, and returns a long string. For example, the result of this expression for the points (0,3) and (4,0) is the String
{{XCode|1='''Output'''
<pre style="background-color:#000; color:#fff;">
"Distance between java.awt.Point[x=0,y=3] and java.awt.Point[x=4,y=0] is 5.0"
</pre>}}
which the method then prints to <code>System.out</code>.

In order to print, we invoke the <code>println()</code>. This is an instance method from <code>java.io.PrintStream</code>, which is the type of the static field <code>out</code> in the class <code>java.lang.System</code>. The Java VM binds <code>System.out</code> to the standard output stream when it starts a program.

==== The main() method ====

The <code>main()</code> method is the main entry point which Java invokes when you start a Java program from the command line. The command
{{XCode|1='''Output'''
<pre style="background-color:#000; color:#fff;">
java Distance 0 3 4 0
</pre>}}
instructs Java to locate the Distance class, put the four command line arguments into an array of String values, then pass those arguments to the <code>public static main(String[])</code> method of the class. We will introduce arrays shortly. Any Java class that you want to invoke from the command line or desktop shortcut must have a main method with this signature or the following signature: <code>public static main(String...)</code>.
{{XExample|1='''Code section 2.9: <code>main()</code> method.'''
<syntaxhighlight lang="Java5" line start="1">
public static void main(String[] args) {
   Distance dist = new Distance(
         intValue(args[0]), intValue(args[1]),
         intValue(args[2]), intValue(args[3]));
   dist.printDistance();
}
</syntaxhighlight>}}
The <code>main()</code> method invokes the final method, <code>intValue()</code>, four times. The <code>intValue()</code> takes a single string parameter and returns the integer value represented in the string. For example, <code>intValue("3")</code> will return the integer 3.

People who do test-first programming or perform regression testing
write
a main() method in every Java class, and
a [[Python Programming/Modules and how to use them | main() function in every Python module]],
to run automated tests.
When a person executes the file directly,
the main() method executes and runs the automated tests for that file.
When a person executes some other Java file
that in turn imports many other Java classes,
only one main() method is executed --
the main() method of the directly-executed file.

==== The <code>intValue()</code> method ====

The <code>intValue()</code> method delegates its job to the <code>Integer.parseInt()</code> method. The main method could have called <code>Integer.parseInt()</code> directly; the <code>intValue()</code> method simply makes the <code>main()</code> method slightly more readable.

{{XExample|1='''Code section 2.10: <code>intValue()</code> method.'''
<syntaxhighlight lang="Java5" line start="1">
private static int intValue(String data) {
   return Integer.parseInt(data);
}
</syntaxhighlight>}}

This method is {{java:private}} since, like the fields <code>point0</code> and <code>point1</code>, it is part of the internal implementation of the class and is not part of the external programming interface of the <code>Distance</code> class.

==== Static vs. Instance Methods ====

Both the <code>main()</code> and <code>intValue()</code> methods are ''static methods''. The {{java:static}} keyword tells the compiler to create a single memory space associated with the class.  Each individual object instantiated has its own private state variables and methods but use the same <b>static</b> methods and members common to the single class object created by the compiler when the first class object is instantiated or created.  This means that the method executes in a static or non-object context &mdash; there is no implicit separate instance available when the static methods run from various objects, and the special variable <code>this</code> is not available. As such, static methods cannot access instance methods or instance fields (such as <code>printDistance()</code>) or <code>point0</code>) directly. The <code>main()</code> method can only invoke the instance method <code>printDistance()</code> method via an instance reference such as <code>dist</code>.

=== Data Types ===

Most declarations have a data type. Java has several categories of data types: reference types, primitive types, array types, and a special type, void.

==== Primitive Types ====

The ''[[Java Programming/Primitive Types|primitive types]]'' are used to represent boolean, character, and numeric values. This program uses only one primitive type explicitly, <code>''{{java:int}}''</code>, which represents 32 bit signed integer values. The program also implicitly uses <code>''{{java:double}}''</code>, which is the return type of the <code>distance()</code> method of <code>java.awt.Point</code>. <code>double</code> values are 64 bit IEEE floating point values. The <code>main()</code> method uses integer values 0, 1, 2, and 3 to access elements of the command line arguments. The <code>Distance()</code> constructor's four parameters also have the type <code>int</code>. Also, the <code>intValue()</code> method has a return type of <code>int</code>. This means a call to that method, such as <code>intValue(args[0])</code>, is an expression of type <code>int</code>. This helps explain why the main method cannot call:

{{XWarning|1=<span style="color: red;">'''Code section 2.11: Wrong type.'''</span>
<syntaxhighlight lang="Java5" line start="1">
new Distance(args[0], args[1], args[2], args[3]) // This is an error
</syntaxhighlight>}}

Since the type of the <code>args</code> array element is String, and our constructor's parameters must be <code>int</code>, such a call would result in an error because Java will not automatically convert values of type String into <code>int</code> values.

Java's primitive types are
<code>''{{java:boolean}}''</code>,
<code>''{{java:byte}}''</code>,
<code>''{{java:char}}''</code>,
<code>''{{java:short}}''</code>,
<code>''{{java:int}}''</code>,
<code>''{{java:long}}''</code>,
<code>''{{java:float}}''</code> and
<code>''{{java:double}}''</code>. Each of which are also Java language keywords.

==== Reference Types ====

In addition to primitive types, Java supports ''reference type''. A reference type is a Java data type which is defined by a Java class or interface. Reference types derive this name because such values ''refer to'' an object or contain a ''reference to'' an object. The idea is similar to pointers in other languages like C.

Java represents sequences of character data, or ''[[Java Programming/API/java.lang.String|String]]'', with the reference type <code>java.lang.String</code> which is most commonly referred to as <code>String</code>. ''String literals'', such as  <code>"Distance between "</code> are constants whose type is String.

This program uses three separate reference types:
# java.lang.String (or simply String)
# Distance
# java.awt.Point

:''For more information see chapter: [[Java Programming/Classes, Objects and Types]].''

==== Array Types ====

Java supports ''[[Java Programming/Arrays|arrays]]'', which are aggregate types which have a fixed element type (which can be any Java type) and an integral size. This program uses only one array, <code>String[] args</code>. This indicates that <code>args</code> has an array type and that the element type is <code>String</code>. The Java VM constructs and initializes the array that is passed to the <code>main</code> method. See ''[[Java Programming/Arrays|arrays]]'' for more details on how to create arrays and access their size.

The elements of arrays are accessed with integer indices. The first element of an array is always element 0. This program accesses the first four elements of the <code>args</code> array explicitly with the indices 0, 1, 2, and 3. This program does ''not'' perform any input validation, such as verifying that the user passed at least four arguments to the program. We will fix that later.

==== void ====

{{Java:void}} is not a type in Java; it represents the absence of a type. Methods which do not return values are declared as ''void methods''.

This class defines two void methods:

{{XExample|1='''Code section 2.12: Void methods'''
<syntaxhighlight lang="Java5" line start="1">
public static void main(String[] args) { ... }
public void printDistance()  { ... }
</syntaxhighlight>}}

== Whitespace ==
Whitespace in Java is used to separate the tokens in a Java source file. Whitespace is required in some places, such as between [[Java Programming/Scope|access modifiers]], [[Java Programming/Primitive Types|type names]] and Identifiers, and is used to improve readability elsewhere.

Wherever whitespace is required in Java, one or more whitespace characters may be used. Wherever whitespace is optional in Java, zero or more whitespace characters may be used.

Java whitespace consists of the
* space character {{Java:ch| }} (0x20),
* the tab character (hex 0x09),
* the form feed character (hex 0x0c),
* the line separators characters newline (hex 0x0a) or carriage return (hex 0x0d) characters.

Line separators are special whitespace characters in that they also terminate line comments, whereas normal whitespace does not.

Other Unicode space characters, including vertical tab, are not allowed as whitespace in Java.

=== Required Whitespace ===

Look at the {{Java:static}} method <code>intValue</code>:
{{XExample|1='''Code section 2.13: Method declaration'''
<syntaxhighlight lang="Java5" line start="1">
private static int intValue(String data) {
  return Integer.parseInt(data);
}
</syntaxhighlight>}}

Whitespace is required between {{Java:private}} and {{Java:static}}, between {{Java:static}} and {{Java:int}}, between {{Java:int}} and <code>intValue</code>, and between <code>String</code> and <code>data</code>.

If the code is written like this:
{{XExample|1='''Code section 2.14: Collapsed code'''
<syntaxhighlight lang="Java5" line start="1">
privatestaticint intValue(String data) {
  return Integer.parseInt(data);
}
</syntaxhighlight>}}

...it means something completely different: it declares a method which has the return type <code>privatestaticint</code> It is unlikely that this type exists and the method is no longer static, so the above would result in a semantic error.

== Indentation ==
Java ignores all whitespace in front of a statement. As this, these two code snippets are identical for the compiler:
{{XExample|1='''Code section 2.15: Indented code'''
<syntaxhighlight lang="Java5" line start="1">
public static void main(String[] args) {
  Distance dist = new Distance(
           intValue(args[0]), intValue(args[1]),
           intValue(args[2]), intValue(args[3]));
  dist.printDistance();
}

private static int intValue(String data) {
  return Integer.parseInt(data);
}
</syntaxhighlight>}}

{{XExample|1='''Code section 2.16: Not indented code'''
<syntaxhighlight lang="Java5" line start="1">
public static void main(String[] args) {
Distance dist = new Distance(
intValue(args[0]), intValue(args[1]),
intValue(args[2]), intValue(args[3]));
dist.printDistance();
}

private static int intValue(String data) {
return Integer.parseInt(data);
}
</syntaxhighlight>}}

However, the first one's style (with whitespace) is preferred, as the readability is higher. The method body is easier to distinguish from the head, even at a higher reading speed.

<noinclude>{{Nav}}
{{Status|100%}}</noinclude>