Java tutorial: initializing variables, literals, escape sequences, Introducing String class

References/Links: http://pasted.co/109159db

Chapters

• Literals
• Boolean, Integer and Long Literals
• Double and Float Literals
• Introducing Upcast and Downcast
• Character Literals
• Double and Float with hexadecimal and exponents
• String Literals and Introducing String Class
• Character Escape Sequence
• Special Character Escape Sequence
• Conventional naming for numeric literals
• Declaring Multiple Variables using ","

Hello everybody! This is brainy ghosts and today we're gonna discuss initializing variables, literals, escape sequences and introduce the String class.

If you're ready then let's get started!

We're gonna use the Beginner class that we created in previous tutorial, If you deleted it or it's missing please check the link above and download the Beginner class there so you won't write all the code again. Open your preferred text editor then open the Beginner class. In previous tutorial we just declared instance variables in the Beginner class then the JVM assigns a default value to each variables implicity. Today we're gonna explicity initialize the instance variables here, before we do that let's discuss the literals first.

Literals

Literals are notations for representing a fixed value in source code. It is syntactic representation of boolean, character, or String data. Literals provide a means of expressing specific values in your program.

Here are examples of literal types in java:

Base System literals

Binary - e.g. 0b11110101(0b followed by a binary number)

Octal - e.g. 0365(0 followed by an octal number)

Decimal - e.g. 245

Hexadecimal - e.g. 0xF5(0x followed by a hexadecimal number)

Type Literals

Boolean Literals: true,false

Character Literals: e.g. 'A'

Integer Literals

Decimal: e.g. 245(default literal for byte, short, int and long type)

Binary:  e.g. 0b110111

Octal:  e.g. 0615

Hexadecimal:  e.g. 0xFF6655

Long Literals: 

Decimal:  245L

Binary: e.g. 0b110111L

Octal: e.g. 0615L

Hexadecimal: e.g. 0xFF6655L

Float Literals: e.g. 3.50f

With exponents: 1.72E3f

Hexadecimal floating-point with mandatory exponents and "f" suffix: 0x.5FP0f, 0x5.FFP2f

Double Literals: e.g. 3.50(default literal for double)

With optional "d" suffix: 3.50d

With exponents: 1.72E3d

Hexadecimal floating-point with mandatory exponents and "d" suffix: 0x.5FP0d, 0x5.FFP2d

Null Literal: &null

String Literals: e.g. "String"

Boolean, Integer and Long Literals

Now that we know what literals are let's try to add those in our code. To initialize a primitive variable we will use the assignment("=") operator then write the literal that we want, then type of literal must match the type of the variable.

Let's start with the boolean, there is two boolean literal values and that's the true and false. There's no byte and short literal to java so we will use the integer literals for these two because integer literals is the default literal value for numeric data type like byte, short, int and long.

Code:
public class Beginner
{
   boolean booleanVar = true;
   byte byteVar = 100;
   short shortVar = 1000;
   int intVar = 1000000;
   long longVar = 100000000L;
   //more codes here later...

  public static void main(String[] args)
  {
    Beginner beginner;
    beginner = new Beginner();

   //more codes here later...


  }
}

Adding the "L" suffix in long literal is optional when we write a literal that is in the size range of int for example if we put 10,000 as the long variable value, the compiler won't complain about the missing "L" suffix.

Code:
public class Beginner
{
   boolean booleanVar = true;
   byte byteVar = 100;
   short shortVar = 1000;
   int intVar = 1000000;
   long longVar = 10000;
   //more codes here later...

  public static void main(String[] args)
  {
    Beginner beginner;
    beginner = new Beginner();

   //more codes here later...


  }
}

compile the code and check the result. We can see that the compiler didn't complain about the missing "L" suffix. If we try to change the literal to a higher value like 10 billons, let's try that, put 1 then 10 zeroes then compile and run the program. We can see that the compiler complain and throws an error "The integer value too large".

"integer too large" error

this error occurred because the compiler knows that the integer size of int is ranging from -2,147,483,648 to +2,147,483,647 and because we didn't put an "L" suffix at the end of the value, the compiler consider this literal as an int then this value is too large for int to store that's why the compiler throw that error.

If we put the "L" suffix then compile and run the program. We can see that the compiler didn't throw an error, that's because we put the "L" suffix at the end of the literal and now the compiler knows that this literal is a long literal.

You might wonder: I thought when assigning an integer literal to another numeric data type like long the compiler will do the conversion automatically so why did the compiler still throw an error?

That's because, the compiler will check the literal first before converting it to the type of the variable so the compiler will consider the literal as an integer literal because it doesn't have an "L" and since the literal value is out of range for int, the compiler will complain.

Double and Float Literals

For the double literals adding "d" suffix is optional when writing a decimal values, so if we type 0.5, this literal is a double, if we want to be more specific we can put the "d" suffix at the end e.g. 0.5d. For float literals we need to put the "f" suffix at the end so the compiler will know that this literal is a float literal.
Note: If you're dividing two whole(int) numbers, putting the suffixes of double and float affects the result of our division e.g. 1000/60 = 16.0 , 1000f/60f = 16.666666