Java Basics

Data Types

Every variable in Java has a data type. Data types specify the different sizes and values that can be stored in the variable. There are two types of data types in Java:

1) Primitive data types:

The primitive data types include Boolean, char, byte, short, int, long, float and double.

2) Non-primitive data types:

The non-primitive data types include Classes, Interfaces, and Arrays.

Data Type Default Value Default Size
boolean false 1 bit
char '\u0000' 2 byte
short false 1 byte
int 0 2 byte
long 0 4 byte
boolean 0L 8 byte
float 0.0f 4 byte
double 0.0d 8 byte
1) Primitive data types: <
1) Boolean
            
  • Boolean data type represents one bit of information.
    •         
  • There are only two possible values: true and false.
    •         
  • This data type is used for simple flags that track true/false conditions.
    •         
  • Default value is false.

    •         Example:

            boolean isStatusOnline = true

            System.out.println(isStatusOnline);

2) Char
            
  • char data type is a single 16-bit Unicode character.
    •         
  • Minimum value is '\u0000' (or 0).
    •         
  • Maximum value is '\uffff' (or 65,535 inclusive).
    •         
  • Char data type is used to store any character.

    •         Example:

            char employeeGrade = 'A';

            System.out.println(employeeGrade);

3) Byte
            
  • Byte data type is an 8-bit signed two's complement integer.
    •         
  • Minimum value is -128 (-2^7).
    •         
  • Maximum value is 127 (inclusive)(2^7 -1).
    •         
  • Default value is 0.
    •         
  • Byte data type is used to save space in large arrays, mainly in place of integers, since a byte is four times smaller than an integer.

    •         Example:

            byte employeeId = 121;

            System.out.println(employeeId);

4) Short
            
  • Short data type is a 16-bit signed two's complement integer.
    •         
  • Minimum value is -32,768 (-2^15).
    •         
  • Maximum value is 32,767 (inclusive) (2^15 -1).
    •         
  • Short data type can also be used to save memory as byte data type. A short is 2 times smaller than an integer.
    •         
  • Default value is 0.

    •         Example:

            short employeeAge = 21;

            System.out.println(employeeAge);

5) Int
            
  • Int data type is a 32-bit signed two's complement integer.
    •         
  • Minimum value is - 2,147,483,648 (-2^31).
    •         
  • Maximum value is 2,147,483,647(inclusive) (2^31 -1).
    •         
  • Integer is generally used as the default data type for integral values unless there is a concern about memory.
    •         
  • The default value is 0.

    •         Example:

            int customerId = 122;

            System.out.println(customerId);

6) Long
            
  • Long data type is a 64-bit signed two's complement integer.
    •         
  • Minimum value is -9,223,372,036,854,775,808(-2^63).
    •         
  • Maximum value is 9,223,372,036,854,775,807 (inclusive)(2^63 -1).
    •         
  • This type is used when a wider range than int is needed.
    •         
  • Default value is 0L.

    •         Example:

            long customerContactNumber = 9623639693L;

            System.out.println(customerContactNumber);

7) Float
            
  • Float data type is a single-precision 32-bit IEEE 754 floating point.
    •         
  • Float is mainly used to save memory in large arrays of floating point numbers.
    •         
  • Default value is 0.0f.
    •         
  • Float data type is never used for precise values such as currency.

    •         Example:

            float productPrice = 5.75f;

            System.out.println(productPrice);

8) Double
            
  • double data type is a double-precision 64-bit IEEE 754 floating point.
    •         
  • This data type is generally used as the default data type for decimal values, generally the default choice.
    •         
  • Double data type should never be used for precise values such as currency.
    •         
  • Default value is 0.0d.

    •         Example:

            double employeeSalary = 90000.96d;

            System.out.println(employeeSalary);

2) Non-primitive data types:
Non-primitive data types are called reference types because they refer to objects.

The main difference between primitive and non-primitive data types are:

  • Primitive types are predefined (already defined) in Java. Non-primitive types are created by the programmer and is not defined by Java (except for String).

  • Non-primitive types can be used to call methods to perform certain operations, while primitive types cannot.

  • A primitive type has always a value, while non-primitive types can be null.

  • A primitive type starts with a lowercase letter, while non-primitive types starts with an uppercase letter.

  • The size of a primitive type depends on the data type, while non-primitive types have all the same size.

  • Examples of non-primitive types are Strings, Arrays, Classes, etc. i.e. Customer customer = new Customer(“JERRY”);