Java tutorial: Typecasting(primitive types)

Chapters

• Typecasting(primitive types)
• Upcasting Primitive Type
• Downcasting Primitive Type
• Downcasting a Value That Exceeds Destination's Capacity
• Casting a Type to Character Primitive
• Non-Floating Point Typecasting During Operation
• Casting a Floating-Point to a Floating Point
• Casting a Floating Point to a Non-Floating Point
• Casting a Non-Floating Point to a Floating Point
• Floating and Non-Floating Point Typecasting During Arithmetic Operation

Typecasting(primitive types)

Type casting in java is casting a type explicitly or implicitly to another type in their respective data type group. In other words, you can only cast a primitive type to another primitive type and an object type to another object type, for example, you can cast int to float and class instance to another class instance. 

In this tutorial we will focus on casting primitive data types, casting reference types will be covered in future tutorials. Also, you can somewhat cast a primitive to a reference type, for example, int primitive to Integer reference type and that topic will be also covered in future tutorials. There are two distinct type of typecasting in java, the widecast or upcast and the narrowcast or downcast.

Upcast is also called implicit conversion because once you convert a specific type to another type it will be converted automatically without writing some extra explicit cast syntax. Downcast or explicit conversion, on the other hand, needs an extra explicit syntax to cast a specific type to another type with a possible of data loss.

You might wonder: "if downcast can cause data loss then it is not a good idea to do a downcast because it will ruin the value of the data that i want to convert". Well, that's one of the possible reason why java restricts automatic conversion when doing a downcast, In other words, We are downcasting because we know what we are doing.

These are the several reasons that can cause data loss when downcasting: casting a floating-point to integer for example casting float to int, when you cast float to int the decimal or fractional part of that float will be lost. Next is, casting a large data value that exceed the size of the destination type. For example, if you convert int to byte and the int value is larger than the size of the byte that it can hold, the int value may lose some of its value.

Here's a figure guide for java primitive type casting.

To clearly understand typecasting and all of the thing that we discussed let's test it on actual coding. First create a java source file in our workspace folder, then name it "SampleConversion" and then write the basic code structure of our source file the public class and the main method.

Code:
public class SampleConversion
{

 public static void main(String[]args)
 {
   
 }

}

Then, let's declare and initialize some primitive variables in the main method.

Code:
public class SampleConversion
{

 public static void main(String[]args)
 {
   int intVar = 0;
   byte byteVar = 0;
 }

}

Notice that we initialized the variable in the main instead of initializing it on the top of the main method. These variables are called a local variables. Local variables will cease to exist when the execution leaves the method where they reside.

Upcasting Primitive Type

Now, Let's try the upcast, to do that assign the byte variable to the int variable then compile and run.

Code:

public class SampleConversion
{

 public static void main(String[]args)
 {
   byte byteVar = 100;
   int intVar = byteVar;

   System.out.println("byte: " + byteVar);
   System.out.println("int: " + intVar);
 }

}

As you can see the int variable has a value of 100 which is the same value of our byte variable. You might wonder that the byte variable value should move to int variable since we assigned it to int. Well, java copied byteVar value and assigned the copied value to intVar. When doing upcast or widecast be sure to follow the order of data type in the upcast figure that I showed earlier.

Downcasting Primitive Type

Next is the downcast, to do downcast follow me, let's try to downcast int to byte as an example, we did the upcast earlier and now we will be doing the downcast which is the reverse process of upcast. Assign a 100 value to the int variable then assign the int variable to byte.

Code:

public class SampleConversion
{

 public static void main(String[]args)
 {
   int intVar = 100;
   byte byteVar = intVar;

   System.out.println("byte: " + byteVar);
   System.out.println("int: " + intVar);
 }

}

When we run this now we will receive an error, try to run the code. As you can see an error occurred, I already demonstrated this in previous tutorial so I suppose you're familiar with it. To remove that error type, we need to specify the target type in parentheses like this (target-type) before the primitive type that we want to convert, then compile and run.

Code:

public class SampleConversion
{

