Primitive Data Types, Variables, Constants, Operators & Expressions

1. Data Types in Java

Java is a statically and strongly typed language, which means every variable must have its data type declared before it is used, and the compiler strictly checks type compatibility.

Java data types are divided into two categories:

1. Primitive Data Types (8 built-in types): Store simple raw values directly in memory (byte, short, int, long, float, double, char, boolean).
2. Non-Primitive / Reference Data Types: Store memory references (addresses) to objects in the Heap (String, Arrays, Classes, Interfaces).

2. The 8 Primitive Data Types in Detail

Unlike C/C++, the size of primitive data types in Java is fixed across all operating systems and hardware architectures.

Why does char take 2 Bytes in Java (instead of 1 Byte like C/C++)? C/C++ uses the ASCII character set (which only needs 1 byte for 256 English characters). Java uses the Unicode character set (16-bit), which takes 2 bytes so it can represent characters from all world languages (Hindi, Japanese, Arabic, English, etc.).

3. Variables and Constants in Java

A. Variables

A variable is a named memory location whose value can change during program execution.

• Syntax: dataType variableName = value; (e.g., int marks = 85;)

There are 3 types of variables in Java based on their scope and lifetime:

B. Constants (final Keyword)

A constant is a variable whose value is fixed and cannot be modified once assigned. In Java, constants are created using the final keyword (and by convention, written in UPPER_SNAKE_CASE).

final double PI = 3.14159;
final int MAX_MARKS = 100;
// MAX_MARKS = 120; // Compile-time Error: cannot assign a value to final variable

4. Type Conversion and Type Casting

Converting a value of one primitive data type into another is done in two ways:

1. Implicit Type Conversion (Widening / Automatic): Happens automatically when converting a smaller data type into a larger data type (no data loss).
   • Order: byte → short → int → long → float → double

   int num = 500;
   double d = num; // Automatic widening: 500 becomes 500.0

2. Explicit Type Casting (Narrowing): Must be done manually by the programmer using (targetType) when converting a larger data type into a smaller data type (may lose fractional part or overflow).

   double price = 99.75;
   int roundedPrice = (int) price; // Explicit narrowing: becomes 99 (.75 truncated)

5. Operators and Expressions in Java

An operator is a symbol that performs a specific operation on one, two, or three operands. An expression is a valid combination of variables, constants, and operators that evaluates to a single value (e.g., int total = (marks1 + marks2) * 2;).

Summary of All 8 Categories of Java Operators

Example Program Demonstrating Variables, Constants, and Operators

public class OperatorsDemo {
    static String university = "DAVV Indore"; // Static variable

    public static void main(String[] args) {
        final int PASS_MARKS = 40; // Constant
        int theory = 55;           // Local variable
        int practical = 28;

        int total = theory + practical; // Arithmetic expression
        double percentage = (double) total; // Explicit type casting

        // Relational, Logical & Ternary Operator
        boolean isEligible = (theory >= 25) && (practical >= 15);
        String result = (total >= PASS_MARKS && isEligible) ? "PASSED" : "FAILED";

        System.out.println("University : " + university);
        System.out.println("Total Marks: " + total + " (" + percentage + "%)");
        System.out.println("Final Status: " + result);
    }
}

💡 Exam Preparation Tips for DAVV BCA

• Remember the Unsigned Right Shift operator (>>>) and the instanceof operator—they exist in Java and are frequently asked in 2-mark objective/viva questions.
• Never write that boolean takes 1 byte in Java; its logical size is 1 bit and it only accepts true or false (unlike C++, if(1) is a compile error in Java!).