// Float examples
float temperature = 36.5f;
float price = 299.99f;
float percentage = 85.5f;

// Double examples  
double pi = 3.141592653589793;
double scientificValue = 1.23e-4;
double bankBalance = 50000.75;

// Precision comparison
float f = 1.23456789f;    // Stored as: 1.2345679
double d = 1.23456789;    // Stored as: 1.23456789

// Basic syntax
dataType variableName;

// Declaration examples
int age;
double salary;
boolean isActive;
char grade;

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

// Declaration with initialization
int age = 25;
double salary = 50000.0;
boolean isActive = true;
char grade = 'A';

// Separate initialization
int count;
count = 10;

// Multiple initialization
int a = 1, b = 2, c = 3;

// Using final keyword
final int MAX_STUDENTS = 50;
final double PI = 3.14159;
final String COLLEGE_NAME = "Government Polytechnic";

// Must initialize when declared
final int YEAR = 2024;

// Cannot change later
// YEAR = 2025;  // Compilation error!

public class ScopeExample {
    // Instance variable
    private int instanceVar = 10;
    
    // Class variable  
    private static int classVar = 20;
    
    public void method() {
        // Local variable
        int localVar = 30;
        
        System.out.println(instanceVar); // ✅ Accessible
        System.out.println(classVar);    // ✅ Accessible  
        System.out.println(localVar);    // ✅ Accessible
    }
    
    public void anotherMethod() {
        System.out.println(instanceVar); // ✅ Accessible
        System.out.println(classVar);    // ✅ Accessible
        // System.out.println(localVar); // ❌ Not accessible
    }
}

// Student Management System
public class Student {
    // Appropriate data type choices
    private byte age;              // 0-127 range sufficient
    private short admissionYear;   // Year fits in short
    private int rollNumber;        // Unique ID, int is fine
    private long phoneNumber;      // Large number, needs long
    
    private float height;          // Approximate value, float OK
    private double gpa;            // Precision important, use double
    
    private char section;          // Single character 'A', 'B', etc.
    private boolean isActive;      // True/false status
    
    private String firstName;      // Text data
    private String address;        // Variable length text
}

// Autoboxing: primitive → wrapper (automatic)
Integer num = 42;  // Compiler converts to Integer.valueOf(42)
Double price = 99.99;  // Compiler wraps automatically

// Unboxing: wrapper → primitive (automatic)
int value = num;  // Compiler calls num.intValue()
double cost = price;  // Compiler unwraps automatically

// Manual boxing/unboxing (explicit)
Integer manual = Integer.valueOf(100);  // Manual boxing
int primitive = manual.intValue();      // Manual unboxing

// Mixed operations (auto boxing/unboxing)
Integer a = 10;
Integer b = 20;
Integer sum = a + b;  // Unbox, add, then box result

// Inefficient: Creates many wrapper objects
Integer total = 0;
for (int i = 0; i < 1000; i++) {
    total += i;  // Autoboxing/unboxing in each iteration
}

// Efficient: Use primitive for calculations
int total = 0;
for (int i = 0; i < 1000; i++) {
    total += i;  // Pure primitive operations
}
Integer result = total;  // Box only once at the end

// Parsing strings to numbers
int num1 = Integer.parseInt("123");
int num2 = Integer.parseInt("1010", 2);  // Binary
int num3 = Integer.parseInt("FF", 16);   // Hexadecimal

// Number system conversions
String binary = Integer.toBinaryString(42);      // "101010"
String octal = Integer.toOctalString(42);        // "52"
String hex = Integer.toHexString(42);            // "2a"

// Min/Max values
System.out.println(Integer.MIN_VALUE);  // -2147483648
System.out.println(Integer.MAX_VALUE);  // 2147483647

// Comparison and utility
Integer a = 10, b = 20;
int comparison = Integer.compare(a, b);  // -1 (a < b)
int maxVal = Integer.max(a, b);          // 20
int minVal = Integer.min(a, b);          // 10

// Bit manipulation
int bitCount = Integer.bitCount(42);     // Count of 1s in binary
int leadingZeros = Integer.numberOfLeadingZeros(42);

// Character testing
char ch = 'A';
System.out.println(Character.isLetter(ch));      // true
System.out.println(Character.isDigit('5'));      // true
System.out.println(Character.isWhitespace(' ')); // true
System.out.println(Character.isUpperCase(ch));   // true
System.out.println(Character.isLowerCase(ch));   // false

// Case conversion
char lower = Character.toLowerCase('A');  // 'a'
char upper = Character.toUpperCase('z');  // 'Z'

// Unicode operations
int unicodeValue = Character.getNumericValue('5');  // 5
char fromUnicode = Character.toChars(65)[0];        // 'A'

// Character categories
System.out.println(Character.getType('A'));  // UPPERCASE_LETTER

