In Java, a data type is a classification of types of data that determine the possible values and operations that can be performed on that data.

Java has two categories of data types:

Primitive data types

These include boolean, char, byte, short, int, long, float, and double. These data types are predefined in Java and represent the most basic types of data.

Non-primitive data types 

These include arrays, classes, and interfaces. These data types are not predefined in Java and are created by the programmer.

Each data type has a specific size and range of values that it can represent. For example, the int data type is a 32-bit signed integer that can represent values in the range -2147483648 to 2147483647.

It is important to use the appropriate data type for a given value in your program, as this can affect the performance and memory usage of your program.

Here is a summary of the primitive data types in Java:

Data Type	Size (bits)	Range
boolean	1	true or false
char	16	0 to 65535
byte	8	-128 to 127
short	16	-32768 to 32767
int	32	-2147483648 to 2147483647
long	64	-9223372036854775808 to 9223372036854775807
float	32	1.4E-45 to 3.4028235E38
double	64	4.9E-324 to 1.7976931348623157E308

Here is an example of declaring and initializing variables of the primitive data types:

 

boolean flag = true;
char letter = 'A';
byte b = 100;
short s = 32000;
int i = 2000000;
long l = 4000000000L;
float f = 3.14f;
double d = 3.14159265358979323846;

 

Primitive data types

boolean

In Java, a boolean data type is a primitive data type that can have only two values: true or false. It is used to represent a binary condition, where true represents the condition being met and false represents the condition not being met.

Here is an example of declaring and initializing a boolean variable in Java:

boolean flag = true;

Boolean variables are often used in control structures, such as if statements and for loops, to control the flow of a program based on a certain condition.

For example:

if (flag) {
  System.out.println("The condition is true.");
} else {
  System.out.println("The condition is false.");
}

In this example, the message "The condition is true." will be printed if the value of the flag variable is true, and "The condition is false." will be printed if the value of the flag variable is false.

Boolean variables can also be used in expressions and can be assigned the result of a boolean operation. For example:

boolean a = true;
boolean b = false;
boolean c = a && b; // c will be assigned the value false

In this example, the variable c is assigned the value false because the AND operation (&&) is false when both operands are false.

char

In Java, the char data type is a primitive data type that represents a single character. It is a 16-bit unsigned integer that can represent any Unicode character in the range 0 to 65535.

Here is an example of declaring and initializing a char variable in Java:

char letter = 'A';

Char variables are often used to store and manipulate characters in Java programs. They can be used in expressions and can be compared to other char variables using relational operators (such as <, >, and ==).

For example:

char a = 'A';
char b = 'B';
if (a < b) {
  System.out.println("a is less than b.");
}

In this example, the message "a is less than b." will be printed because the ASCII value of the character 'A' is less than the ASCII value of the character 'B'.

Char variables can also be converted to and from other data types using type casting. For example:

char c = 'C';
int i = (int) c; // i will be assigned the value 67

In this example, the char variable c is cast to an int, and the integer value 67 (the ASCII value of the character 'C') is assigned to the int variable i.

byte

n Java, the byte data type is a primitive data type that represents a 8-bit signed integer. It can store values in the range of -128 to 127.

Here is an example of declaring and initializing a byte variable in Java:

byte b = 100;

Byte variables are often used to store small integers that are expected to take up less space in memory than int variables. They can be used in expressions and can be compared to other byte variables using relational operators (such as <, >, and ==).

For example:

byte a = 100;
byte b = 50;
if (a > b) {
  System.out.println("a is greater than b.");
}

In this example, the message "a is greater than b." will be printed because the value of variable a is greater than the value of variable b.

Byte variables can also be converted to and from other data types using type casting. For example:

byte b = 100;
int i = b; // i will be assigned the value 100

In this example, the byte variable b is automatically converted to an int and the value 100 is assigned to the int variable i.

short

In Java, the short data type is a primitive data type that represents a 16-bit signed integer. It can store values in the range of -32768 to 32767.

Here is an example of declaring and initializing a short variable in Java:

short s = 32000;

Short variables are often used to store small integers that are expected to take up less space in memory than int variables. They can be used in expressions and can be compared to other short variables using relational operators (such as <, >, and ==).

For example:

short a = 32000;
short b = 30000;
if (a > b) {
  System.out.println("a is greater than b.");
}

In this example, the message "a is greater than b." will be printed because the value of variable a is greater than the value of variable b.

Short variables can also be converted to and from other data types using type casting. For example:

short s = 32000;
long l = s; // l will be assigned the value 32000

In this example, the short variable s is automatically converted to a long and the value 32000 is assigned to the long variable l.

int

In Java, the int data type is a primitive data type that represents a 32-bit signed integer. It can store values in the range of -2147483648 to 2147483647.

Here is an example of declaring and initializing an int variable in Java:

int i = 2000000;

Int variables are the most commonly used data type for storing integers in Java programs. They can be used in expressions and can be compared to other int variables using relational operators (such as <, >, and ==).

