运算符优先级

// 左结合示例
int result = 100 / 10 / 2;     // (100 / 10) / 2 = 5，而非 100 / (10 / 2) = 20
System.out.println(result);     // 5

// 右结合示例
int a, b, c;
a = b = c = 10;                // a = (b = (c = 10))

boolean t = true, f = false;
// && 优先级高于 || : a || b && c 等价于 a || (b && c)
boolean r1 = t || f && t;    // t || (f && t) = t || f = true
boolean r2 = (t || f) && t;  // (t || f) && t = t && t = true
// 这两例结果相同，换一个能看出差异的：
boolean r3 = f || t && f;    // f || (t && f) = f || f = false
boolean r4 = (f || t) && f;  // (f || t) && f = t && f = false

/**
 * 飞翔科技 —— 运算符优先级实战
 * 理解优先级与结合性
 */
public class OperatorPrecedenceDemo {
    public static void main(String[] args) {
        System.out.println("===== 飞翔科技 运算符优先级实验 feixiang.net =====\n");

        // --- 实验1：优先级 —— & 与 == 的经典陷阱 ---
        System.out.println("--- 实验1: 优先级陷阱 ---");
        int a = 5;   // 0101
        int b = 3;   // 0011

        // 错误理解：先 (a & b) 再 == 0
        // 实际执行：先 (b == 0) 再 & a（因为 == 优先级高于 &）
        // boolean r1_wrong = a & b == 0;  // 等价于 a & (b == 0) → 编译错误！

        // 正确写法
        boolean r1_right = (a & b) == 0;
        System.out.println("(5 & 3) == 0 → " + r1_right);

        // --- 实验2：结合性 —— 除法的左结合 ---
        System.out.println("\n--- 实验2: 结合性 ---");
        int n1 = 100 / 10 / 2;
        int n2 = 100 / (10 / 2);
        System.out.println("100 / 10 / 2  = " + n1 + "（左结合：(100/10)/2）");
        System.out.println("100 / (10/2)  = " + n2 + "（括号改变结合）");

        // --- 实验3：&& 高于 || ---
        System.out.println("\n--- 实验3: && 高于 || ---");
        boolean t = true, f = false;
        boolean r5a = t || f && t;    // t || (f && t) = t || f = true
        boolean r5b = (t || f) && t;  // (t || f) && t = t && t = true
        System.out.println("true || false && true = " + r5a + "（等价于 true || (false && true)）");
        System.out.println("(true || false) && true = " + r5b);

        boolean r5c = f || t && f;    // f || (t && f) = f || f = false
        boolean r5d = (f || t) && f;  // (f || t) && f = t && f = false
        System.out.println("false || true && false = " + r5c + "（等价于 false || (true && false)）");
        System.out.println("(false || true) && false = " + r5d);

        // --- 实验4：<< 与 + 的优先级 ---
        System.out.println("\n--- 实验4: << 与 + 的优先级 ---");
        int shift1 = 1 << 2 + 3;      // + 优先于 <<：1 << (2+3) = 1 << 5 = 32
        int shift2 = (1 << 2) + 3;    // 括号明： (1<<2) + 3 = 4 + 3 = 7
        System.out.println("1 << 2 + 3 = " + shift1 + "（等价于 1 << (2+3) = 32）");
        System.out.println("(1 << 2) + 3 = " + shift2 + "（等价于 4 + 3 = 7）");
    }
}

/**
 * 飞翔商城 —— 价格表达式中的优先级实战
 */
public class PriceExpressionPrecedence {
    public static void main(String[] args) {
        System.out.println("===== 飞翔商城 价格表达式优先级 feixiang.net =====\n");

        float basePrice = 188.88f;
        int quantity = 5;
        boolean isVip = true;
        float discount = 0.15f;
        float shipping = 10.0f;

        // 复杂表达式：最终价格 = 原价×数量×(1-折扣) + (VIP?0:运费)
        // 括号明确优先级，每一步都可追溯
        float finalPrice = basePrice * quantity * (1 - discount) + (isVip ? 0 : shipping);
        System.out.println("最终价格: ¥" + finalPrice);

        // --- 常见优先级错误 ---
        System.out.println("\n===== 常见优先级错误 =====");

        // 错误写法1：位运算与关系运算混用
        int flags = 0b1010;
        // ❌ 错误：flags & 0b0010 == 0b0010 → flags & (0b0010 == 0b0010) → 编译错误
        // ✅ 正确：(flags & 0b0010) == 0b0010
        boolean hasBit1 = (flags & 0b0010) == 0b0010;
        System.out.println("(0b1010 & 0b0010) == 0b0010 → " + hasBit1 + "（用括号强制优先级）");

        // 错误写法2：三元嵌套无括号
        int salary = 8888;
        String level = (salary >= 10000) ? "高级"
                     : (salary >= 5000)  ? "中级"
                     : "初级";
        System.out.println("薪资等级（括号明确）: " + level);

        // 错误写法3：赋值与比较混淆
        boolean flag = false;
        // if (flag = true)  // ⚠️ 编译通过！永远为true
        // 正确做法：直接使用变量名
        if (flag) {
            System.out.println("这不会执行，因为flag=false");
        }
        System.out.println("赋值vs比较的坑：if(flag=true) 编译通过且永远为true！");
    }
}

// ❌ 这是Java中最著名的优先级陷阱之一！
int flags = 0b1010;   // bit1=1, bit3=1
if (flags & 0b0001 == 0) {
    // 期望：(flags & 0b0001) == 0 → 检测 bit0 是否为 0
    // 实际：flags & (0b0001 == 0) → flags & false → 编译错误！
    System.out.println("bit0 为 0");
}

// ✅ 正确：括号明确优先级
if ((flags & 0b0001) == 0) {
    System.out.println("bit0 为 0");
}

// ❌ 错误：以为 << 优先级高于 +
int result = 1 << 2 + 3;  // 期望 (1<<2)+3=7，实际 1<<(2+3)=1<<5=32
System.out.println(result);  // 32！

// ✅ 正确：用括号明确意图
int result = (1 << 2) + 3;  // 7

// ❌ 经典错误：将 = 误写为 ==
boolean flag = false;
if (flag = true) {  // 编译通过！flag 被赋值为 true，表达式值为 true，永远进入
    System.out.println("这总会执行！");  // 并非本意！
}

// ✅ 防范方案
boolean flag = false;
if (flag) {          // 直接写变量名，最简洁
    // ...
}
// 或者习惯于常量在左：if (true == flag) —— 若写成 true = flag 会编译报错