Introduction

This document provides a comprehensive overview of data types, variables, and operators in Java. Understanding these concepts is crucial for writing effective and efficient Java programs.

Data Types

In Java, a data type specifies the type of value a variable can hold. Java is a statically typed language, meaning that the data type of a variable must be declared before it can be used.

Primitive Data Types

Java offers several primitive data types, which are the building blocks of more complex data structures. These are:

• int: Represents integer numbers (whole numbers) without fractional parts.

  Size: 32 bits (4 bytes)

  Range: -2,147,483,648 to 2,147,483,647

  Example:

  int age = 30;

• float: Represents single-precision floating-point numbers (numbers with fractional parts).

  Size: 32 bits (4 bytes)

  Example:

  float price = 9.99f; // Note the 'f' suffix to indicate a float literal

• double: Represents double-precision floating-point numbers. Generally preferred over float for higher precision.

  Size: 64 bits (8 bytes)

  Example:

  double pi = 3.14159265359;

• boolean: Represents a boolean value, which can be either true or false.

  Size: JVM-dependent, but conceptually 1 bit

  Example:

  boolean isJavaFun = true;

• char: Represents a single Unicode character.

  Size: 16 bits (2 bytes)

  Range: Unicode characters (covers most writing systems)

  Example:

  char grade = 'A';

• byte: Represents a signed 8-bit integer.

  Size: 8 bits (1 byte)

  Range: -128 to 127

  Example:

  byte age = 120;

• short: Represents a signed 16-bit integer.

  Size: 16 bits (2 bytes)

  Range: -32,768 to 32,767

  Example:

  short temperature = -20;

• long: Represents a signed 64-bit integer. Useful for larger integer values than `int` can hold.

  Size: 64 bits (8 bytes)

  Range: -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807

  Example:

  long population = 7000000000L; // Note the 'L' suffix to indicate a long literal

Non-Primitive Data Types (Reference Types)

In addition to primitive data types, Java also has non-primitive data types, which are also called reference types. These include:

• String: Represents a sequence of characters. While not strictly primitive, it's a very commonly used type.
• Arrays: Collections of elements of the same data type.
• Classes: Blueprints for creating objects.
• Interfaces: Contracts that classes can implement.

Reference types store the *address* (reference) of the object in memory, rather than the value itself. This is a crucial distinction from primitive types.

Variables

A variable is a named storage location in memory that can hold a value. In Java, you must declare a variable before you can use it. Variable declarations specify the data type and name of the variable.

Variable Declaration and Initialization

Declaration: The declaration of a variable specifies its data type and name.

int age; // Declares an integer variable named 'age'

Initialization: Initialization assigns an initial value to a variable.

age = 30; // Initializes the 'age' variable with the value 30

You can declare and initialize a variable in a single statement:

int age = 30; // Declares and initializes 'age' in one line

Variable Naming Conventions:

• Variable names should start with a letter, underscore (_), or dollar sign ($).
• Subsequent characters can be letters, numbers, underscores, or dollar signs.
• Variable names are case-sensitive (age and Age are different variables).
• Use descriptive names that clearly indicate the variable's purpose.
• Follow camelCase convention (e.g., firstName, calculateArea).

Variable Scope

The scope of a variable defines where in the program it can be accessed. Java has different types of scopes, including:

• Local scope: Variables declared within a method or block of code. They are only accessible within that method or block.
• Instance scope: Variables declared within a class but outside any method. They are associated with an instance (object) of the class.
• Static (Class) scope: Variables declared with the static keyword. They are associated with the class itself, not with individual instances.

Example demonstrating local scope:

public class Example {
    public static void main(String[] args) {
    int x = 10; // x is declared within the main method's scope

    if (x > 5) {
        int y = 20; // y is declared within the if block's scope
        System.out.println("x = " + x + ", y = " + y); // Accessing both x and y is valid here
    }

    System.out.println("x = " + x); // Accessing x is valid here
    // System.out.println("y = " + y); // Error: y is out of scope
}
}

