// 变量声明与初始化
int age = 25;                 // 基本类型变量
String name = "Alice";        // 引用类型变量
final double PI = 3.14159;    // 常量（final关键字）

// 多个变量声明
int x = 5, y = 10, z = 15;

// 1. 算术运算符
int sum = 10 + 5;     // 15
int diff = 10 - 5;    // 5
int product = 10 * 5; // 50
int quotient = 10 / 5; // 2
int remainder = 10 % 3; // 1

// 2. 关系运算符
boolean isEqual = (10 == 10);   // true
boolean notEqual = (10 != 5);   // true
boolean greater = (10 > 5);     // true

// 3. 逻辑运算符
boolean andResult = (true && false); // false
boolean orResult = (true || false);  // true
boolean notResult = !true;           // false

// 4. 赋值运算符
int count = 10;
count += 5;  // 等价于 count = count + 5 → 15
count *= 2;  // 30

// 1. 条件语句
int score = 85;

// if-else
if (score >= 90) {
    System.out.println("优秀");
} else if (score >= 80) {
    System.out.println("良好"); // 输出此项
} else {
    System.out.println("需努力");
}

// switch-case
char grade = 'B';
switch (grade) {
    case 'A':
        System.out.println("优秀");
        break;
    case 'B':
        System.out.println("良好"); // 输出此项
        break;
    default:
        System.out.println("无效等级");
}

// 2. 循环结构
// for循环
for (int i = 0; i < 5; i++) {
    System.out.print(i + " "); // 输出: 0 1 2 3 4 
}

// 增强for循环
int[] numbers = {1, 2, 3, 4, 5};
for (int num : numbers) {
    System.out.print(num + " "); // 输出: 1 2 3 4 5
}

// while循环
int count = 0;
while (count < 3) {
    System.out.println("计数: " + count);
    count++;
}

// do-while循环
int i = 5;
do {
    System.out.println("至少执行一次");
} while (i < 3);

import java.util.Scanner;

public class InputOutput {
    public static void main(String[] args) {
        // 创建Scanner对象
        Scanner scanner = new Scanner(System.in);
        
        // 输入不同类型数据
        System.out.print("请输入姓名: ");
        String name = scanner.nextLine();
        
        System.out.print("请输入年龄: ");
        int age = scanner.nextInt();
        
        System.out.print("请输入身高(m): ");
        double height = scanner.nextDouble();
        
        // 格式化输出
        System.out.printf("姓名: %s, 年龄: %d, 身高: %.2f米%n", name, age, height);
        
        // 关闭Scanner
        scanner.close();
    }
}

String message = "  Hello, Java!  ";

// 基本操作
int length = message.length();       // 16
String upper = message.toUpperCase(); // "  HELLO, JAVA!  "
String trimmed = message.trim();     // "Hello, Java!"

// 字符串连接
String firstName = "John";
String lastName = "Doe";
String fullName = firstName + " " + lastName; // "John Doe"

// 字符串比较
boolean isEqual = "Java".equals("java"); // false
boolean ignoreCase = "Java".equalsIgnoreCase("java"); // true

// 子字符串
String sub = message.substring(2, 7); // "Hello"

// 字符串拆分
String data = "apple,orange,banana";
String[] fruits = data.split(","); // ["apple", "orange", "banana"]

// 数组声明与初始化
int[] numbers = new int[3];       // {0, 0, 0}
int[] primes = {2, 3, 5, 7, 11}; // 直接初始化

// 二维数组
int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6}
};

// 数组遍历
for (int i = 0; i < primes.length; i++) {
    System.out.println(primes[i]);
}

// 数组排序
import java.util.Arrays;
Arrays.sort(primes); // 升序排序

// 数组复制
int[] copy = Arrays.copyOf(primes, primes.length);

public class MethodDemo {
    // 无返回值方法
    public static void greet() {
        System.out.println("Hello!");
    }
    
    // 带参数有返回值方法
    public static int add(int a, int b) {
        return a + b;
    }
    
    // 可变参数方法
    public static double average(int... numbers) {
        int sum = 0;
        for (int num : numbers) {
            sum += num;
        }
        return (double) sum / numbers.length;
    }
    
    public static void main(String[] args) {
        greet(); // 调用无参方法
        int result = add(5, 3); // 调用带参方法
        double avg = average(1, 2, 3, 4, 5); // 调用可变参数方法
    }
}

public class ExceptionDemo {
    public static void main(String[] args) {
        try {
            // 可能抛出异常的代码
            int result = divide(10, 0);
            System.out.println("结果: " + result);
        } catch (ArithmeticException e) {
            // 捕获特定异常
            System.err.println("错误: " + e.getMessage());
        } finally {
            // 无论是否异常都会执行
            System.out.println("计算结束");
        }
    }
    
    public static int divide(int a, int b) {
        if (b == 0) {
            throw new ArithmeticException("除数不能为零");
        }
        return a / b;
    }
}

int i = 100;
double d = i;  // int → double（100.0）

char   c = 'A';
int code = c;   // char → int（65）

double pi = 3.14159;
int intPi = (int) pi;  // double → int（结果为3，丢失小数）

