Java Static Variables — Race Condition in Trade Counter

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

        // --- DECLARATION ONLY ---
        // We reserve a slot called 'playerAge' that will hold a whole number (int).
        // It has no value yet — we cannot READ it until we assign one.
        int playerAge;

        // --- DECLARATION + INITIALIZATION ---
        // We reserve the slot AND immediately put the value 25 inside it.
        int playerScore = 250;

        // --- ASSIGNING AFTER DECLARATION ---
        // Now we fill the slot we created earlier.
        playerAge = 25;

        // --- DECIMAL NUMBERS use 'double' ---
        // 'double' stores numbers with a decimal point (64-bit precision).
        double itemPrice = 19.99;

        // --- TRUE/FALSE values use 'boolean' ---
        // Only two possible values: true or false. Perfect for flags and conditions.
        boolean isLoggedIn = true;

        // --- SINGLE CHARACTERS use 'char' ---
        // Note the SINGLE quotes — double quotes are for Strings, not chars.
        char grade = 'A';

        // --- PRINTING the values to the console ---
        System.out.println("Player age: " + playerAge);       // prints 25
        System.out.println("Player score: " + playerScore);   // prints 250
        System.out.println("Item price: " + itemPrice);       // prints 19.99
        System.out.println("Logged in: " + isLoggedIn);       // prints true
        System.out.println("Grade: " + grade);                // prints A

        // --- CHANGING a variable's value ---
        // This is the whole point of a *variable* — it can vary.
        playerScore = 500;  // the old value 250 is gone, replaced by 500
        System.out.println("Updated score: " + playerScore);  // prints 500
    }
}

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

        // ✅ GOOD — camelCase, descriptive, instantly readable
        int numberOfStudentsEnrolled = 42;
        double annualSalaryInDollars = 75000.00;
        boolean isAccountSuspended = false;
        String customerFullName = "Maria Chen";  // String = text, not a primitive

        // ❌ BAD — compiles fine but will get you flagged in code review
        int n = 42;                  // what does 'n' mean? Nobody knows.
        double d = 75000.00;         // is this salary? a measurement? a count?
        boolean flag = false;        // a 'flag' for WHAT?
        String s = "Maria Chen";     // seriously, just... no.

        // ❌ ILLEGAL — these will cause a compile error
        // int 2ndPlayer = 5;        // starts with a number — ILLEGAL
        // int player-score = 5;     // hyphens not allowed — ILLEGAL
        // int class = 5;            // 'class' is a reserved keyword — ILLEGAL

        // Printing the good variables so we can run this
        System.out.println("Students enrolled: " + numberOfStudentsEnrolled);
        System.out.println("Annual salary: $" + annualSalaryInDollars);
        System.out.println("Account suspended: " + isAccountSuspended);
        System.out.println("Customer name: " + customerFullName);
    }
}

public class ConstantsDemo {

    // Class-level constants: static final + SCREAMING_SNAKE_CASE
    // These are defined outside main() so the whole class can access them.

    // The maximum number of times a user can attempt to log in before lockout.
    static final int MAX_LOGIN_ATTEMPTS = 5;

    // The sales tax rate — defined once, used everywhere in billing calculations.
    static final double SALES_TAX_RATE = 0.08;  // 8%

    // The name of the application — never changes at runtime.
    static final String APP_NAME = "BudgetTracker Pro";

    public static void main(String[] args) {

        // Using the constants in real logic
        int currentLoginAttempts = 3;
        double itemPrice = 49.99;

        // Calculate the tax amount using our locked-in constant
        double taxAmount = itemPrice * SALES_TAX_RATE;
        double totalPrice = itemPrice + taxAmount;

        System.out.println("Welcome to " + APP_NAME);
        System.out.println("Item price: $" + itemPrice);
        System.out.println("Tax (" + (SALES_TAX_RATE * 100) + "%): $" + taxAmount);
        System.out.println("Total: $" + totalPrice);
        System.out.println("Login attempts remaining: " + (MAX_LOGIN_ATTEMPTS - currentLoginAttempts));

        // ❌ Try uncommenting the line below — Java will REFUSE to compile.
        // MAX_LOGIN_ATTEMPTS = 10;  // Error: cannot assign a value to final variable
    }
}

