# Scala | Literals

• Last Updated : 01 Apr, 2019

Any constant value which can be assigned to the variable is called as literal/constant. The literals are a series of symbols utilized for describing a constant value in the code. There are many types of literals in Scala namely Character literals, String literals, Multi-Line String literals, Boolean literals, Integer literals, and Floating point literals.

### Types of literals

1. Integer Literals:
The Integer literals are generally of type Int or of type Long when a suffix L or l is added at the end of the Integers. The type Int as well as type Long are all Integer numerals.
Note:
• The range of the type Int is from (-231 to 230).
• The range of the type Long is from (-263 to 262).
• When an Integer literal has a number which falls out of this range then a compile time error arises.

The Integers literals are specified in two ways:

• Decimal literals:
Here, the allowed digits are from 0 to 9.
`val x = 37`
• Hexa-decimal literals:
Here, the allowed digits are from 0 to 9 and characters used are from a to f. We can use uppercase as well as lowercase characters.

```// The hexa-decimal number should be prefix
// with 0X or 0x.
val x = 0xFFF```

Example:

 `// Scala program of integer``// literals`` ` `// Creating object``object` `integer``{`` ` `    ``// Main method``    ``def` `main(args``:` `Array[String])``    ``{`` ` `        ``// decimal-form literal``        ``val` `a ``=` `46`` ` `        ``// Hexa-decimal form literal``        ``val` `b ``=` `0xfF`` ` `        ``// Displays results in``        ``// integer form``        ``println(a)``        ``println(b)``    ``}``}`
Output:
```46
255
```

Note: The Octal form of the literal is obsolete.

2. Floating Point Literals :
This type of literals are of type Double as well as type Float when a suffix F or f is added at the end and we can even specify Double type by suffixed with d or D.
`val x = 3.14159`

Example:

 `// Scala program of floating``// point literals`` ` `// Creating object``object` `double``{`` ` `    ``// Main method``    ``def` `main(args``:` `Array[String])``    ``{`` ` `        ``// decimal-form literal``        ``val` `a ``=` `3.156`` ` `        ``// It is also a decimal ``        ``// form of the literal``        ``val` `b ``=` `0123.34`` ` `        ``// Displays results``        ``println(a)``        ``println(b)``    ``}``}`
Output:
```3.156
123.34
```

Here, we can’t specify literals in Octal or Hexadecimal form.

3. Character Literals :
character literals are either uni-code character which are printable or are represented by escape sequences.
```val x = 'b'
//character literal in a single quote.```
```val x = '\u0051'
//uni-code representation of character literal,
//This uni-code represents Q.```
```val x = '\n'
//Escape sequence in character literals```

Example:

 `// Scala program of character``// literal`` ` `// Creating object``object` `literal``{`` ` `    ``// Main method``    ``def` `main(args``:` `Array[String])``    ``{``        ``// Creating a character literal``        ``// in single quote``        ``val` `x ``=` `'b'`` ` `        ``// uni-code representation of``        ``// character literal``        ``val` `y ``=` `'\u0051'`` ` `        ``// Escape sequence in character``        ``// literals``        ``val` `z ``=` `'\n'`` ` `        ``// Displays results``        ``println(x)``        ``println(y)``        ``println(z)``    ``}``}`
Output:

```b
Q
```

The character literals are enclosed in a single quote.

4. String literals :
The String literals are series of characters, which are available in double quotes. The String literals can be handled smoothly by utilizing String Interpolation.
`val x = "GfG"`

Example:

 `// Scala program of literals`` ` `// Creating object``object` `literal``{`` ` `    ``// Main method``    ``def` `main(args``:` `Array[String])``    ``{``        ``// Creating a string ``        ``// literal``        ``val` `x ``=` `"GeeksforGeeks"`` ` `        ``// Displays string ``        ``// literals``        ``println(x)``    ``}``}`
Output:
```GeeksforGeeks
```

A single line string literals are enclosed in a quotation marks.

5. Multi-Line String Literals :
The multi-line string literals are also series of characters but it has multiple lines.
`val x = """GfG"""`

Example:

 `// Scala program of multi-line``// string literals`` ` `// Creating object``object` `literal``{`` ` `    ``// Main method``    ``def` `main(args``:` `Array[String])``    ``{``        ``// Creating a multiple ``        ``// line string literal``        ``val` `x ``=``""``"GeeksforGeeks``        ``is a``        ``computer science ``        ``portal"``""`` ` `        ``// Displays multiple``        ``// lines``        ``println(x)`` ` `    ``}``}`
Output:
```GeeksforGeeks
is a
computer science
portal
```

The multi-line string literals are enclosed in triple quotes.

6. Boolean Literals :
Boolean literals allow only two values i.e. true and false, which are members of type Boolean.
`val x = true`

Example:

 `// Scala program of Boolean``// literals`` ` `// Creating object``object` `GfG``{`` ` `    ``// Main method``    ``def` `main(args``:` `Array[String])``    ``{`` ` `        ``// Assigning true``        ``val` `a ``=` `true`` ` `        ``// Assigning false``        ``val` `b ``=` `false`` ` `        ``// Displays results``        ``println(a)``        ``println(b)``    ``}``}`
Output:
```true
false
```

My Personal Notes arrow_drop_up