// Practical example: validating input
public static boolean isValidIdentifierChar(char c, boolean isFirst) {
    if (isFirst) {
        return Character.isLetter(c) || c == '_' || c == '$';
    } else {
        return Character.isLetterOrDigit(c) || c == '_' || c == '$';
    }
}

// Widening conversions (automatic, no data loss)
byte b = 100;
short s = b;    // byte → short
int i = s;      // short → int
long l = i;     // int → long
float f = l;    // long → float (may lose precision)
double d = f;   // float → double

// Chain conversion
byte original = 50;
double result = original;  // byte → short → int → long → float → double

// Mixed arithmetic (automatic promotion)
byte x = 10;
short y = 20;
int z = x + y;  // x and y promoted to int for calculation

// Literal assignments
long bigNumber = 123456789L;
float decimal = 3.14f;
double precise = 2.718281828;

// Narrowing conversions (explicit, potential data loss)
double d = 123.456;
float f = (float) d;    // double → float
long l = (long) f;      // float → long (fractional part lost)
int i = (int) l;        // long → int
short s = (short) i;    // int → short
byte b = (byte) s;      // short → byte

// Potential data loss examples
int large = 300;
byte small = (byte) large;  // Overflow: 300 becomes 44
System.out.println("300 as byte: " + small);

// Safe narrowing with bounds checking
public static byte safeIntToByte(int value) {
    if (value < Byte.MIN_VALUE || value > Byte.MAX_VALUE) {
        throw new IllegalArgumentException("Value out of byte range: " + value);
    }
    return (byte) value;
}

// Truncation in floating point
double pi = 3.14159;
int piInt = (int) pi;  // 3 (decimal part truncated)

public class MemoryExample {
    
    // Static variables: Method Area
    private static int classCounter = 0;
    private static final String COLLEGE_NAME = "GTU";
    
    // Instance variables: Heap Memory
    private String studentName;
    private int rollNumber;
    private double[] marks;  // Array reference in heap, array data also in heap
    
    public void processStudent(String name) {
        // Local variables: Stack Memory
        int localCounter = 0;      // Stack
        double average = 0.0;      // Stack
        String tempName = name;    // Stack (reference), Heap (String object)
        
        // Array creation
        int[] scores = new int[5]; // Reference in stack, array in heap
    }
}

public class MemoryAllocation {
    
    // Class-level demonstration
    private static void demonstrateMemoryUsage() {
        
        // Stack allocation (local variables)
        int studentAge = 20;           // 4 bytes on stack
        long studentId = 12345L;       // 8 bytes on stack
        boolean isActive = true;       // 1 byte on stack
        
        // Heap allocation (objects)
        String name = "John Doe";      // Reference on stack, object on heap
        int[] marks = new int[5];      // Reference on stack, array on heap
        
        // Wrapper objects (heap allocation)
        Integer wrappedAge = studentAge;     // Boxing creates heap object
        Double gpa = 3.75;                   // Object on heap
        
        // Large data structures
        List<String> subjects = new ArrayList<>();  // Objects on heap
        subjects.add("Java Programming");           // String on heap
        subjects.add("Data Structures");            // String on heap
        
        // Memory efficiency consideration
        StringBuilder builder = new StringBuilder(); // More efficient than String concatenation
        for (int i = 0; i < 1000; i++) {
            builder.append("Student").append(i);    // Reuses internal buffer
        }
        String result = builder.toString();         // Final string creation
    }
    
    // Garbage collection demonstration
    public static void demonstrateGarbageCollection() {
        String[] largeArray = new String[1000];
        
        // Fill array with objects
        for (int i = 0; i < largeArray.length; i++) {
            largeArray[i] = "Student " + i;
        }
        
        // Remove reference - objects become eligible for GC
        largeArray = null;
        
        // Suggest garbage collection (not guaranteed)
        System.gc();
        
        System.out.println("Objects may be garbage collected now");
    }
}

// ✅ Correct variable names
int studentAge;
double averageMarks;
boolean isStudentActive;
String firstName;
List<String> enrolledCourses;

// ✅ Correct method names
public void calculateGPA() { }
public boolean isEligibleForScholarship() { }
public String getFormattedName() { }
public void setStudentDetails() { }

// ❌ Incorrect naming
int student_age;        // Snake case (not Java style)
double AvgMarks;        // PascalCase (wrong for variables)
boolean flag;           // Non-descriptive
String s;               // Single character (unclear)

// ✅ Correct constants
public static final int MAX_STUDENTS_PER_CLASS = 60;
public static final String DEFAULT_COLLEGE_NAME = "GTU";
public static final double PASSING_PERCENTAGE = 40.0;
private static final String DATABASE_URL = "jdbc:mysql://localhost:3306/college";

// ❌ Incorrect constants
public static final int maxStudents = 60;    // Should be ALL_CAPS
private static final String dbUrl = "...";   // Should be ALL_CAPS