 public static void main(String[]args)
 {
   int intVar = 100;
   byte byteVar = (byte)intVar;

   System.out.println("byte: " + byteVar);
   System.out.println("int: " + intVar);
 }

}

As you can see we discarded the error, we cast an int value to byte and our program runs normally.

Downcasting a Value That Exceeds Destination's Capacity

Now, let's try to convert a larger int value to byte let's try 1000, If we assign 1000 to a byte data loss will occur let's try it! change the value of int variable to 1000 then compile and run.

Code:

public class SampleConversion
{

 public static void main(String[]args)
 {
   int intVar = 1000;
   byte byteVar = (byte)intVar;

   System.out.println("byte: " + byteVar);
   System.out.println("int: " + intVar);
 }

}

As you can see the converted value is too far off from the original value. You might asked yourself "Why the converted value is -24, How's that happened?". If you want to have a deep understanding about the situation I recommend you to study decimal and binary number system, one's and two's complement, adding and subtracting binary numbers. I won't cover those topic here, those topic are not part of this tutorial maybe I will cover them in my future tutorials.

To have a better understanding on how the converted value end like that we will use the windows calculator instead of computing it manually. Open the calculator type then switch to the programmer's mode, then make sure decimal or Dec radio button is selected and select the dword radio button,we will use dword which is a 32-bit value, since int data type is 32-bit.

Switching to Programmer's mode

Setting our calculator

Then input the int value which is 1000, then click the binary or bin radio button to convert the int value to binary. Also, focus on the bits that is highlighted in red

Converting 1000 from decimal to binary

When java converts the int value to byte some bits of int value to the left will be discarded, so to do that in the calculator all we need to do is to click the byte radio button to change the bit size to 8 bits which is the size of byte data type in java.

Converting int bits to byte bits

As you can see the left bits at the left side was discarded. Then, click the dec radio button to convert the binary to decimal and as you can see the answer on the calculator is the same as the output on the console.

Converting binary to decimal

If you know how the general conversion of binary to decimal you might say that this binary is equal to 232 when converted to decimal. Well, That's true when you convert an unsigned numbers to binary, unsigned numbers means a data that has no negative value just a plain whole numbers, but we're converting a signed numbers and to convert a signed number java uses the two's complement method.

We did use two's complement on the calculator earlier and we didn't notice that we used it because the calculator did most of the work for us. The procedure that we used earlier at the calculator can also work on other integers like long and short if you have spare time try to downcast other data types like long to int or short to byte then compute the output using calculator.

Casting a Type to Character Primitive

What about casting a type to char, Since char is separated from integer data types such as byte,short,int and long and floating-point data types like float and double, downcasting is needed.

Code:

public class SampleConversion
{

 public static void main(String[]args)
 {
   int intVar = 1000;
   byte byteVar = (byte)intVar;
   char charVar = (char)intVar;

   System.out.println("byte: " + byteVar);
   System.out.println("int: " + intVar);
   System.out.println("char: " + charVar);
 }

}

What about downcasting a type to boolean? I suppose we can't downcast any data type to boolean. Remember, when downcasting, don't forget the parentheses then the data type in the parentheses.

Non-Floating Point Typecasting During Operation

Apart from boolean and long type, When two non-floating points are both operands in one operation, the result is upcasted to the primitive type with the highest bits which is int.

Actually, long(64 bits) is the primitive type with the highest bits to all non-floating point numbers. However, when we exclude long then the primitive type with the highest bits is int(32 bits).

public class SampleConversion{

  public static void main(String[]args){
    short s1 = 50;
    
    //valid
    int intOne = s1 + 100;
    
    //error: possible lossy conversion
    //from int to short 'cause the
    //result is int
    //short s2 = s1 + 100;
    
    //invalid
    //result is converted to int
    //byte b1 = 25;
    //short s1 = 50;
    //byte b2 = b1 + s1;
    
    //valid
    //result is long since long
    //has higher bits than int
    long longOne = 100 + 100L;
    //invalid
    //int intOne = 100 + 100L;
    
    //valid
    int intTwo = 'c' + 5;
    
    //if char and an integer literal
    //are both operands in one operation
    //and the result is gonna be stored
    //in a char variable then, the result
    //is gonna be char type
    
    //valid
    char character = 'c' + 5;
    
    //invalid
    //int intOne = 5;
    //char character = 'c' + intOne;
    
  }
}

