Basic Data Types

Primitive Data Type

• Byte is a 8 bit data type
• It's range is -128 to 127.
• It's default value is zero.
• It is the smallest java integer type. Byte is four times smaller than an int.
• Example : byte x = 90, byte y =- 60.

• Short is 16 bit signed type.
• It's range is 32,768 to 32,767.
• Default value is 0.
• Short is 2 times smaller than an int.
• Example :short s= 20000 , short r = -30000

• Int is a 32-bit data type.
• It's range is from 2,147,483,648 to 2,147,483,647.
• For integral value int is generally used.
• Default value is 0.
• Example : int a = 200000, int b = -300000.

• Long is 64 bit data type.
• It's range is -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807.
• Long is used where we need to store a wider range data than int.
• It's default value is 0L.
• Example : int a = 100000L, int b = -200000L.

• Double is used ,when fractional precision calculation is required.
• It is 64 bit double precision data type.
• It's default value is Default value is 0.0d.
• Example : double d = 123.4.

• float is 32 bit single precision type.
• It is used when fractional precision calculation is required.
• Default value is 0.0f.
• Example : float f1 = 234.5f.

• When we need to represent one bit of information, we use Boolean data type.
• It takes two values true and false.
• It is generally used where we need to track true/false conditions.
• Default value is false.
• Example : Boolean one = true.

• char is 16 bit type and used to represent Unicode characters.
• Range of char is 0 to 65,536.
• Example . char letter ='A' .

• Reference data types or objects are created using class constructors. It's type can't be changed after declaration.
• Default value of any reference variable is null.
• A reference variable can be used to refer to any object of the declared type or any compatible type.
• Example : Mainclass mc = new Mainclass("Ankit") . 

Java Variable Types

• Local variables
  
• Instance variables
  
• Class/static variables
  

Local Variables

• The variables which are declared inside methods, constructors, or blocks are known as local variables.
• These variables have local scope i.e. it can't be access outside the program.
• Need initial value assignment before use.
• Access modifiers cannot be used for local variables.
  

package corejava;
public class Main {
        public void Age() {
                int age = 0;
                age = age + 7;
                System.out.println("Age: " + age);
        }

        public static void main(String args[]) {
                Main m = new Main();
                m.Age();
        }
}

Instance Variables

• This method declared outside methods, constructors, or blocks .
• When memory is allocated for object, the space slot for each instance variable value is created.
• Instance variable created and destroyed with the creation and destruction of object.
• More than one method , constructor or block can refer to the values hold by instance variable.
  
• Access modifiers can be given for instance variables.
  
• The default value of instance variable for numbers is 0, for Boolean it is false, and for object references it is null.
  
• Inside class , you can access variable by calling variable name directly without using any object reference. But within static methods and different class, it should be called using object reference as : ObjectReference.VariableName
  

public class Student {
// this instance variable is visible for any child class.
public String name;
// salary variable is visible in Student class only.
private int marks;
// The name variable is assigned in the constructor.
public Student(String StudName) {
name = StudName;
}
// The marks variable is assigned a value.
public void setMarks(int studMarks) {
marks = studMarks;
}
// This method prints the student's details.
public void printStud() {
System.out.println("Student name : " + name);
System.out.println("Marks :" + marks);
}
public static void main(String args[]) {
Student st = new Student("Divya");
st.setMarks(80);
st.printStud();
}
}

Class/Static Variable

• Class variable also declared outside a method, constructor or a block with a 'static' keyword.
• Class variable has only one copy for each class, regardless of how many objects are created from it.
• Static variables are generally used as constant. Constants are variables that are declared as public/private, final and static. Constant variables never change from their initial value.
• Class variable is created when program starts and ends with the program.
• It has same default values as instance variable.
• Static can only be accessed by using it's fully qualified name as : ClassName.VariableName
• If you are declaring class variable as public static final, then variable(constant) should be in upper case. If the static variables are not public and final the naming syntax is the same as instance and local variables.

