Unicode and ASCII

Maintained by the Unicode Consortium standards organization, Unicode is the universal character set with the first 128 characters the same as those in the American Standard Code for Information Interchange (ASCII) character set. Unicode provides a unique number for each character, usable across all platforms, programs, and languages. Java SE 9 supports Unicode 8.0.0. You can find more information about the Unicode Standard in the online manual. Java SE 8 supports Unicode 6.2.0.

The Unicode set version used by a specified version of the Java platform is documented in the Character class of the Java API. The Unicode Character Code Chart for scripts, symbols, and punctuation can be accessed at http://unicode.org/charts/.

Compact Strings

The compact strings feature is an optimization that allows for a more space-efficient internal representation of strings. It is enabled by default in Java 9. This feature may be disabled by using -XX:-CompactStrings, if you are mainly using UTF-16 strings.

Comments

A single-line comment begins with two forward slashes and ends immediately before the line terminator character:

// Default child's birth year
private Integer childsBirthYear = 1950;

A multiline comment begins with a forward slash immediately followed by an asterisk and ends with an asterisk immediately followed by a forward slash. The single asterisks in between provide a nice formatting convention; they are typically used, but are not required:

  /*
   * The average age of a woman giving birth in the
   * US in 2001 was 24.9 years old. Therefore,
   * we'll use the value of 25 years old as our
   * default.
   */
  private Integer mothersAgeGivingBirth = 25;

A Javadoc comment is processed by the Javadoc tool to generate API documentation in HTML format. A Javadoc comment must begin with a forward slash, immediately followed by two asterisks, and end with an asterisk immediately followed by a forward slash (Oracle’s documentation page provides more information on the Javadoc tool):

/**
 * Genitor birthdate predictor
 *
 * @author Robert J. Liguori
 * @author Gliesian, LLC.
 * @version 0.1.1 09-02-16
 * @since 0.1.0 09-01-16
 */
public class GenitorBirthdatePredictorBean {...}

In Java, comments cannot be nested:

/* This is /* not permissible */ in Java */

Keywords

Table 2-3 contains the Java 9 keywords. Two of these, the const and goto keywords, are reserved but are not used by the Java language.

Identifiers

A Java identifier is the name that a programmer gives to a class, method, variable, and so on.

Identifiers cannot have the same Unicode character sequence as any keyword, boolean, or null literal.

Java identifiers are made up of Java letters. A Java letter is a character for which Character.isJavaIdentifierStart(int) returns true. Java letters from the ASCII character set are limited to the dollar sign ($), upper- and lowercase letters, and the underscore symbol (_). Note that as of Java 9, (_) is a keyword and may not be used alone as an identifier.

Digits are also allowed in identifiers after the first character:

// Valid identifier examples
class GedcomBean {
  private File uploadedFile;  // uppercase and
                              // lowercase
  private File _file; // leading underscore
  private File $file; // leading $
  private File file1; // non-leading digit
}

See Chapter 1 for naming guidelines.

Separators

Several ASCII characters delimit program parts and are used as separators. (), { }, [ ], and < > are used in pairs:

() { } [ ] < > :: : ; , . ->

Table 2-4 cites nomenclature that can be used to reference the different types of bracket separators. The first names mentioned for each bracket are what is typically seen in the Java Language Specification.

Guillemet characters, a.k.a. angle quotes, are used to specify stereotypes in UML << >>.

Operators

Operators perform operations on one, two, or three operands and return a result. Operator types in Java include assignment, arithmetic, comparison, bitwise, increment/decrement, and class/object. Table 2-5 contains the Java operators listed in precedence order (those with the highest precedence at the top of the table), along with a brief description of the operators and their associativity (left to right or right to left).

Literals

Literals are source code representation of values. As of Java SE 7, underscores are allowed in numeric literals to enhance readability of the code. The underscores may only be placed between individual numbers and are ignored at runtime.

For more information on primitive type literals, see “Literals for Primitive Types” in Chapter 3.

boolean isFullRelation = true;
boolean isHalfRelation = Boolean.valueOf(false); // unboxed
boolean isEndogamyPresent = false;

char charValue1 = 'a';
// An apostrophe
Character charValue2 = Character.valueOf(''');

int intValue1 = 34567, intValue2 = 1_000_000;

Integer integerValue1 = Integer.valueOf(100);

public static final int INT_VALUE = -200;

int intValue3 = 0X64; // 100 decimal from hex

int intValue4 = 0144; // 100 decimal from octal

char msgValue1 = 0b01001111; // O
char msgValue2 = 0B01001011; // K
char msgValue3 = 0B0010_0001; // !

long longValue = 100L;

[whole-number].[fractional_part][e|E exp][f|F|d|D]

float floatValue1 = 9.15f, floatValue2 = 1_168f;
Float floatValue3 = new Float(20F);
double doubleValue1 = 3.12;
Double doubleValue2 = Double.valueOf(1e058);
float expValue1 = 10.0e2f, expValue2=10.0E3f;

String stringValue1 = new String("Valid literal.");
String stringValue2 = "Valid.
On new line.";
String stringValue3 = "Joins str" + "ings";
String stringValue4 = ""Escape Sequences"
";

// Adds String "thisString" to the pool
String stringValue5 = "thisString";
// Uses String "thisString" from the pool
String stringValue6 = "thisString";

String stringValue7 = new String("thatString");
String stringValue8 = stringValue7.intern();

String n = null;

Escape Sequences

Table 2-6 provides the set of escape sequences in Java.

Different line terminators are used for different platforms to achieve a newline (see Table 2-7). The println() method, which includes a line break, is a better solution than hardcoding and when used appropriately.

Unicode Currency Symbols

Unicode currency symbols are present in the range of u20A0–u20CF (8352–8399). See Table 2-8 for examples.

A number of currency symbols exist outside of the designated currency range. See Table 2-9 for examples.