long bigNum = 100_000_000_000L;
int smallNum = (int) bigNum;  // 溢出风险（错误结果）

// 自动装箱：基本类型 → 包装类（编译器自动转换）
Integer obj = 100;   // 等价于 Integer.valueOf(100)

// 自动拆箱：包装类 → 基本类型
int num = obj;       // 等价于 obj.intValue()

// 声明方式
int[] arr1 = new int[3];         // {0, 0, 0}
int[] arr2 = {1, 2, 3};          // 直接初始化
int[][] matrix = {{1,2}, {3,4}}; // 二维数组

enum Status {
    PENDING, APPROVED, REJECTED
}

Status current = Status.APPROVED;

// 十进制表示（默认）
int decimal = 100;       // 100
int negative = -50;      // -50

// 二进制表示（前缀 0b 或 0B）
byte binary = 0b1101;    // 13 (0b00001101)
int binInt = 0b1010_1100_1101; // 使用下划线增强可读性

// 八进制表示（前缀 0）
short octal = 017;       // 15 (1*8 + 7)

// 十六进制表示（前缀 0x 或 0X）
int hex = 0xFF;          // 255
long hexLong = 0xCAFEBABEL; // 3,405,691,582

// long 类型字面量（后缀 L 或 l）
long bigNum = 10000000000L; // 必须加 L
long creditCard = 1234_5678_9012_3456L; // 使用下划线分隔

// 自动装箱（基本类型 → 包装类）
Integer obj = 100;  // 等价于 Integer.valueOf(100)

// 自动拆箱（包装类 → 基本类型）
int num = obj;      // 等价于 obj.intValue()

// 手动转换
String numStr = "123";
int parsed = Integer.parseInt(numStr); // 字符串转int
String binary = Integer.toBinaryString(10); // 十进制转二进制

// 基本算术运算
int a = 10, b = 3;
int sum = a + b;    // 13
int diff = a - b;   // 7
int product = a * b;// 30
int quotient = a / b; // 3（整数除法）
int remainder = a % b; // 1

// 位运算
int x = 0b1010;     // 10 (二进制)
int y = 0b1100;     // 12 (二进制)
int and = x & y;    // 0b1000 → 8（按位与）
int or = x | y;     // 0b1110 → 14（按位或）
int xor = x ^ y;    // 0b0110 → 6（按位异或）
int shiftLeft = x << 1; // 0b10100 → 20（左移）
int shiftRight = y >> 1; // 0b0110 → 6（带符号右移）
int unsignedRight = y >>> 1; // 0b0110 → 6（无符号右移）

// 复合赋值
int count = 10;
count += 5;     // 15
count *= 2;     // 30
count &= 0x0F;  // 14 (30 & 15)

// 数组内存占用对比
byte[] byteArray = new byte[1000]; // 1,000 字节
int[] intArray = new int[1000];    // 4,000 字节
long[] longArray = new long[1000]; // 8,000 字节

// 无符号操作（Java 8+）
int unsigned = Integer.parseUnsignedInt("4294967295");
String unsignedStr = Integer.toUnsignedString(-1); // "4294967295"

// 最大值/最小值常量
int maxInt = Integer.MAX_VALUE;   // 2,147,483,647
int minInt = Integer.MIN_VALUE;   // -2,147,483,648

// 位操作工具
int bitCount = Integer.bitCount(15); // 4（二进制1的数量）
int reversed = Integer.reverse(0xA); // 0x50000000（位反转）

// 标准十进制表示
double d1 = 3.14;          // 有效
float f1 = 3.14f;          // 必须加 f 后缀

// 科学计数法
double earthMass = 5.972e24;   // 5.972 × 10²⁴
double electronMass = 9.1e-31; // 9.1 × 10⁻³¹

// 特殊值表示
double positiveInfinity = Double.POSITIVE_INFINITY; // 正无穷大
float negativeInfinity = Float.NEGATIVE_INFINITY;   // 负无穷大
double nan = Double.NaN;  // 非数字（Not a Number）

// 下划线增强可读性（Java 7+）
double billion = 1_000_000_000.000_001;

System.out.println(0.1 + 0.2);  // 0.30000000000000004（非0.3）
System.out.println(1.0 - 0.9);  // 0.09999999999999998

// 方案1：使用 BigDecimal（精确计算）
BigDecimal a = new BigDecimal("0.1");
BigDecimal b = new BigDecimal("0.2");
System.out.println(a.add(b)); // 0.3

// 方案2：控制精度（四舍五入）
double result = Math.round((0.1 + 0.2) * 100.0) / 100.0; // 0.3

// 方案3：使用误差范围比较
final double EPSILON = 1e-10; // 误差阈值
double x = 1.0 - 0.9;
if (Math.abs(x - 0.1) < EPSILON) {
    System.out.println("视为相等");
}

// 1. 无穷大运算
System.out.println(1.0 / 0.0);   // Infinity
System.out.println(-1.0 / 0.0);  // -Infinity
System.out.println(1.0 / Double.POSITIVE_INFINITY); // 0.0

