Untitled design - 2023-01-10t204625.383

A literal in Java is a type of value that represents a fixed, literal value of a primitive type or a String type. Examples of literal values in Java include integer literals, character literals, string literals, boolean literals, and float literals. This article will provide an overview of the different types of literals that are available in Java and how to declare them.

What is a literal in java

A literal, in the context of Java programming, is a notation for representing a fixed value in the source code of a program. In the language, there are several kinds of literals for different primitive data types. This can include numerical values, Boolean truth values (true or false), and character strings.

More precisely, a literal has two main components; one is the value itself (i.e., 12.3 or ‘a’), and the other one is its type (float, int, boolean). By declaring and initializing variables with literals directly in your code you can save time while writing and reading them as they are self-explanatory as to their contents and meaning when read by someone else. Further, variables declared with literals can also make code easier to maintain since they do not require an extra statement in order to define their value at runtime which saves memory resources.

In Java, all floating point numbers are double by default before being stored into memory; therefore if precise floating point number calculations need to be done they should be declared with an explicit decimal point (e.g., 2.0 instead of just 2). Additionally, whenever you declare strings you must provide them with single quotation marks otherwise it will not be interpreted correctly as text thus potentially leading to errors during runtime execution or failing certain debugging tests such as unit testing if implemented within your development process workflow!

Declaring Literals in Java

In Java, a literal is a fixed value that is assigned to an object. A literal can be a number, a character, a string, or a boolean.

In this article, we’ll discuss how to declare a literal in Java and what the different types of literals are. We’ll also look at how to use literals in some common programming tasks.

Untitled design - 2023-01-10t204647.236

Integer Literals

Integer literals are numeric constants, having no fractional component and no exponent. They are used to represent whole numbers and can be expressed in base 10 form (the most common way of using numbers, such as 1, 050 or -500), or hexadecimal form with a 0x prefix (such as 0x18D9), or octal form with a 0 prefix (such as 0876).

Integer literals can have a suffix of U and/or L to indicate the data type of the literal, such as:

  • U for unsigned int. Unsigned integer literals must be non-negative values.
  • L for long. Long integer literals must have an uppercase “L” suffix. For example: 123456789L

It’s important to note that decimal, hexadecimal, and octal literals do not require a prefix unless otherwise noted. Negative values must be indicated using the minus sign before the number itself (-234 or -0x234). Decimal numbers may contain underscores as separators (_) in order to make them more readable; however, these underscores will be ignored by Java’s compiler.

Floating Point Literals

Java defines literal constants as fixed values that are written directly in a command. Floating point literals are treated as double types by default so their values should end in an F if they are to be considered float types. Floating point literals must include a decimal point, a decimal digit and either an exponent (e) or a fractional part. They may also include an optional negative sign.

Examples of floating-point literals include:

  • -3.14f is treated as a float constant, with the value 3.14
  • 1e5f is treated as the float constant 100000F
  • 4.2e-3 is interpreted by Java to be equal to 0.0042

Character Literals

In Java, character literals are representations of characters which are enclosed within a single quotation mark ‘ ‘. For instance, the main statement of a program can be written as ‘main()’.

Java supports both Unicode character as well as ASCII characters and literals for this purpose. Character literals can consist of single characters, escape sequences (such as n) or octal digits.

For example, the following code prints out the character after A – B on the console:

char c = ‘A’ + 1;

System.out.println(c); //prints out B

Similarly, various other operations such as addition, subtraction can also be performed with character literals to produce desired characters. The output depends on the encoding scheme in use and may vary with different Java compilers.

String Literals

String literals are enclosed in quotation marks and can contain any combination of letters, numbers, special characters, and escape sequences. For clarity, it is recommended to use the character when writing out Strings on a single line. Using this backslash will allow the compiler to ignore all characters that follow until it finds a matching quotation mark.

Java string literals are considered immutable objects; meaning once they are created they cannot be altered. This is not necessarily true of all Java objects but can be assumed for most basic types like Strings and integers. An immutable object’s internal state cannot be changed once initialized, thus providing greater stability for other objects that may depend on it.

When declaring a String literal in Java, there are two primary ways to format it: with double quotes (“”) or with single quotes (”). Single quotes must always be used in order to differentiate them from other text within the same string that may be enclosed by double quotes. Additionally, escape sequences such as ‘n’ should always begin and end with a single quote character since they may contain strings spanning multiple lines of code.

Untitled design - 2023-01-10t204710.532

Boolean Literals

In the Java language, boolean literals can be used to represent true or false values. Boolean literals are special symbols and they are treated differently than other data types in Java. The primary syntax for declaring a boolean literal is to use one of the two keywords true or false.

Boolean variables, like any other data type in Java, must be declared before they can be used by a program.

When declaring a boolean literal directly in your code it is important to remember that only the lowercase letters “t” for true and “f” for false will be accepted by the compiler. In addition, these literals must appear unquoted and without any other characters around them otherwise a compiler error will occur. For example:

// Boolean Literals

boolean myBoolean1 = true;

boolean myBoolean2 = false;

Examples of Literals in Java

A literal in Java is a fixed value that can be assigned to a variable in a program. It is a value that never changes during the course of the program. Literals can be numbers, strings of characters, boolean values, or null. In Java, there are several types of literals including numeric, string, Boolean, and character literals.

