Home > Articles > Programming > Java

  • Print
  • + Share This
This chapter is from the book


In addition to variables, you will also use a literal in a Java statement.

New Term

A literal is any number, text, or other information that directly represents a value.

Literal is a programming term that essentially means that what you type is what you get. The following assignment statement uses a literal:

int year = 2000;

The literal is 2000, because it directly represents the integer value 2000. Numbers, characters, and strings all are examples of literals.

Although the meaning and usage of literals will seem intuitive most of the time, Java has some special types of literals that represent different kinds of numbers, characters, strings, and Boolean values.

Number Literals

Java has several integer literals. The number 4, for example, is an integer literal of the int variable type. It also can be assigned to byte and short variables because the number is small enough to fit into those integer types. An integer literal larger than an int can hold is automatically considered to be of the type long. You also can indicate that a literal should be a long integer by adding the letter L (L or l) to the number. For example, the following statement treats the value 4 as a long integer:

pennyTotal = pennyTotal + 4L;

To represent a negative number as a literal, prepend a minus sign (-) to the literal, as in -45.

If you need to use a literal integer with octal numbering, prepend a 0 to the number. For example, the octal number 777 would be the literal 0777. Hexadecimal integers are used as literals by prepending the number with 0x, as in 0x12 or 0xFF.


Octal and hexadecimal numbering systems are convenient for many advanced programming uses, but unlikely to be needed by beginners. Octal numbers are a base-8 numbering system, which means they can only represent the values 0 through 7 as a single digit. The eighth number in octal is 10 (or 010 as a Java literal).

Hexadecimal is a base-16 numbering system, and it can represent 16 numbers as a single digit. The letters A through F represent the last six digits, so the first 16 numbers are 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.

The octal and hexadecimal systems are better suited for certain tasks in programming than the normal decimal system is. If you have ever used HTML to set a Web page's background color, you might have used hexadecimal numbers.

Floating-point literals use a period character (.) for the decimal point, as you would expect. The following statement uses a literal to set up a double variable:

double myGPA = 2.25;

All floating-point literals are considered of the double variable type instead of float. To specify a literal of float, add the letter F (F or f) to the literal, as in the following example:

float piValue = 3.1415927F;

You can use exponents in floating-point literals by using the letter e or E followed by the exponent, which can be a negative number. The following statements use exponential notation:

double x = 12e22;
double y = 19E-95; 

Boolean Literals

The Boolean values true and false also are literals. These are the only two values you can use when assigning a value to a boolean variable type or using a Boolean in a statement in other ways.

If you have used another language such as C, you might expect that a value of 1 is equivalent to true and 0 is equivalent to false. This isn't the case in Java—you must use the values true or false to represent Boolean values. The following statement sets a boolean variable:

boolean chosen = true;

Note that the literal true does not have quotation marks around it. If it did, the Java compiler would assume that it was a string of characters.

Character Literals

Character literals are expressed by a single character surrounded by single quotation marks, such as 'a', '#', and '3'. You might be familiar with the ASCII character set, which includes 128 characters including letters, numerals, punctuation, and other characters useful in computing. Java supports thousands of additional characters through the 16-bit Unicode standard.

Some character literals represent characters that are not readily printable or accessible through a keyboard. Table 3.2 lists the special codes that can represent these special characters as well as characters from the Unicode character set. The letter d in the octal, hex, and Unicode escape codes represents a number or a hexadecimal digit (a–f or AF).

Table 3.2 Character Escape Codes




New line






Carriage return






Single quotation mark


Double quotation mark






Unicode character


C and C++ programmers should note that Java does not include character codes for \a (bell) or \v (vertical tab).

String Literals

The final literal that you can use in a Java program represents strings of characters. A string in Java is an object rather than being a basic data type, and strings are not stored in arrays as they are in languages such as C.

Because string objects are real objects in Java, methods are available to combine strings, modify strings, and determine whether two strings have the same value.

String literals consist of a series of characters inside double quotation marks, as in the following statements:

String quitMsg = "Are you sure you want to quit?";
String password = "swordfish";

Strings can include the character escape codes listed in Table 3.2 previously, as shown here:

String example = "Socrates asked, \"Hemlock is poison?\"";
System.out.println("Sincerely,\nMillard Fillmore\n");
String title = "Sams Teach Yourself Rebol While You Sleep\u2122"

In the last example here, the Unicode code sequence \u2122 produces a !" symbol on systems that have been configured to support Unicode.


Most users in English-speaking countries aren't likely to see Unicode characters when they run Java programs. Although Java supports the transmission of Unicode characters, the user's system also must support it for the characters to be displayed. Unicode support provides a way to encode its characters for systems that support the standard. Although Java 1.0 supported only the Latin subset of Unicode, Java 1.1 and subsequent versions support the display of any Unicode character that can be represented by a host font.

For more information about Unicode, visit the Unicode Consortium Web site at http://www.unicode.org.

Although string literals are used in a manner similar to other literals in a program, they are handled differently behind the scenes.

When a string literal is used, Java stores that value as a String object. You don't have to explicitly create a new object, as you must do when working with other objects, so they are as easy to work with as basic data types. Strings are unusual in this respect—none of the basic types is stored as an object when used. You learn more about strings and the String class today and tomorrow.

  • + Share This
  • 🔖 Save To Your Account