// 2. NaN 运算
System.out.println(0.0 / 0.0);            // NaN
System.out.println(Math.sqrt(-1));        // NaN
System.out.println(Double.NaN == Double.NaN); // false（重要！）

// 正确检测 NaN
if (Double.isNaN(x)) {
    System.out.println("x 是非数字");
}

// 3. 严格浮点计算（strictfp）
public strictfp class ScientificCalculator {
    // 类内所有浮点运算遵循 IEEE 754 标准
    // 保证不同平台结果一致
}

int count = 100;
double dCount = count;   // 100.0

float price = 19.99f;
double dPrice = price;   // 19.990000000000002

double pi = 3.1415926535;
float fPi = (float) pi;  // 3.1415927（精度损失）

double large = 1.8e308;
float small = (float) large; // Infinity（溢出）

// 字符串转浮点
float f = Float.parseFloat("3.14");
double d = Double.parseDouble("2.71828");

// 特殊值检测
Double.isNaN(Double.NaN);      // true
Float.isInfinite(Float.POSITIVE_INFINITY); // true

// 浮点比较（避免直接==）
Double.compare(0.1 + 0.2, 0.3) > 0; // true（0.3 < 实际值）

// 物理公式：动能计算
double kineticEnergy(double mass, double velocity) {
    return 0.5 * mass * Math.pow(velocity, 2);
}

// 使用 BigDecimal 处理货币
BigDecimal total = new BigDecimal("99.99")
    .multiply(new BigDecimal("0.15")) // 15%税
    .setScale(2, RoundingMode.HALF_UP); // 四舍五入到分

// 3D坐标（使用 float 节省内存）
public class Vector3f {
    float x, y, z; // 适合GPU处理
}

// 计算平均值（注意溢出）
double average(int[] data) {
    double sum = 0.0;
    for (int value : data) {
        sum += value; // 使用double避免整数溢出
    }
    return sum / data.length;
}

// 1. 直接字符赋值
char c1 = 'A';           // 拉丁字母
char c2 = '汉';           // 汉字
char c3 = 'あ';          // 平假名
char c4 = 'Δ';           // 希腊字母

// 2. Unicode 转义序列
char u1 = '\u0041';      // 'A' (16进制)
char u2 = '\u6C49';      // '汉'

// 3. 整数赋值（自动转换）
char i1 = 65;            // 'A' (十进制)
char i2 = 0x6C49;        // '汉' (16进制)

// 表情符号：😂 (U+1F602)
String emoji = "\uD83D\uDE02";  // 代理对
System.out.println(emoji);       // 输出 😂

String text = "Hello汉😂";

// 获取码点数量（实际字符数）
int charCount = text.length();       // 7（包括代理对）
int codePointCount = text.codePointCount(0, text.length()); // 6

// 遍历码点
for (int i = 0; i < text.length(); ) {
    int codePoint = text.codePointAt(i);
    System.out.printf("U+%04X ", codePoint); // U+0048 U+0065...
    i += Character.charCount(codePoint);
}
// 输出：U+0048 U+0065 U+006C U+006C U+006F U+6C49 U+1F602

// 字符分类
boolean isLetter = Character.isLetter('漢');    // true
boolean isDigit = Character.isDigit('９');      // true（全角数字）
boolean isSpace = Character.isWhitespace('　'); // true（全角空格）

// 大小写转换
char upper = Character.toUpperCase('é');        // 'É'
char lower = Character.toLowerCase('Ω');        // 'ω'

// Unicode 块判断
boolean isCJK = Character.UnicodeBlock.of('漢') 
                == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS; // true

// 字符 ↔ 码点
int codePoint = Character.codePointAt("A", 0); // 65
char[] chars = Character.toChars(0x1F602);     // [0xD83D, 0xDE02]

// 代理对判断
char high = '\uD83D', low = '\uDE02';
boolean isHigh = Character.isHighSurrogate(high); // true
boolean isLow = Character.isLowSurrogate(low);    // true
int emojiCode = Character.toCodePoint(high, low); // 128514 (0x1F602)

// 1. 字符串长度陷阱
String emoji = "😂";
int length = emoji.length();          // 2（代理对数量）
int trueLength = emoji.codePointCount(0, emoji.length()); // 1

// 2. 正确遍历字符
String text = "A汉😂";
IntStream codePoints = text.codePoints(); // Java 8+
codePoints.forEach(cp -> 
    System.out.println(new String(Character.toChars(cp)));
// 输出：A, 汉, 😂

// 3. 子字符串处理
String sub = text.substring(0, 3); // "A汉"（不会截断 😂）

// 1. 字符串 ↔ 字节数组
String original = "日本語";
byte[] utf8Bytes = original.getBytes(StandardCharsets.UTF_8); 
String decoded = new String(utf8Bytes, StandardCharsets.UTF_8);

// 2. 处理乱码问题
byte[] data = {(byte)0xE6, (byte)0x97, (byte)0xA5}; // "日"的UTF-8
String correct = new String(data, StandardCharsets.UTF_8); // "日"
String wrong = new String(data, StandardCharsets.ISO_8859_1); // "日"