Let’s look at some examples of literals in Java:

Integer Literals

In Java, a literal is a data value written into the code. Literals come in different types, such as integer literals, boolean literals, character literals, and string literals. Integer literals are integral numbers used to represent whole numbers. These literals can be written in the form of decimal integers, octal integers (base 8), or hexadecimal integers (base 16). In all cases, the integer literal’s type is int.

  • Decimal Integer Literals: A plain number can be used to represent a decimal integer such as 35 or -99999.
  • Octal Integer Literals: An octal number must begin with a leading 0 (zero) followed by one or more digits from 0 to 7 (e.g., 012; 007). Octal numbers must not exceed 2147483647 and must not be negative.
  • Hexadecimal Integer Literals: A hexadecimal number must begin with a leading 0x followed by one or more digits from 0-9 and/or letters from A-F (e.g., 0x19aF; 0xFF). Hexadecimal numbers must not exceed 9223372036854775807 and must not be negative.
  • Long Integer Literals: If an integral literal suffixed with an uppercase ‘L’ or lowercase ‘l’ is encountered at compile time then it will always be treated as long integer properties rather than an int type value even if its numeric size qualifies within that of an int property value size limits imposed by the Java reference implementation – values within this range cannot utilize either of these post fix identifiers even if so desired by the programmer because its numeric size does qualify within the range of what is recognized as being a long integer type data value for that particular implementation. Long integer values are denoted using prefixes L or l respectively after its associated numeric representation going up to 231 – 1 (2147483647L/l) while its embedded companion utilizing full 64 bit representations extends up to 263 – 1 ((9223372036854775807L/l)).

Floating Point Literals

Floating Point literals are used for working with decimal numbers in Java. A Floating Point literal is any number that has a decimal point, such as 3.14 or 4.567. For double-precision and long numbers, an ‘L’ is used at the end of the number to signify that it is a long datatype (long integer) or a double (decimal). An upper-case ‘D’ can be used as an alternative to ‘L’ but it is not recommended as this can cause confusion with Regular Expression syntax in Java and result in compilation errors.

The syntax for a Floating Point literal looks like this:

where is optional, is required and is optional when the number contains the letter ‘E’ (for exponential notation).

Examples of Floating Point literals include:

  • 4.30F (Float Literal)
  • -52.4D (Double Literal)
  • 0.675L (Long Literal)

Character Literals

In Java, character literals are atomic pieces of data that denote a single alphanumeric character. A character literal consists of a single quotation mark followed by one character, or alternatively an escape sequence denoting a single character enclosed in single quotes. For example, the integer litrals ‘a’ and ‘n’ are both valid.

Character literals can represent any Unicode character, including letters, numbers, symbols or special characters (like line breaks). Character encodings like UTF-8 and ISO-8859-1 allow different characters to be represented by different sets of numbers in software applications.

In Java programming language there are two kinds of such encodings: verbatim (plain) character literals and escaped characters. Verbatim literals use only one symbol to represent a char–one within single quotes. Escaped characters are enclosed in quotation marks (‘) but preceded by a backslash (). The most commonly used escaped characters are ‘t’, ‘b’, and ” which stand for ‘tab’, ‘backspace’ and ‘single quote’ respectively.

It is important to note that unlike integer literals in Java , you cannot specify octal or hexadecimal values when writing a character literal – they must be defined as normal ASCII codes or escaped with quotation marks preceded by the backslash sign.

String Literals

String literals in Java are written with double quotes. A string literal is a sequence of characters used to represent text. A string literal is composed of either a single quoted character such as ‘A’ or a sequence of characters enclosed in double quotes, such as “Hello World!”. In Java, it is possible to have string literals that span multiple lines using the backslash character (\) after each line break.

When writing string literals, Java allows three types of escape sequences that can be used to represent certain special characters. The backslash (\), single quote () and double quote () are both used for this purpose. The backslash can also be followed by one or more octal digits to produce an alternate Unicode representation for non-printable ASCII characters.

Examples of Java String literals could include:

  • “This is a single line string”
  • “This isna multi-line string”
  • ‘a’
  • “”Special” Characters Here”

Boolean Literals

Boolean literals are special tokens that have only two possible values: true and false. Boolean data type is used to store a boolean value. Java has two boolean literals, namely true and false. The default value of a boolean variable is false. Boolean literals are the most basic literals in Java and do not require any declaration to represent them in memory.

Java provides us with three types of Boolean operators–and (&), or (|) and not (!). And operator returns true if both operands are true, or operator returns true if any one operand is true, and not operator reverse the result, i.e., it reverses the truth value of a condition or an expression.

For example, consider the following condition – (a == 5) & (b > 3). Here we have used the & operator which will return True only when both operands are True i.e., when a equals 5 and b is greater than 3 otherwise it will return False.


In summary, the syntax for declaring a literal in Java is the following:

[data type] [name] = [literal];

For example:

  • int x = 5;
  • double y = 3.14159;
  • String name = “John Smith”;
  • boolean isRaining = true;

Take caution when dealing with type conversions because you won’t be able to assign a double to an int variable. Always validate that the data types are compatible and use typecasting if necessary. Once you understand how to declare literals in Java, you are on your way to unlocking further advanced concepts and topics within the language.