Casting a Floating-Point to a Floating Point

Float primitive type can be upcasted to double and double can be downcasted to float.

public class SampleConversion{

  public static void main(String[]args){
    //upcasting float literal to double
    double doubleVar = 5.55f;
    System.out.println(doubleVar);
    
    //converting double literal to float
    //Just like other primitive types,
    //downcasting double to float can
    //cause data loss if the double
    //value that is gonna be casted exceeds
    //the bit range of float. Double is
    //64bits whereas float is 32bits
    float floatVar = (float)200.598333d;
    System.out.println(floatVar);
  }
}

Casting a Floating Point to a Non-Floating Point

What about casting a floating point to a non-floating point? When we cast a floating-pont to non-floating-point then the decimal places will be discarded.

Code:

public class SampleConversion
{

 public static void main(String[]args)
 {
   float floatVar = 55.5f;
   byte byteVar = (byte)floatVar;

   System.out.println("byte: " + byteVar);
 }

}

When we run this code, we will see that the decimal part of floatVar has been truncated.

Casting a Non-Floating Point to a Floating Point

Casting a non-floating point to a floating point is simply like upcasting.

public class SampleConversion
{

 public static void main(String[]args)
 {
   int intVar = 100;
   float floatVar = intVar;
   System.out.println("float: " + floatVar);
   
   long longVar = 100000L;
   double doubleVar = longVar;
   System.out.println("float: " + doubleVar);
 }

}

Floating and Non-Floating Point Conversion During Arithmetic Operation

When a floating point and a non-floating point are both operands in one operation, the result is converted to floating point.

public class SampleConversion{

  public static void main(String[]args){
    
    //error: lossy conversion from float to
    //int 'cause the result is float
    //int intOne = 20 + 30.5f;
    
    //downcast the float literal to int first
    //if you want the result to be converted
    //to int
    //int intOne = 20 + (int)30.5f;
    //System.out.println(intOne);
    
    //valid
    float floatOne = 20 + 30.5f;
    System.out.println(floatOne);
  }
}

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

Java tutorial: variables, data types, instantiate class

References/Link: http://pasted.co/dd01a501

Chapters

• Naming Java Identifier/s
• Java Variables
• Primitive Type
• Reference Type
• Applying Identifiers, types and variables to our code
• Instance and Local Variables
• Primitive and Reference Default Values
• Declaring Various Primitive Types
• "non-static variable to static context" error
• "might not have been initialized" error
• line number error indicator
• Brief Introduction to Java errors and warnings
• Assigning values to our reference variable
• Brief Explanation of Heap and Stack Memory
• Another way of instantiating a class or assigning a value to a variable
• Displaying instance variable values on the console
• Introducing print() method
• Understanding the difference between print() and println() method
• Windows cmd Up and Down Command Shortcut
• char default value
• Difference between char null value and reference type null value
• Some tips on how to avoid certain beginner's error
• The var Type Name

Hello everybody! This is brainy ghosts and today we're gonna discuss variables, the assignment operator, data types, naming java identifier syntactically, Instantiate class, the print() method and some tips to avoid some beginner's error. Some of these topics must be familiar because I mentioned some of them in previous tutorials. 

Naming Java Identifier/s

Alright! Let's start at naming java identifier syntactically. Identifiers are the names of variables, methods, classes, packages and interfaces. Here are the rules for naming java identifiers: 

1.) All identifiers should begin with a letter, currency($) character or an underscore(_).

2.) Identifiers can have any variation of character after the first character.

3.) Identifiers can't use reserved keywords

4.) Identifiers are case sensitive.

I already mentioned the last two rules in previous tutorial so you must be familiar with it. Here are some example of legal and illegal identifiers:

