Variable Declaration Syntax:

// Syntax: datatype variablename;
int age;
double salary;
boolean isStudent;
char grade;

// Multiple variables of same type
int x, y, z;
double length, width, height;

Variable Initialization:

// Declaration and initialization
int age = 25;
double salary = 50000.50;
boolean isStudent = true;
char grade = 'A';

// Initialize after declaration
int marks;
marks = 95;

Variable Naming Rules:

• Must start with letter, underscore, or $
• Cannot start with digit
• Case-sensitive (age ≠ Age)
• Cannot use reserved keywords
• No spaces allowed

Final Variables (Constants):

// final keyword makes variable constant
final int MAX_STUDENTS = 100;
final double PI = 3.14159;
final String COLLEGE_NAME = "GTU";

// Must be initialized when declared
final int MIN_AGE = 18;

// Cannot change value later
// MAX_STUDENTS = 200; // ❌ Compilation error

Static Final Variables:

public class MathConstants {
    public static final double PI = 3.14159;
    public static final int MAX_VALUE = 2147483647;
    public static final String VERSION = "1.0";
    
    public static void main(String[] args) {
        System.out.println("PI = " + PI);
        System.out.println("MAX = " + MAX_VALUE);
    }
}

Implicit Type Conversion (Widening):

// Automatic conversion (smaller to larger)
byte b = 42;
short s = b;    // byte to short
int i = s;      // short to int
long l = i;     // int to long
float f = l;    // long to float
double d = f;   // float to double

// Widening conversion hierarchy:
// byte → short → int → long → float → double

Explicit Type Casting (Narrowing):

// Manual conversion (larger to smaller)
double d = 9.78;
float f = (float) d;    // double to float
long l = (long) f;      // float to long
int i = (int) l;        // long to int
short s = (short) i;    // int to short
byte b = (byte) s;      // short to byte

// Example with potential data loss
int largeNum = 130;
byte smallNum = (byte) largeNum;  // Data loss!
System.out.println(smallNum);     // Output: -126

Types of Variables:

public class ScopeExample {
    // 1. Instance variables (class level)
    private int instanceVar = 10;
    static int staticVar = 20;  // Class variable
    
    public void method1() {
        // 2. Local variables (method level)
        int localVar = 30;
        
        // 3. Block variables
        {
            int blockVar = 40;
            System.out.println(blockVar);  // ✅ Valid
        }
        // System.out.println(blockVar);  // ❌ Error
        
        for (int i = 0; i < 5; i++) {  // Loop variable
            System.out.println(i);
        }
        // System.out.println(i);  // ❌ Error
    }
}

Variable Scope Rules:

One-Dimensional Arrays:

// Array declaration and creation
int[] numbers = new int[5];
double[] prices = new double[10];

// Declaration with initialization
int[] marks = {85, 90, 78, 92, 88};
String[] names = {"John", "Alice", "Bob"};

// Accessing array elements
numbers[0] = 10;    // First element
numbers[1] = 20;    // Second element
int first = numbers[0];

// Array length
int size = numbers.length;  // 5

Array Properties:

Array Default Values:

• int[], byte[], short[], long[]: 0
• float[], double[]: 0.0
• boolean[]: false
• char[]: '\u0000'
• Object arrays: null

Student Grade Calculator:

public class GradeCalculator {
    public static void main(String[] args) {
        // Student information
        String studentName = "John Doe";
        int rollNumber = 101;
        
        // Subject marks
        int mathMarks = 85;
        int physicsMarks = 90;
        int chemistryMarks = 78;
        int englishMarks = 92;
        int computerMarks = 88;
        
        // Calculate total and percentage
        int totalMarks = mathMarks + physicsMarks + 
                        chemistryMarks + englishMarks + 
                        computerMarks;
        double percentage = (double) totalMarks / 5;
        
        // Determine grade
        char grade;
        if (percentage >= 90) grade = 'A';
        else if (percentage >= 80) grade = 'B';
        else if (percentage >= 70) grade = 'C';
        else if (percentage >= 60) grade = 'D';
        else grade = 'F';
        
        // Display results
        System.out.println("Student: " + studentName);
        System.out.println("Roll No: " + rollNumber);
        System.out.println("Total Marks: " + totalMarks);
        System.out.println("Percentage: " + percentage + "%");
        System.out.println("Grade: " + grade);
    }
}

Temperature Converter:

public class TemperatureConverter {
    // Constants
    public static final double CELSIUS_TO_FAHRENHEIT_RATIO = 9.0/5.0;
    public static final int FAHRENHEIT_OFFSET = 32;
    public static final double CELSIUS_TO_KELVIN_OFFSET = 273.15;
    
    public static void main(String[] args) {
        // Input temperature in Celsius
        double celsius = 25.5;
        
        // Convert to Fahrenheit
        double fahrenheit = (celsius * CELSIUS_TO_FAHRENHEIT_RATIO) + FAHRENHEIT_OFFSET;
        
        // Convert to Kelvin
        double kelvin = celsius + CELSIUS_TO_KELVIN_OFFSET;
        
        // Display conversions
        System.out.println("Temperature Conversion:");
        System.out.println("Celsius: " + celsius + "°C");
        System.out.println("Fahrenheit: " + fahrenheit + "°F");
        System.out.println("Kelvin: " + kelvin + "K");
        
        // Demonstrate type casting
        int celsiusInt = (int) celsius;  // Explicit casting
        System.out.println("\nCelsius as integer: " + celsiusInt + "°C");
        
        // Character operations
        char tempSymbol = '°';
        int symbolCode = tempSymbol;     // Implicit casting
        System.out.println("Degree symbol ASCII: " + symbolCode);
    }
}

Key Concepts Covered:

• 8 primitive data types with ranges
• Variable declaration and initialization
• Variable naming conventions and rules
• Constants and final variables
• Type conversion (implicit and explicit)
• Variable scope and lifetime
• Introduction to arrays

Learning Outcomes Achieved:

• ✅ Master all primitive data types
• ✅ Understand memory allocation
• ✅ Apply proper variable naming
• ✅ Handle type conversions safely
• ✅ Use constants effectively
• ✅ Understand variable scope rules
• ✅ Implement practical programs