let x: number = 5;
let y: number = 5;

x = y + 2; // 加法
console.log(x); // 輸出: 7
x = y - 2; // 減法
console.log(x); // 輸出: 3
x = y * 2; // 乘法
console.log(x); // 輸出: 10
x = y / 2; // 除法
console.log(x); // 輸出: 2.5
x = y % 2; // 取模（余數(shù)）
console.log(x); // 輸出: 1

x = ++y; // 自增（前綴）
console.log(x); // 輸出: 6, y 也變?yōu)?6
y = 5; // 重置 y
x = y++; // 自增（后綴）
console.log(x); // 輸出: 5, 但 y 變?yōu)?6

x = --y; // 自減（前綴）
console.log(x); // 輸出: 4, y 也變?yōu)?4
y = 5; // 重置 y
x = y--; // 自減（后綴）
console.log(x); // 輸出: 5, 但 y 變?yōu)?4

let a: number = 5;
let b: number = 8;

console.log(a == 8); // 輸出: false
console.log(a == 5); // 輸出: true
console.log(a != 8); // 輸出: true
console.log(a > 8);  // 輸出: false
console.log(a < 8);  // 輸出: true
console.log(a >= 8); // 輸出: false
console.log(a <= 8); // 輸出: true

let c: boolean = (a < 10 && b > 1); // and
console.log(c); // 輸出: true

let d: boolean = (a == 5 || b == 5); 
// or（這里實際上為false，因為b不等于5，但示例中寫錯了，已更正）
console.log(d); 
// 輸出: false，因為a==5為真，但b==5為假，但由于是or運算，有一個為真則結(jié)果為真
//（此處描述有誤，已根據(jù)邏輯更正輸出和解釋）
// 注意：上面的d應該為false，因為這里的||是邏輯或，只要有一個條件為真，結(jié)果就為真，
//這里的描述有誤，已更正。
// 正確的邏輯應該是：d為true，因為a==5為真，所以整個表達式為真，但原意是想展示or運算，
//所以保留原代碼和錯誤描述以指出更正。
// 為了避免混淆，我們重新寫一個正確的or運算示例：
let e: boolean = (a == 10 || b == 5); // or
console.log(e); // 輸出: true，因為b==5為真

let f: boolean = !(a == b); // not
console.log(f); // 輸出: true，因為a不等于b

public class ShortCircuitExample {
    public static void main(String[] args) {
        int a = 10;
        int b = 0;

// 這是一個安全的檢查，因為如果 a < 5 為 false，則不會執(zhí)行 b / a，從而避免了除以零的錯誤
        if (a < 5 && b / a > 0) {
            System.out.println("Both conditions are true");
        } else {
            System.out.println("At least one condition is false");
        }

        // 輸出: At least one condition is false
    }
}

public class ShortCircuitOrExample {
    public static void main(String[] args) {
        int a = 10;
        int b = 0;

// 如果第一個條件 a > 5 為 true，則不會評估第二個條件 b / a > 0，從而避免了除以零的錯誤
        if (a > 5 || b / a > 0) {
            System.out.println("At least one condition is true");
        } else {
            System.out.println("Both conditions are false");
        }

        // 輸出: At least one condition is true
    }
}

let g: number = 5; // 二進制: 0101
let h: number = 1; // 二進制: 0001

let i: number = g & h; // AND
console.log(i); // 輸出: 1 (二進制: 0001)

let j: number = g | h; // OR
console.log(j); // 輸出: 5 (二進制: 0101)

let k: number = ~g; // NOT
console.log(k); // 輸出: -6 (二進制: 1010 取反后加1表示負數(shù)，這里是補碼表示)

let l: number = g ^ h; // XOR
console.log(l); // 輸出: 4 (二進制: 0100)

let m: number = g << 1; // 左移
console.log(m); // 輸出: 10 (二進制: 1010)

let n: number = g >> 1; // 右移
console.log(n); // 輸出: 2 (二進制: 0010)

let o: number = 2 >>> 1; // 無符號右移
console.log(o); // 輸出: 1 (對于正數(shù)，無符號右移和有符號右移結(jié)果相同)

let p: number = 10;
let q: number = 5;

p = q; // 賦值
console.log(p); // 輸出: 5

p += q; // 加后賦值
console.log(p); // 輸出: 10

p -= q; // 減后賦值
console.log(p); // 輸出: 5

p *= q; // 乘后賦值
console.log(p); // 輸出: 25

p /= q; // 除后賦值
console.log(p); // 輸出: 5

let r: boolean = true;
let s: string = r ? "Yes" : "No";
console.log(s); // 輸出: Yes

let t: number = 10;
let typeOfT: string = typeof t; // 獲取變量的類型
console.log(typeOfT); // 輸出: "number"

class MyClass {}
let myObj: MyClass = new MyClass();
let isInstanceOfMyClass: boolean = myObj instanceof MyClass; 
// 檢查對象是否是某個構造函數(shù)的實例
console.log(isInstanceOfMyClass); // 輸出: true

// 對正數(shù)應用負號運算符
let positiveNumber: number = 10;
let negativeNumber: number = -positiveNumber;
console.log(negativeNumber); // 輸出: -10

// 對負數(shù)應用負號運算符（相當于取絕對值后再加上負號，但結(jié)果仍是正數(shù)，
//如果原數(shù)是負數(shù)的話其絕對值會變?yōu)槠湎喾磾?shù)再取負還是原數(shù)）
let anotherNegativeNumber: number = -5;
let result: number = -anotherNegativeNumber;
console.log(result); // 輸出: 5

// 直接對字面量數(shù)值應用負號運算符
let literalNegativeNumber: number = -7;
console.log(literalNegativeNumber); // 輸出: -7

// 在表達式中使用負號運算符
let x: number = 5;
let y: number = -3;
let sum: number = x + (-y); 
// 相當于 x + y，但這里顯式地使用了負號運算符來取y的相反數(shù)
console.log(sum); // 輸出: 8

// 注意：負號運算符不能用于非數(shù)值類型，否則會引發(fā)類型錯誤
// let stringValue: string = "10";
// let invalidOperation: number = -stringValue; 
// 這會編譯錯誤，因為不能對字符串類型應用負號運算符

let t: number = 10;
let typeOfT: string = typeof t; // 獲取變量的類型
console.log(typeOfT); // 輸出: "number"

class MyClass {}
let myObj: MyClass = new MyClass();
let isInstanceOfMyClass: boolean = myObj instanceof MyClass; 
// 檢查對象是否是某個構造函數(shù)的實例
console.log(isInstanceOfMyClass); // 輸出: true