legal:(e.g. $income, profit, _wrapper).

Illegal:(e.g. 1dude, +oneForU, 7UP).

Java Variables

Next is variables, A variable or scalar is a storage location paired with an associated symbolic name (an identifier), which contains some known or unknown quantity of information referred to as a value. 

Variable is a combination of data type and an identifier. Here are some examples of declaring a variable in java.

Variable declaration without value
int myInt;

Variable declaration with value
int myInt = 10;

Variable declaration that instantiate(create) object
String myString = new String("String");

Data Type

Data type or simply type is a classification of data which tells the compiler or interpreter how the programmer intends to use the data. Most programming languages support various types of data. Java has two groups of data type: the primitive and reference type.

Primitive Type

Primitive data types stores only one value and acquire a certain amount of memory space. Java defines 8 primitive types.

Eight Primitive Types

Reference Type

Reference or object types are any classes that can be instantiated as well as arrays. Here are some reference/object types in java.

Reference Types

Notice the first 8 references, some of them looks like primitive types but they are not. Remember java is case-sensitive so boolean is different from Boolean.

boolean vs Boolean

Arrays and more reference data types will be covered in future tutorials I'll only show some reference data types here.

You can create your own object types by creating custom classes that will be discussed in future tutorials. Remember all of the things that has been discussed here and try to take notes if possible so that you can review those information easily when those information is applied at coding. 

Applying Identifiers, types and variables to our code

create a source file in the package folder that we used in previous tutorial then name it "Beginner" then write the basic program structure that we learned.

Basic Program Structure

Alright! let's apply those information that we discussed earlier. First, let's declare a variable, to declare a variable, follow this general variable syntax:

datatype identifier;
or
datatype identifier = value;

Declaring a variable

This type of variable is called "primitive variable" because its data type is primitive. This variable is also consider as an "instance variable". 

Instance and Local Variables

Variable can be defined by its data type and location. When variable is declared in the class but not in its nested blocks like intVar variable then it is called an instance variable. When variable is declared in class nested block like constructor, method, etc. then it is called local variable. 

Local variables are only accessible in its block and the nested blocks in that block. It will be removed once the compiler is done executing the block.

Primitive and Reference Default Values

When we declare a primitive variable we see that it has no value, but when instantiate(we will learn class instantiation later) our class, the declared variable will implicitly initialize. Here are the default values of primitive and reference types.

You might ask: "What is a nested block?" To put it simply, blocks are elements in java that have pairs of braces({}). Nested block is a block in a block.

Primitive and Reference Default Values

Here are the default initial values of each primitive variables when implilicity initialized. Notice the character default value in single quotation mark, in previous tutorial, we use the double quotes in the println() method. Well, the difference is that the text or number that is in the single quotes is a character literal which is a char type while the text or number in the double quotes is String literal which is a string type.

Declaring Various Primitive Types

Okay! let's try to declare variables with different primitive data types, after that we will use the println() method to display their default initial value.

Declaring Additional Primitive Variables

All we need to do now is to write println() method in the main and put the variable name in the parentheses. Let's give it a try! And compile our code after.

println() method to print variable value

"non-static variable to static context" error 

There's an error when we compile our code, the compiler said "non-static variable varBoolean cannot be referenced from a static context." this means we cannot reference non-static instance variable directly to a static context.

Note: "cannot be referenced" means cannot be used. It means that, We can't put a non-static variable in a static context. We can think of "static context" as context that is related to static elements like methods, fields, etc.

"non-static variable to static context" error 

But why? that's because non-static instance variable need to obviously exist in order to use, in contrast to static context because static context already exist.

Remember this, non-static instance variables like these variables and other non-static context in the class belongs to its instance whereas static variables and other static context belongs to the class itself. 

There are two ways to fix this error:

First, we declare each variable static, the solution is not good in this case because it's tedious to do(Note: too much use of static context is not a good practice). The second solution is to create a class instance in the main method.

