// FORM 1: Declare and initialise in one line (most common)
int age = 20;
double gpa = 3.75;
String name = "Ahmed";
boolean passed = true;

// FORM 2: Declare first, assign later
int marks;           // declared — memory reserved, not yet assigned
marks = 95;          // now assigned
System.out.println(marks);  // OK: 95

// FORM 3: Multiple variables of the same type
int x = 5, y = 10, z = 15;

// FORM 4: Update (reassign) an existing variable
int score = 50;
score = 75;     // old value 50 is gone, replaced with 75
score = score + 10;  // score is now 85

// byte: perfect for small values (e.g., age, percentage)
byte age = 20;
byte max = 127;   // maximum byte value
// byte overflow — what happens if you go beyond 127?
byte b = 127;
b++;              // b becomes -128! Wraps around (overflow)

// short: rarely used directly, saves memory in large arrays
short year = 2024;

// int: the DEFAULT integer type in Java — use this for most cases
int students = 500;
int maxInt = Integer.MAX_VALUE;   // 2,147,483,647
int minInt = Integer.MIN_VALUE;   // -2,147,483,648

// long: for values beyond int range — MUST add L suffix
long population = 7_800_000_000L;  // world population
long bytes = 9_223_372_036_854_775_807L;  // Long.MAX_VALUE
// Note: underscores _ in literals (Java 7+) for readability — ignored by compiler
int million = 1_000_000;  // same as 1000000

// double is DEFAULT for decimal literals — use it for most cases
double pi = 3.14159265358979;
double price = 99.99;
double temp = -273.15;

// float needs 'f' or 'F' suffix — otherwise ERROR
float f1 = 3.14f;    // ✓ correct
float f2 = 3.14;     // ✗ ERROR: "possible lossy conversion from double to float"
float f3 = (float) 3.14;  // ✓ explicit cast also works

// Precision comparison:
float  precision = 1.0f / 3.0f;
double precDouble = 1.0 / 3.0;
System.out.println(precision);   // 0.33333334  (7 digits, then error)
System.out.println(precDouble);  // 0.3333333333333333  (15 digits)

// Special double values:
double inf = 1.0 / 0.0;     // Infinity (no exception! division by zero for doubles)
double nan = 0.0 / 0.0;    // NaN (Not a Number)
System.out.println(inf);     // Infinity
System.out.println(nan);     // NaN

// char stores ONE character — ALWAYS single quotes
char grade = 'A';
char digit = '7';    // the CHARACTER '7', not the number 7
char space = ' ';
char newline = '\n';  // escape sequence inside char

// char uses UNICODE — stores a 16-bit number internally
char c = 'A';
System.out.println((int) c);   // prints 65 (Unicode value of 'A')
System.out.println((char) 65); // prints 'A'

// TRICKY: char arithmetic (char + int = int!)
char ch = 'A';
System.out.println(ch + 1);     // prints 66 (int, not 'B'!)
System.out.println((char)(ch + 1)); // prints 'B' (cast back to char)

// Common Unicode values (memorise for exams):
// 'A' = 65, 'Z' = 90
// 'a' = 97, 'z' = 122
// '0' = 48, '9' = 57
// ' ' = 32 (space)

// boolean stores ONLY true or false — no 0/1, no "yes"/"no"
boolean isAdult = true;
boolean hasPassed = false;

// Most common use: storing the result of a comparison
int score = 75;
boolean passed = (score >= 50);       // true
boolean distinction = (score >= 90); // false
boolean isEven = (score % 2 == 0);   // false (75 is odd)

System.out.println(passed);        // true
System.out.println(distinction);   // false

// TRAP: cannot assign 0 or 1 like C/C++
boolean b = 1;  // ❌ COMPILE ERROR in Java! (works in C/C++ not Java)
boolean b = true; // ✓ correct

// INTEGER LITERALS
int  decimal = 255;            // decimal (base 10) — default
int  octal   = 0377;           // octal  (base 8)  — starts with 0
int  hex     = 0xFF;           // hex    (base 16) — starts with 0x
int  binary  = 0b11111111;     // binary (base 2)  — starts with 0b (Java 7+)
// All four represent the value 255!

long big = 9_000_000_000L;     // L suffix = long literal

// FLOATING-POINT LITERALS
double d = 3.14;               // double by default
double sci = 1.5e10;           // scientific: 1.5 × 10¹⁰
float  f = 3.14f;              // f or F suffix = float literal
double d2 = 3.14d;             // d suffix optional for double

// CHARACTER LITERALS
char c1 = 'A';                  // character
char c2 = 65;                   // integer literal assigned to char (='A')
char c3 = '\u0041';             // Unicode literal (='A')