For example:

int a = 2000000;
int b = 1000000;
if (a > b) {
  System.out.println("a is greater than b.");
}

In this example, the message "a is greater than b." will be printed because the value of variable a is greater than the value of variable b.

Int variables can also be converted to and from other data types using type casting. For example:

int i = 2000000;
long l = i; // l will be assigned the value 2000000

In this example, the int variable i is automatically converted to a long, and the value 2000000 is assigned to the long variable l.

long

In Java, the long data type is a primitive data type that represents a 64-bit signed integer. It can store values in the range -9223372036854775808 to 9223372036854775807.

Here is an example of declaring and initializing a long variable in Java:

long l = 4000000000L;

The "L" at the end of the value is used to indicate that it is a long literal. This is necessary because long values are too large to fit in the range of the int data type.

Long variables are used to store large integers that are too big to be stored in an int variable. They can be used in expressions and can be compared to other long variables using the relational operators (such as <, >, and ==).

For example:

long a = 4000000000L;
long b = 2000000000L;
if (a > b) {
  System.out.println("a is greater than b.");
}

In this example, the message "a is greater than b." will be printed because the value of variable a is greater than the value of variable b.

Long variables can also be converted to and from other data types using type casting. For example:

long l = 4000000000L;
float f = l; // f will be assigned the value 4000000000.0

In this example, the long variable l is automatically converted to a float and the value 4000000000.0 is assigned to the float variable f.

float

In Java, the float data type is a primitive data type that represents a single-precision 32-bit floating-point number. It can store values in the range of 1.4E-45 to 3.4028235E38.

Here is an example of declaring and initializing a float variable in Java:

float f = 3.14f;

The "f" at the end of the value is used to indicate that it is a float literal. This is necessary because the default data type for decimal values is double, which is a larger data type than float.

Float variables are used to store floating-point numbers in Java programs. They can be used in expressions and can be compared to other float variables using relational operators (such as <, >, and ==).

For example

float a = 3.14f;
float b = 2.72f;
if (a > b) {
  System.out.println("a is greater than b.");
}

In this example, the message "a is greater than b." will be printed because the value of variable a is greater than the value of variable b.

Float variables can also be converted to and from other data types using type casting. For example:

float f = 3.14f;
double d = f; // d will be assigned the value 3.14

In this example, the float variable f is automatically converted to a double and the value 3.14 is assigned to the double variable d.

double

In Java, the double data type is a primitive data type that represents a double-precision 64-bit floating-point number. It can store values in the range 4.9E-324 to 1.7976931348623157E308.

Here is an example of declaring and initializing a double variable in Java:

double d = 3.14159265358979323846;

Double variables are used to store floating-point numbers in Java programs. They are often used when a greater level of precision is required than what is provided by the float data type. They can be used in expressions and can be compared to other double variables using relational operators (such as <, >, and ==).

For example:

double a = 3.14159265358979323846;
double b = 2.71828182845904523536;
if (a > b) {
  System.out.println("a is greater than b.");
}

In this example, the message "a is greater than b." will be printed because the value of variable a is greater than the value of variable b.

Double variables can also be converted to and from other data types using type casting. For example:

double d = 3.14159265358979323846;
float f = (float) d; // f will be assigned the value 3.1415927

In this example, the double variable d is cast to a float and the value 3.1415927 is assigned to the float variable f. Note that some precision may be lost in this conversion due to the smaller size of the float data type.

Non-primitive data types

In Java, non-primitive data types are also known as reference types because they refer to objects. Non-primitive data types are created by the programmer and are not defined by Java. Some examples of non-primitive data types in Java are:

Arrays

An array is a collection of elements of the same data type, used to store multiple values in a single variable. It is a fixed size, meaning that you cannot change the size of an array once it is created.

To declare an array in Java, you need to specify the type of elements that the array will hold, followed by the name of the array, and then the size of the array in square brackets.

For example:

int[] numbers = new int[5];

This creates an array of integers with a size of 5. The elements of the array are not initialized and will have default values.

You can also initialize an array with values at the time of creation.

For example:

int[] numbers = {1, 2, 3, 4, 5};

This creates an array of integers with a size of 5 and initializes the elements with the values 1, 2, 3, 4, and 5.

To access an element of an array, you can use the index of the element in square brackets.

For example:

int firstElement = numbers[0];

This will assign the value of the first element of the array (which is 1) to the variable first element.

Arrays are useful when you need to store a large number of elements of the same data type and you want to be able to access them quickly.

Classes

A class is a blueprint for creating objects. It defines the variables and methods that objects of the class will have.

Interfaces

An interface is a set of related methods with empty bodies. A class can implement an interface, which means it agrees to implement all the methods defined in the interface.

String

A string is a sequence of characters. In Java, strings are treated as objects.

Enumerations

An enumeration is a special type of data type that consists of a set of predefined constants.

Object

The Object class is the root of the class hierarchy. Every class in Java is a subclass of the Object class.