Operators

Operators are symbols that perform operations on one or more operands (values or variables). Java supports a wide range of operators.

Arithmetic Operators

Arithmetic operators perform mathematical operations.

• +: Addition
• -: Subtraction
• *: Multiplication
• /: Division
• %: Modulus (remainder of division)
• ++: Increment (adds 1 to the operand) - prefix and postfix versions
• --: Decrement (subtracts 1 from the operand) - prefix and postfix versions

int a = 10;
int b = 5;
int sum = a + b; // sum is 15
int difference = a - b; // difference is 5
int product = a * b; // product is 50
int quotient = a / b; // quotient is 2
int remainder = a % b; // remainder is 0

a++; // a is now 11
b--; // b is now 4

Relational Operators

Relational operators compare two operands and return a boolean value (true or false).

• ==: Equal to
• !=: Not equal to
• >: Greater than
• <: Less than
• >=: Greater than or equal to
• <=: Less than or equal to

int x = 10;
int y = 20;
boolean isEqual = (x == y); // isEqual is false
boolean isNotEqual = (x != y); // isNotEqual is true
boolean isGreaterThan = (x > y); // isGreaterThan is false
boolean isLessThan = (x < y); // isLessThan is true
boolean isGreaterOrEqual = (x >= y); // isGreaterOrEqual is false
boolean isLessOrEqual = (x <= y); // isLessOrEqual is true

Logical Operators

Logical operators combine boolean expressions.

• &&: Logical AND (returns true if both operands are true)
• ||: Logical OR (returns true if at least one operand is true)
• !: Logical NOT (reverses the boolean value of the operand)

boolean p = true;
boolean q = false;
boolean andResult = (p && q); // andResult is false
boolean orResult = (p || q); // orResult is true
boolean notP = !p; // notP is false

Assignment Operators

Assignment operators assign values to variables. The most basic assignment operator is =.

• =: Assignment
• +=: Add and assign (x += y is equivalent to x = x + y)
• -=: Subtract and assign (x -= y is equivalent to x = x - y)
• *=: Multiply and assign (x *= y is equivalent to x = x * y)
• /=: Divide and assign (x /= y is equivalent to x = x / y)
• %=: Modulus and assign (x %= y is equivalent to x = x % y)

int num = 5;
num += 3; // num is now 8 (num = num + 3)
num -= 2; // num is now 6 (num = num - 2)
num *= 4; // num is now 24 (num = num * 4)
num /= 6; // num is now 4 (num = num / 6)
num %= 3; // num is now 1 (num = num % 3)

Bitwise Operators

Bitwise operators perform operations on the individual bits of integer operands. These are less commonly used in general application development but are important in areas like low-level programming and cryptography.

• &: Bitwise AND
• |: Bitwise OR
• ^: Bitwise XOR (exclusive OR)
• ~: Bitwise NOT (unary operator, flips all bits)
• <<: Left shift (shifts bits to the left)
• >>: Right shift (shifts bits to the right, preserving the sign)
• >>>: Unsigned right shift (shifts bits to the right, filling with zeros)

int a = 5;  // Binary: 00000101
int b = 3;  // Binary: 00000011

int andResultBitwise = a & b;   // Binary: 00000001, Decimal: 1
int orResultBitwise = a | b;    // Binary: 00000111, Decimal: 7
int xorResultBitwise = a ^ b;   // Binary: 00000110, Decimal: 6
int notAResultBitwise = ~a;    // Binary: 11111010 (depends on the integer representation), Decimal: -6 (two's complement)

int leftShift = a << 2;  // Binary: 00010100, Decimal: 20  (5 * 2^2 = 20)
int rightShift = a >> 1; // Binary: 00000010, Decimal: 2 (5 / 2 = 2, integer division)
int unsignedRightShift = -5 >>> 1;  // Different behavior than >> for negative numbers