package net.roseindia;
public class College {
        // salary variable is a private static variable
        private static int resultPercent;

        // DEPARTMENT is a constant
        public static final String BRANCH = "Computer Science";

        public static void main(String args[]) {
                resultPercent = 76;
                System.out.println(BRANCH + " Result %:" + resultPercent);
        }
}

package com.devmanuals;
class VariableDemo {
        static int num;
        static int num1;
}
public class StaticVariableDemo1 {
public static void main(String[] args) {
        VariableDemo.num = 22;
        VariableDemo.num1 = 12;
        System.out.println("Value of first static/class variable : "
                        + VariableDemo.num);
        System.out.println("Value of second static/class variable : "
                        + VariableDemo.num1);
        }
}

package com.devmanuals;
class DemoStatic {
        static int num1 = 0; // static/class variable
        int num = 0; // non-static/instance variable
        public int getNum1() {
                return num1;
        }
        public void setNum1(int num1) {
                DemoStatic.num1 = num1;
        }
        public int getNum() {
                return num;
        }
        public void setNum(int num) {
                this.num = num;
        }
}
class SameCopyDemo{
        public static void main(String[] arg) {
                DemoStatic obDemoStatic = new DemoStatic();
                DemoStatic obDemoStatic2 = new DemoStatic();

                obDemoStatic.setNum1(2);
                obDemoStatic2.setNum1(3);
                // Each object has same copy of static variable.
                System.out.println("Static variable value for first object : "
                                + obDemoStatic.num1);
                System.out.println("Static variable value for second object : "
                                + obDemoStatic2.num1);

                obDemoStatic.setNum(9);
                obDemoStatic2.setNum(10);
                
                // Each object has separate copy of instance variable
                System.out.println("Instance variable value for first object : "
                                + obDemoStatic.getNum());
                System.out.println("Instance variable value for second object : "
                                + obDemoStatic2.getNum());
        }
}

package com.devmanuals;
class StaticDemo {
        static String name;
public static void staticVariable() {
        name = name + " " + "Singh";
        System.out.println("Value of static variable after method calling : "
                + name);
        }
}
public class InitializeByMethod {
public static void main(String[] args) {
        System.out.println("Initial value of static variable : "
                        + StaticDemo.name);
        StaticDemo.name = "Bharat";
        System.out.println("Value of static variable after initialization : "
                        + StaticDemo.name);
        StaticDemo.staticVariable();
        }
}

package com.devmanuals;
class LocalDemo {
        public void showVariable() {
                int num = 22;
                System.out.println("Value of local variable : " + num);
        }
}
public class LocalVariables {

        public static void main(String[] args) {
                LocalDemo obLocalDemo = new LocalDemo();
                obLocalDemo.showVariable();
        }
}

package com.devmanuals;
class InitializeDemo {
        public void sum() {
                int num = 6;
                int num1 = 5;
                System.out.println("Sum of two number : " + (num + num1));
        }
        public void show() {
                try {
                        String name;
                        name = name + " ";
                        System.out.println();
                } catch (Exception e) {
                        System.out.println(e.getMessage());
                }
        }
}
public class LocalVariableInitialization {

        public static void main(String[] args) {
                InitializeDemo obInitializeDemo = new InitializeDemo();
                obInitializeDemo.sum();
                obInitializeDemo.show();
        }
}

package com.devmanuals;
class InstanceDemo {
        int num = 10;
        int num1 = 20;
        public void sum() {
        System.out.println("Sum of two instance variable : " + (num + num1));
        }
        public void division() {
        System.out.println("Division of two instance variable : "
                + (num1 / num));
        }
}
public class InstanceVariable {
public static void main(String[] args) {
        InstanceDemo obDemo = new InstanceDemo();
        obDemo.sum();
        obDemo.division();
        }
}