We will use the second solution because it's easier to type, we don't need to type static keyword in each variable and it is an efficient solution to our problem. To create or instantiate a class we need to declare a class first. Declaring a class is just like declaring a variable that we did earlier, just follow this general class declaration syntax: class-name identifier-name;

Declaring a class(variable)

(Note: Java is case-sensitive so, "Beginner" with capital first letter is the class-name and "beginner" with small first letter is the identifier-name)

After that use the println() method and reference our reference variable to it.

println() method

"might not have been initialized" error

When we compile this code we will receive another error. The error is "variable (class-name) might not have been initialized." we encounter this error because in java, local variables should be initialized explicitly, in other words we are the one that will assign a value to local variables.

"might not have been initialized" error

line number error indicator

Notice the number on the error "(filename).java:(number)" it means that the error in the source file

(filename).java is on the line (number).(Note: If you want to clear all the messages on the console type the command "cls" and execute the command)

line number error indicator

Brief Introduction to Java errors and warnings

Java compiler throws an error and a warning, when the compiler encounter an error our code won't compile  but when the compiler throws a warning, the compiler will still compile our code but that doesn't mean that we will just ignore the warning that the compiler throws.

Java throws a warning because of a poor and inefficient syntax writing or using java obsolete features, It means that our syntax is correct but it is written poorly. We will learn  more about compiler warnings in future tutorials.

Assigning values to our reference variable

To assign a new value to our reference variable we will use the assignment operator, then we will use the new keyword, new keyword allocates memory in heap memory, then type the class name and put an empty parentheses then semi-colon.

Class Instantiation

Let's examine this syntax. First is the data type which is the class-name then the variable name then the assignment operator, assignment operator("=") assigns the value on its right to the operand on its left. It means that the right side operand which is the new class-name(); will be assigned to the left side which is the (class-name identifier), the class-name with a parentheses after the new keyword is called the class constructor. Constructor is beyond to be covered in this tutorial and will be explained in future tutorials so just keep the information in your mind for now.

We can generally call the variable "Beginner beginner;" in the main() a reference local variable, Since the variable data type is a class type and it's a local variable.

Brief Explanation of Heap and Stack Memory

You might be wondering: "what is heap?", java stores values to the heap and stack memory. Heap memory stores objects and the instance variables that the object owns. Stack memory stores method calls and local variables.

Another way of instantiating a class or assigning a value to a variable

There's another way to instantiate a class, the first one that we did was a shortcut, this is the other way to instantiate a class, write a declaration statement, then on the next line type the reference variable identifier first then the assignment operator then the next syntax is the same as the first class declaration syntax.

syntax: class identifier;

             identifier = new Contructor();

These syntaxes that we used are applicable to other types of variables.

Alternative Way to Assign a Value to a Variable

Displaying instance variable values on the console

Now, let's display the initial value of these variable on the console using the println() method. To access the instance variable of the object on this reference variable type this in the println() parentheses, (syntax: class-name.instance-variable-name;), 

Assigning instance variable to println()

We will display multiple values on the console so will use multiple println() method.

Using Multiple println() to display instance variables values

You might notice that the value in the println() parentheses is not enclosed in double quotes but in previous tutorial we see that the println() message is in the double quotes. Well, the text or number that is in the double quotes is a string literal which is an acceptable value in println().

this time we want to display the value of variables so we use the variable name as a value to println() then println() will get the value of that variable and display that value on the console. Also, print() and println() method accept lots of data types as values, you will see the print() method in a moment. 

When we compile and run the code we will see the default values of these variable.

Multiple println() Printing Multiple Values

Introducing print() method

Now, the values are displayed on the console but the message is not very informative so we will add some labels to every value to make it more informative, In this situation we can use the print() method,the difference between print() and println() is the newline that is being added after the message. print() method display a message but it doesn't add a newline while println() method display a message and add a newline at the end of the message.

Let's put the print() method at the top of each println() method.

print() method

After that, let's compile and execute our code and as you can see the console message is now more informative.

Result When print() Method Added To Our Code

Understanding the difference between print() and println() method