// ❌ Poor naming (unclear, abbreviated)
public class Student {
    private String n;           // What is 'n'?
    private int a;              // What is 'a'?
    private double m;           // What is 'm'?
    private boolean f;          // What is 'f'?
    
    public void calc() {        // Calculate what?
        double r = m * 0.9;     // What is 'r'?
    }
}

// ✅ Good naming (clear, descriptive)
public class Student {
    private String fullName;
    private int currentAge;
    private double totalMarks;
    private boolean isActiveStudent;
    
    public void calculateFinalGrade() {
        double finalGrade = totalMarks * 0.9;
        // Clear what we're calculating
    }
}

// ✅ Context-appropriate naming
public class BankAccount {
    private double currentBalance;
    private String accountHolderName;
    private int transactionCount;
    private LocalDate lastTransactionDate;
    
    public boolean withdrawAmount(double requestedAmount) {
        if (requestedAmount > currentBalance) {
            return false; // Insufficient funds
        }
        currentBalance -= requestedAmount;
        transactionCount++;
        lastTransactionDate = LocalDate.now();
        return true;
    }
}

// ✅ Banking Domain Example
public class BankingTransaction {
    
    // Domain-specific terminology
    private UUID transactionId;
    private AccountNumber sourceAccount;
    private AccountNumber destinationAccount;
    private MonetaryAmount transactionAmount;
    private TransactionType operationType;
    private LocalDateTime transactionTimestamp;
    private TransactionStatus currentStatus;
    
    // Business rule methods with clear names
    public boolean isTransactionWithinDailyLimit(MonetaryAmount dailyLimit) {
        return transactionAmount.isLessThanOrEqualTo(dailyLimit);
    }
    
    public boolean isSourceAccountSufficientForTransaction() {
        return sourceAccount.getAvailableBalance()
                          .isGreaterThanOrEqualTo(transactionAmount);
    }
    
    public void executeTransfer() throws InsufficientFundsException {
        validateTransactionPreconditions();
        debitSourceAccount();
        creditDestinationAccount();
        updateTransactionStatus(TransactionStatus.COMPLETED);
        recordTransactionInAuditLog();
    }
}

// ✅ E-commerce Domain Example  
public class ShoppingCart {
    
    private CustomerId customerId;
    private List<CartItem> cartItems;
    private MonetaryAmount subtotalAmount;
    private TaxAmount applicableTax;
    private DiscountAmount appliedDiscount;
    private ShippingCost estimatedShippingCost;
    
    public MonetaryAmount calculateTotalAmount() {
        return subtotalAmount
                .plus(applicableTax)
                .minus(appliedDiscount)  
                .plus(estimatedShippingCost);
    }
}

public class ApplicationConfiguration {
    
    // ✅ Grouped constants with clear hierarchy
    public static final class DatabaseConfiguration {
        public static final String DEFAULT_DRIVER_CLASS = "com.mysql.cj.jdbc.Driver";
        public static final String CONNECTION_URL_TEMPLATE = "jdbc:mysql://%s:%d/%s";
        public static final int DEFAULT_CONNECTION_TIMEOUT = 30000;
        public static final int MAXIMUM_POOL_SIZE = 20;
        public static final int MINIMUM_POOL_SIZE = 5;
    }
    
    public static final class BusinessRules {
        public static final int MINIMUM_STUDENT_AGE = 16;
        public static final int MAXIMUM_STUDENT_AGE = 65;
        public static final double MINIMUM_PASSING_GRADE = 40.0;
        public static final int MAXIMUM_SUBJECTS_PER_SEMESTER = 8;
        public static final Duration SESSION_TIMEOUT_DURATION = Duration.ofMinutes(30);
    }
    
    public static final class ValidationPatterns {
        public static final Pattern EMAIL_VALIDATION_PATTERN = 
            Pattern.compile("^[A-Za-z0-9+_.-]+@([A-Za-z0-9.-]+\\.[A-Za-z]{2,})$");
        public static final Pattern PHONE_NUMBER_PATTERN = 
            Pattern.compile("^\\+?[1-9]\\d{1,14}$");
        public static final Pattern STUDENT_ID_PATTERN = 
            Pattern.compile("^[A-Z]{3}\\d{6}$");
    }
    
    // ✅ Environment-specific configuration
    public enum Environment {
        DEVELOPMENT("dev", "localhost", 3306),
        TESTING("test", "test-server", 3306),
        PRODUCTION("prod", "prod-server", 3306);
        
        private final String environmentName;
        private final String databaseHost;
        private final int databasePort;
        
        Environment(String environmentName, String databaseHost, int databasePort) {
            this.environmentName = environmentName;
            this.databaseHost = databaseHost;
            this.databasePort = databasePort;
        }
        
        public String getDatabaseUrl(String databaseName) {
            return String.format(DatabaseConfiguration.CONNECTION_URL_TEMPLATE,
                               databaseHost, databasePort, databaseName);
        }
    }
}