Skip to content
Related Articles

Related Articles

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
Recommended Articles
Page :