Java Data Types Explained — Primitives, Objects and Real-World Usage

public class TwoFamilies {
    public static void main(String[] args) {

        // --- PRIMITIVE: the value lives right here in the variable ---
        int playerScore = 4200;          // 'playerScore' IS the number 4200
        boolean isGameOver = false;      // 'isGameOver' IS the value false

        // --- REFERENCE TYPE: the variable holds a pointer to the object ---
        String playerName = "Maya";      // 'playerName' points to an object
                                         // somewhere in memory that holds "Maya"

        // Printing both works the same way on the surface...
        System.out.println("Player : " + playerName);
        System.out.println("Score  : " + playerScore);
        System.out.println("Done?  : " + isGameOver);

        // ...but copy behaviour is VERY different (more on this later)
        int backupScore = playerScore;   // copies the NUMBER itself
        String backupName = playerName;  // copies the POINTER, not the text

        System.out.println("\n-- Backup values --");
        System.out.println("Backup score : " + backupScore);
        System.out.println("Backup name  : " + backupName);
    }
}

public class AllEightPrimitives {
    public static void main(String[] args) {

        // --- INTEGER FAMILY ---
        byte sensorReading = 120;           // raw sensor value, fits in -128 to 127
        short yearBuilt = 1995;             // a year — fits in short's range
        int dailyStepCount = 12_847;        // underscores improve readability (Java 7+)
        long worldPopulation = 8_100_000_000L; // MUST add L suffix for long literals

        // --- DECIMAL FAMILY ---
        float productWeight = 2.75f;        // MUST add f suffix for float literals
        double accountBalance = 98_432.57;  // double is the default decimal type

        // --- CHARACTER ---
        char bloodType = 'O';               // single quotes for char (NOT double quotes)

        // --- BOOLEAN ---
        boolean isPremiumMember = true;     // only ever true or false

        // Print everything with labels
        System.out.println("Sensor reading   : " + sensorReading);
        System.out.println("Year built       : " + yearBuilt);
        System.out.println("Daily steps      : " + dailyStepCount);
        System.out.println("World population : " + worldPopulation);
        System.out.println("Product weight   : " + productWeight + " kg");
        System.out.println("Account balance  : $" + accountBalance);
        System.out.println("Blood type       : " + bloodType);
        System.out.println("Premium member?  : " + isPremiumMember);

        // Show data type sizes in memory (in bits)
        System.out.println("\n--- Memory sizes ---");
        System.out.println("byte    = 8 bits,  max = " + Byte.MAX_VALUE);
        System.out.println("short   = 16 bits, max = " + Short.MAX_VALUE);
        System.out.println("int     = 32 bits, max = " + Integer.MAX_VALUE);
        System.out.println("long    = 64 bits, max = " + Long.MAX_VALUE);
        System.out.println("float   = 32 bits, max = " + Float.MAX_VALUE);
        System.out.println("double  = 64 bits, max = " + Double.MAX_VALUE);
    }
}

public class TypeCastingDemo {
    public static void main(String[] args) {

        // ===== WIDENING CASTING (automatic — no syntax needed) =====
        int distanceInMetres = 1500;
        long distanceForDatabase = distanceInMetres;  // int → long, happens silently
        double distanceInKm = distanceInMetres / 1000.0; // int used in double expression

        System.out.println("Distance (int)    : " + distanceInMetres + " m");
        System.out.println("Distance (long)   : " + distanceForDatabase + " m");
        System.out.println("Distance (double) : " + distanceInKm + " km");

        // ===== NARROWING CASTING (explicit — YOU must write the cast) =====
        double preciseTemperature = 36.87;
        int roundedTemperature = (int) preciseTemperature; // truncates, does NOT round
        // Note: 36.87 becomes 36, not 37 — it chops the decimal off entirely

        System.out.println("\nPrecise temp : " + preciseTemperature + " °C");
        System.out.println("Rounded temp : " + roundedTemperature + " °C  (decimal chopped!)");

        // ===== CHAR ↔ INT casting (char is secretly a number) =====
        char firstInitial = 'A';
        int unicodeValue = firstInitial;         // widening: char → int automatically
        char nextLetter = (char) (firstInitial + 1); // narrowing back to char

        System.out.println("\nChar 'A' as int  : " + unicodeValue);
        System.out.println("Next letter      : " + nextLetter);

        // ===== DANGEROUS NARROWING — overflow in action =====
        int tooBigForByte = 300;                 // byte max is 127
        byte overflowedValue = (byte) tooBigForByte; // Java wraps around silently!
        System.out.println("\n300 cast to byte : " + overflowedValue + "  <-- not 300!");
    }
}

public class StringDeepDive {
    public static void main(String[] args) {

        // --- Basic String creation ---
        String firstName = "Elena";
        String lastName  = "Vasquez";

        // String concatenation with +
        String fullName = firstName + " " + lastName;
        System.out.println("Full name : " + fullName);

        // Useful String methods
        System.out.println("Length         : " + fullName.length());      // number of chars
        System.out.println("Uppercase      : " + fullName.toUpperCase());
        System.out.println("Contains 'Van' : " + fullName.contains("Van"));
        System.out.println("Starts with E  : " + fullName.startsWith("E"));

        // ===== THE CLASSIC == vs .equals() TRAP =====
        String cityA = "Tokyo";                  // goes into String pool
        String cityB = "Tokyo";                  // reuses the SAME pool object
        String cityC = new String("Tokyo");       // forces a BRAND NEW object (not pool)

        System.out.println("\n-- Comparing Strings --");
        System.out.println("cityA == cityB      : " + (cityA == cityB));      // true  (same pool object)
        System.out.println("cityA == cityC      : " + (cityA == cityC));      // false (different objects!)
        System.out.println("cityA.equals(cityB) : " + cityA.equals(cityB));  // true
        System.out.println("cityA.equals(cityC) : " + cityA.equals(cityC));  // true  <-- USE THIS

        // ===== IMMUTABILITY in action =====
        String username = "dev_learner";
        username.toUpperCase();            // this does NOTHING to 'username'
        System.out.println("\nAfter toUpperCase() : " + username);  // still lowercase!

        username = username.toUpperCase(); // you MUST capture the new String
        System.out.println("After capturing     : " + username);

        // ===== StringBuilder for efficient concatenation =====
        StringBuilder csvRow = new StringBuilder();
        String[] columns = {"John", "32", "Engineer", "Berlin"};
        for (String column : columns) {
            csvRow.append(column).append(",");  // mutates in place — efficient
        }
        System.out.println("\nCSV row : " + csvRow);
    }
}