Spelling Rules of Java

Outline

• Numbers
  • Integers
  • Floating-point numbers
• Spaces and line breaks
• Parentheses, brackets, and braces
• Names
• Comments
• Strings

Numbers

integers

a sequence of as many digits (0-9) as you wish. You can also put a plus ("+") or minus ("-") sign in front, with no spaces in between. If the number is larger than about 2000000000 (or smaller than about -2000000000) Java may not handle it correctly.

Examples:

• 873245
• -34597862
• 5,280 (illegal because it contains a comma)

floating-point numbers

a sequence of digits, a period, and another sequence of digits, with no spaces in between. You can also use scientific notation by putting the letter "e" or "E" and a positive or negative integer at the end, with no spaces in between.

Examples:

• 3.1415926
• 6.02e23
• -.738E-17

Notes: Such numbers are usually inexact: for example, 49.0 *  (1.0 / 49.0) will probably be very close, but not exactly equal, to 1.0. They are limited in precision -- only about fifteen digits after the decimal point, and the exponent can be no larger than about 308 (depending on what's in front of the decimal point)

Spaces and line breaks

Spaces and line breaks separate one name, number, or keyword from another. In most places in the Java language they're not required, as there's a punctuation mark of some kind to clearly distinguish one word from another. The most common place that spaces are required is in a declaration, between the type and the name of the variable or method. A space is similarly required in a class header, between the word class and the name of the class.

In general, a line break can be anywhere that a space can be, except inside a quoted string. Spaces and line breaks are allowed between any two names, numbers, keywords, operators, etc. but they are not allowed inside a name, number, keyword, or operator.

Examples:

• class Foo{int x;float myMethod(){return x/2.0;}}
  

  has only the spaces that are absolutely necessary. A more readable version is ...

• class Foo
    {
    int x;
    float myMethod()
      {
      return x/2.0;
      }
    }
  

  This illustrates several widespread programming conventions: putting the header of a class or method on one line, and its body on the next; indenting the body of a class or method farther than its header was indented; and lining up the opening and closing curly-braces of a class or method body.

•      class
    Foo
  
                   {       int
  x
  
      ;
    float myMethod
  (                )
  
             {
      return
         x
     /     2.0
        ;
                 } }
  

  is technically legal, and defines exactly the same class, variable, and method, but it has so many spaces and line breaks and such misleading indentation that it's almost impossible to read.

Parentheses, brackets, and braces

Left parentheses must match right parentheses. Left square brackets must match right square brackets. Left curly braces must match right curly braces. Simple enough?

Examples:

• (3 + (4 * 5)) is legal.
• (3 + (4 * 5) is illegal because there are more left parentheses than right parentheses.

• class Foo {
     int x;
     float myMethod )
       { return x/2.0; }
  

  is illegal because the right-parenthesis after myMethod is unmatched, and the left-curly-brace after Foo is unmatched.

Names

Methods, classes, variables, and keywords all follow basically the same spelling rules. They can be made up of upper-case and lower-case letters (yes, case matters!), underscores, and a few other punctuation marks. They cannot contain spaces or hyphens. Nor can they contain parentheses, curly braces, square brackets, apostrophes, commas, or quotation marks, as these all have special meanings in Java.

Examples:

• sqrt
  is a good name for a method. It happens to be predefined to be a method in the Math class that computes square roots, but you could easily define a variable or a method in a different class with the same name.
• square
  is another good name; it doesn't happen to be predefined at all, but you can easily define it to mean a method that multiplies a number by itself, or you can define it to be a variable that holds a description of a geometric shape, or....
• true
  is the predefined name of a Boolean constant -- i.e. a variable that cannot be changed. You can define your own variables that cannot be changed, using the final keyword.
• my age
  is an illegal name, because it contains a space. In most contexts, Java will try to treat this as two variable names, and since two variable names in a row are almost never legal, it guesses that the latter was intended to be the beginning of a new statement, which means that the programmer must have left out the semicolon between the statements, so it gives you the misleading error message "Semicolon expected."
• myAge
  is a legal name, following the Java naming convention (multi-word names have all but the first word capitalized).
• class
  is a predefined keyword in the language. You cannot redefine it to mean something else. Some other common keywords are if, else, and return.

Comments

Anything between two slashes // and the end of the line is ignored by Java (unless the slashes are inside a quoted string).
Examples:

• // This is a comment that takes up the whole line.
• int bignum 1234567;//a big number
  Note that spaces are not required around the slashes (but they're recommended, for readability).
• int biggernum 123457890; // a really really
                 really big number
  Note that the second line is not ignored, and will presumably produce error messages when the compiler tries to treat it as Java code.

Anything between slash-star /* and star-slash */ is ignored (unless the comment delimiters are inside a quoted string). This kind of comment can extend over several lines.
Examples:

• int bignum/*a big number*/1234567;
  Note that spaces are not required around the comment delimiters, but they aid readability, especially if the comment is in the middle of a statement like this (which is usually a bad idea).

• int biggernum 123457890; /* a really really
                     really big number */
  

  Note that the second line is still inside the comment, and will not produce an error message.

• int biggernum 123457890; /* a really really big number
  int littlenum 7;
  

  Note that the comment is never ended, so the second line (which the programmer presumably meant to be Java code) will be treated as a comment too. Fortunately, BlueJ and many other Java development environments use color to show you what they consider to be comments.

Strings

A string is any sequence of characters surrounded by "double-quote marks". Spaces, upper and lower case letters, and any punctuation mark are allowed inside. If you want to put a double-quote mark inside a string, precede it with a backslash, e.g.

"This is a \"string\" containing quotation marks."

If you want to put a backslash inside a string, precede it with a backslash, e.g.

"This is another string containing a single \\ backslash."

A string cannot extend from one line of source code to the next. If you want a line break inside a string, use "\n" to represent it.

"This is a\nstring containing\ntwo line breaks."