public class InitializationAndVar {

    // Instance variable — gets default value 0.0
    double balance;

    // Static variable — gets default value null for String
    static String defaultName;

    public static void main(String[] args) {

        // Local variable — MUST be initialised before use
        int localCount;
        // System.out.println(localCount);  // Compile error: variable might not have been initialised
        localCount = 10;  // now it's safe
        System.out.println("Local count: " + localCount);

        // Using var for type inference — only for local variables
        var message = "Hello Java";  // String inferred
        var price = 19.99;            // double inferred
        // price = "not a number";    // Compile error: String can't be assigned to double

        System.out.println("Message: " + message);
        System.out.println("Price: " + price);

        // Instance and static variables: access through object or class
        InitializationAndVar obj = new InitializationAndVar();
        System.out.println("Default balance: " + obj.balance);  // prints 0.0
        System.out.println("Default name: " + defaultName);     // prints null
    }
}

public class VariableScopeDemo {

    // STATIC VARIABLE — one shared copy for the entire class.
    // Every time we create a new BankAccount, this counter goes up by 1.
    static int totalAccountsCreated = 0;

    // INSTANCE VARIABLES — each BankAccount object gets its own copies.
    // Java sets these to defaults: 0.0 for double, "" is NOT the default for
    // String — the default is null. We initialize explicitly to be safe.
    String accountHolderName;
    double accountBalance;

    // Constructor — called when we create a new BankAccount object
    VariableScopeDemo(String holderName, double initialBalance) {

        // LOCAL VARIABLE — only exists inside this constructor.
        // We use it temporarily before it disappears when the constructor ends.
        String welcomeMessage = "Account created for: " + holderName;

        // Assigning values to the instance variables
        this.accountHolderName = holderName;
        this.accountBalance = initialBalance;

        // Incrementing the SHARED static counter
        totalAccountsCreated++;

        System.out.println(welcomeMessage);  // use the local variable
    }

    void displayBalance() {
        // LOCAL VARIABLE — only lives during this method call
        String balanceReport = accountHolderName + " | Balance: $" + accountBalance;
        System.out.println(balanceReport);
    }

    public static void main(String[] args) {

        // Creating two separate account objects
        VariableScopeDemo account1 = new VariableScopeDemo("James Okafor", 1500.00);
        VariableScopeDemo account2 = new VariableScopeDemo("Priya Nair", 3200.50);

        // Each object has its OWN instance variables
        account1.displayBalance();
        account2.displayBalance();

        // But there is only ONE static variable — shared by both
        System.out.println("Total accounts ever created: " + totalAccountsCreated);
    }
}

// io.thecodeforge
public interface CalculatorConstants {
    double PI = 3.14159265359;
    double UPPER_LIMIT = 0x1.fffffffffffffP+1023;
}

// Don't do this:
public class Calculator implements CalculatorConstants {
    public double area(double radius) {
        return PI * radius * radius; // Compiler inlines PI at compile time
    }
}

// Do this instead:
public final class MathConstants {
    private MathConstants() {}
    public static final double PI = 3.14159265359;
    public static final double UPPER_LIMIT = 0x1.fffffffffffffP+1023;
}

// io.thecodeforge
public enum OrderStatus {
    PENDING("PENDING", "Order placed, awaiting payment"),
    SHIPPED("SHIPPED", "Order dispatched to carrier"),
    DELIVERED("DELIVERED", "Order confirmed delivered");

    private final String code;
    private final String description;

    OrderStatus(String code, String description) {
        this.code = code;
        this.description = description;
    }

    public String getCode() { return code; }
    public String getDescription() { return description; }

    public boolean canCancel() {
        return this == PENDING;
    }
}

// Usage — zero chance of inlining inconsistency:
public class OrderService {
    public void processOrder(Order order) {
        if (order.getStatus() == OrderStatus.PENDING) {
            // Type-safe. Never a silent mismatch.
        }
    }
}