// STRING LITERALS (not primitive — but good to know)
String s = "Hello";            // String in double quotes
String empty = "";             // empty String

// BOOLEAN LITERALS
boolean t = true;
boolean f2 = false;

// ✗ Bad — violates conventions, hard to read:
int A = 20;          // single letter (meaningless)
double MyGPA = 3.5;   // PascalCase for variable (wrong)
int total_marks = 90; // snake_case (Python style, not Java)

// ✓ Good — follows Java conventions:
int age = 20;
double myGpa = 3.5;
int totalMarks = 90;
final double PI = 3.14159;    // constant — ALL_CAPS
final int MAX_STUDENTS = 100; // constant — ALL_CAPS

public class ScopeDemo {

    static int classVar = 100;  // class-level: accessible everywhere in class

    public static void main(String[] args) {
        int x = 10;  // local to main — only exists inside main

        {   // inner block
            int y = 20;  // local to this inner block
            System.out.println(x);         // ✓ x is in scope
            System.out.println(y);         // ✓ y is in scope
            System.out.println(classVar);  // ✓ class variable in scope
        }   // y goes out of scope here — DESTROYED

        System.out.println(x);        // ✓ still in scope
        // System.out.println(y);     // ❌ COMPILE ERROR: y is out of scope
    }

    static void otherMethod() {
        // System.out.println(x);     // ❌ x from main is not accessible here
        System.out.println(classVar); // ✓ class variable accessible
    }
}

int    i = 100;
long   l = i;        // int → long: automatic, safe. l = 100L
float  f = l;        // long → float: automatic. f = 100.0f
double d = f;        // float → double: automatic. d = 100.0

int x = 50;
double result = x + 3.14;  // int x is automatically widened to double
// result = 53.14

char ch = 'A';
int code = ch;  // char → int: automatic. code = 65 (Unicode of 'A')
System.out.println(code);  // 65

// double → int: decimal part TRUNCATED (not rounded!)
double pi = 3.99999;
int approx = (int) pi;    // approx = 3 (not 4! decimal just dropped)

double d = 9.7;
int i = (int) d;          // i = 9 (NOT 10 — truncated, not rounded)

// long → int: value may be completely wrong if too large
long big = 9_999_999_999L;
int small = (int) big;    // small = 1410065407 (garbage! overflow)

// int → byte: only keeps last 8 bits
int n = 130;
byte b = (byte) n;        // b = -126 (overflow wraps around)

// int → char:
int code = 65;
char ch = (char) code;    // ch = 'A'

// WITHOUT CAST — compile error:
double x = 3.14;
int y = x;   // ❌ ERROR: possible lossy conversion from double to int
int y = (int) x;  // ✓ explicit cast — y = 3

// String → int
String s = "42";
int n = Integer.parseInt(s);       // n = 42

// String → double
String d = "3.14";
double pi = Double.parseDouble(d);  // pi = 3.14

// String → long
long l = Long.parseLong("9999999999");

// int → String (three ways)
int x = 100;
String way1 = String.valueOf(x);   // "100" — preferred
String way2 = Integer.toString(x); // "100"
String way3 = "" + x;             // "100" — concatenation trick

// DANGEROUS: parsing non-numeric string
int bad = Integer.parseInt("hello");  // ❌ NumberFormatException at runtime!

// Declare and initialise final (constant) variables
final double PI = 3.14159265358979;
final int MAX_STUDENTS = 100;
final String UNIVERSITY_NAME = "Abu Dhabi University";

// Attempting to reassign — compile error:
PI = 3.0;  // ❌ ERROR: cannot assign a value to final variable PI

// final can be declared first, assigned once later:
final int x;
x = 42;     // ✓ first assignment allowed
x = 43;     // ❌ ERROR: second assignment not allowed

// Why use final?
// 1. Prevents accidental modification of important values
// 2. Communicates intent: "this value never changes"
// 3. Can enable compiler optimisations

// Before Java 10: explicit type required
int age = 20;
double gpa = 3.75;
String name = "Ahmed";

// Java 10+: var — compiler infers the type
var age2 = 20;          // inferred as int
var gpa2 = 3.75;        // inferred as double
var name2 = "Ahmed";   // inferred as String

// var is still STATICALLY typed — type is fixed once assigned
var x = 10;    // x is int
x = 20;        // ✓ still int, fine
x = "hello";  // ❌ ERROR: x is int, cannot assign String

// var CANNOT be used without initialisation:
var y;  // ❌ ERROR: cannot use 'var' on variable without initialiser

// var is ONLY for local variables — not for fields or parameters