If you can't still understand the difference of print() and println() method try this, remove all the print() method then change the println() to print().

Changing Some Portion of Our Code

then run and compile the code. As you can see the values are all on the same line that's because the print() method doesn't add a newline at the end of the message.

Effect of print() method on the console

We will learn more about the newline in the escape sequence topic. After that return the code structure.

Our Code Original Form

Windows cmd Up and Down Command Shortcut

Let's run our code again, and by the way, if you're using cmd like me you can use the Up and Down key to reuse the command that you already typed as long as the cmd is still active, if you close the cmd, the Up and Down key won't work until you don't type another command and execute it. 

char default value

When we run our code you might notice that all of the primitive types have default values except for char type. Well, we can't see the char default value because its default value is a null character, the char default value '\u0000' represent a null character, null means nothing so you know the logic. 

Difference between char null value and reference type null value

Don't be confused with the null default value of an object and the null character, They represent nothing but their usage is different, the null can be used as an object value while the null character can be used as a char value.

If you want more clarification let's try it into our code remove all the code in the main except for the class variable declaration.

remove codes in main() except class variable declaration

If you're text editor that can only undo once like notepad, it's better to cut the code by pressing the ctrl+x and paste it back again so you don't need to type it again, Atom can undo multiple times so it's not necessary to do that.

Let's assign a null value to this variable then put it to println().

Assigning null value to reference variable

Then, run and compile the code, as you can see the value of this variable is null.

null value

Now try to put the default character value then run and compile the code.

assigning null character value to reference variable 

As you can see there is an error, this error means that this value the null character is not compatible to this data type.

"incompatible types" error

Same goes when we assign the null value to a char variable.

assigning null value to char type

Let's undo the changes that we made.

Our Code Original Form

Some tips on how to avoid certain beginner's error

And before I end this tutorial I'll give you some tips on how to avoid certain beginner's error for example: 

1.) In this type of class instantiation(line 17 and 18) we used two lines, when our code execute, it will declare this variable first then create an instance of class and point it to "beginner" reference. When you try to switch these two codes you will receive an error. That error means that you were trying instantiate a class to the undefined identifier, in other words the compiler couldn't instantiate the class because the variable that we put on the left side of the assignment operator didn't exist or declared.

2.) Next tip is the arrangement of your codes for example, when we execute our code the main method execute from the first line to the bottom of its block that's why the printed message on the console is arrange like that, if you try to switch the print() and println() you can see that the printed message arrangement changes too. As you can see code fragments arrangement are also important so be careful when arranging the codes in your source file, you might get an error or unexpected result.

The var Type Name

The var was introduced in java10 and its purpose is to infer types of local variables by looking at the actual type that is assigned to the variable. The use of var is limited to local variables like in for and for-each loops parentheses.

public class SampleClass{
  
  //invalid: can't use var
  //keyword as type of
  //instance variable
  //var myVar = false;
  
  void meth1(){
    //var can be used in this
    //block
    var str = "String";
    
    //var can be used in for loop
    //parentheses
    for(var i = 0; i < 3;i++)
      System.out.println(str);
  }
  
  //invalid: var can't be used as
  //type of method and constructor
  //parameter
  //void meth2(var param){}
  
  public static void main(String[]args){
    //var can be used here 'cause main()
    //is a method like meth1()
    var chararacter = 'c';
    
    //var can't be used as type of an array
    //var[] myStr = new String[]{"A","B"};
    
    String[] str = new String[]{"A","B"};
	
    //var can be used in for-each loop
    //parentheses
    for(var s : str)
       System.out.println(s);
  }
}

var is a reserved type name, not a keyword, which means that existing code that uses var as a variable, method, or package name is not affected. However, code that uses var as a class or interface name is affected and the class or interface needs to be renamed.

public class SampleClass{
  
  //valid method name
  static void var(String s){
    
    //valid variable name
    var var = s;
    System.out.println(var);
  }
  
  public static void main(String[] args){
  
    SampleClass.var("Hello!");
  }
}

//compile-time error
/*
class var{
}
*/