package com.devmanuals;
public class PublicModifiers {
        public static String name = "Bharat Singh";

        public static void main(String[] arg) {
                System.out.println("Use of public modifierds within class.");
                System.out.println("Public string name : " + name);
        }
}

package com.devmanuals;
class SuperDemo {
        public String firstName = "Bharat";
}
public class PublicInSuperClass {
        public static void main(String[] args) {
                String lastName = "Singh";
                SuperDemo obSuperDemo = new SuperDemo();
                System.out.println("Value of super class variables : "
                                + obSuperDemo.firstName);
                obSuperDemo.firstName = obSuperDemo.firstName + " " + lastName;
                System.out.println("Full name : " + obSuperDemo.firstName);     
        }
}

package devmanuals.com;
public class Firstclass {
        public String firstName = "Bharat";
}

package devmanuals.com;
public class SecondClass  {

                public static void main(String[] args) {
                Firstclass obDemo=new Firstclass();
                System.out
                        .println("Accessibility of public variable with in package : ");
                System.out
                        .println("Access value of first name from FirstClass : "
                                        + obDemo.firstName);
                }
        }

public class Main {
   public static void main(String args[]){
      int a= 10;
      System.out.println("The Changing value of 'a' during execution :");
      while( a < 20 ){
      System.out.print("a : " + a );
      a++;
      System.out.print("\n");
      }
   }
}

do
{
   //body of loop
}while(condition);

public class Main {
   public static void main(String args[]){
      int a= 3;
      System.out.println("The Changing value of 'a' during execution :")
      do{
         System.out.print(" a : " + a );
         a++;
         System.out.print("\n");
      }while( a < 10 );
   }
}

for(initialization; Condition; iteration)
{
   //body
}

for(type itr-var: collection)
{
   //body
}

public static void main(String args[]){
int a = 30;
if( a < 32 ){
System.out.print("It is inside if control statement");
}}
}

public class IfElse {
   public static void main(String args[]){
      int x = 5;

      if( x < 3 ){
         System.out.print("Inside if statement");
      }else{
         System.out.print("Inside else statement");
      }
   }
}

public class NestedIf {
public static void main(String args[]){
int a = 3;
int b = 30;
if( a == 3 ){
if( b == 30 ){
System.out.print("a = 3 and b = 30");
}
}
}

public class IfElseIf {
   public static void main(String args[]){
      int x = 30;

      if( x == 10 ){
         System.out.print("Value of X is 10");
      }else if( x == 20 ){
         System.out.print("Value of X is 20");
      }else if( x == 30 ){
         System.out.print("Value of X is 30");
      }else{
         System.out.print("else statement");
      }
   }
}

switch(expression){
    case value :
       //Statements
       break; //optional
    case value :
       //Statements
       break; //optional
    //You can have any number of case statements.
    default : //Optional
       //Statements
}

package corejava;
public class Switch {
private static final char c='A';
public static void main(String args[]){

switch(c)
{
case 'A' :
System.out.println("Excellent!"); break;
case 'B' :
case 'C' :
System.out.println("Well done");
break;
case 'D' :
System.out.println("You passed");
case 'F' :
System.out.println("Better try again");
break;
default :
System.out.println("Invalid grade");
}
System.out.println("Your grade is " + c);
}
}

Numbers in Java

public class boxing{
   public static void main(String args[]){
      Integer a = 3; // boxes int to an Integer object
      a =  a + 30;   // unboxes the Integer to a int
      System.out.println(x); 
   }
}

Characters in Java

char ch = 'a';
// Unicode for uppercase Greek omega character
char uniChar = '\u039A'; 
// an array of chars
char[] charArray ={ 'a', 'b', 'c', 'd', 'e' }; 

Character ch = new Character('x');

// Here following primitive char 'a' is boxed into the Character object ch
Character ch = 'a';
// Here primitive 'x' is boxed for method test,return is unboxed to char 'c'
char c = test('x');