Java变量——运算符——程序逻辑控制

变量

定义：变量就是在程序中值可以改变的量。

赋值和初始化：int a;  a=10;

变量类型	作用域范围	生命周期	默认值
成员变量（实例变量）	整个类内部（非static修饰）	对象创建时存在，对象销毁时释放	有默认值（如int是0）
静态变量（类变量）	整个类内部（static修饰）	类加载时存在，程序结束时释放	有默认值
局部变量	仅在定义它的代码块（方法、循环、if等）内有效	进入代码块时创建，离开时销毁	无默认值，必须显式初始化

1. 成员变量（实例变量）

特点

属于对象：每个对象拥有自己的一份实例变量。

作用域：整个类内部（非static修饰）。

生命周期：对象创建时分配内存，对象被垃圾回收时释放。

默认值：有默认值（如 int 默认 0，boolean 默认 false）。

例子：public class Dog {
    // 成员变量（实例变量）
    String name;  // 默认值 null
    int age;      // 默认值 0

    public void bark() {
        System.out.println(name + " is barking!"); // 可以直接使用成员变量
    }

    public static void main(String[] args) {
        Dog dog1 = new Dog();
        dog1.name = "Buddy";  // 设置实例变量
        dog1.age = 3;
        dog1.bark();  // 输出 "Buddy is barking!"

        Dog dog2 = new Dog();
        System.out.println(dog2.name);  // 输出 null（默认值）
    }
}

2. 静态变量（类变量）

特点

属于类：所有对象共享同一份静态变量。

作用域：整个类内部（static修饰）。

生命周期：类加载时分配内存，程序结束时释放。

默认值：有默认值（同成员变量）。

访问方式：推荐通过类名访问（如 ClassName.variable）。

例子：public class Cat {
    // 静态变量（类变量）
    static int count = 0;  // 统计Cat对象的数量

    String name;

    public Cat(String name) {
        this.name = name;
        count++;  // 每创建一个Cat对象，count+1
    }

    public static void main(String[] args) {
        Cat cat1 = new Cat("Tom");
        Cat cat2 = new Cat("Whiskers");

        System.out.println(Cat.count);  // 输出 2（所有对象共享count）
        System.out.println(cat1.count); // 也能通过对象访问（但不推荐）
    }
}

3. 局部变量

特点

属于方法/代码块：仅在定义它的方法、循环、if等内部有效。

作用域：仅限于定义它的代码块内。

生命周期：代码块执行时创建，执行完毕后销毁。

默认值：无默认值，必须显式初始化！

例子：public class Calculator {
    // 成员变量
    int result;  // 默认值 0

    public void add(int a, int b) {
        // 局部变量（必须初始化）
        int sum = a + b;  // sum是局部变量
        result = sum;     // 成员变量result被修改
        System.out.println("Sum: " + sum);
    }

    public static void main(String[] args) {
        Calculator calc = new Calculator();
        calc.add(5, 3);  // 输出 "Sum: 8"

        // System.out.println(sum); // 错误！sum是add()的局部变量，此处不可见
        System.out.println(calc.result); // 输出 8（成员变量）
    }
}

---

public class Test {
    static int x = 10;  // 静态变量
    int y = 20;         // 实例变量

    public static void main(String[] args) {
        // System.out.println(y); // 错误！不能直接访问实例变量
        System.out.println(x);    // 正确（静态变量）
        
        Test obj = new Test();
        System.out.println(obj.y); // 正确（通过对象访问实例变量）
    }
}

• 静态方法（如 main）中不能直接访问实例变量（需通过对象）。

• 静态变量可以通过类名直接访问（如 Test.x）。

---

2. 关键区别：成员变量 vs 局部变量

(1) 成员变量（实例变量 / 静态变量）

• 有默认值（即使不赋值，Java也会自动初始化）。

• 作用域：整个类内有效。

• 示例：

  public class Test {
      int a;          // 实例变量（默认值 0）
      static double b; // 静态变量（默认值 0.0）
      
      public static void main(String[] args) {
          Test obj = new Test();
          System.out.println(obj.a); // 输出 0
          System.out.println(b);     // 输出 0.0
      }
  }

(2) 局部变量

• 没有默认值，必须显式初始化后才能使用，否则编译报错。

• 作用域：仅在定义它的代码块（方法、循环、if等）内有效。

• 示例：变量必须先赋值再使用

  1.public class Test {
      public static void main(String[] args) {
          int x;       // 局部变量（未初始化）
          // System.out.println(x); // 编译错误！x未赋值
          
          x = 10;      // 正确：先赋值再使用
          System.out.println(x); // 输出 10
      }
  }
  
  
  2.public class Test {
      public static void main(String[] args) {
          String name;
          System.out.println(name);
  （改：String name = "Alice"; // 或 name = null; System.out.println(name);）
      }
  }

---

public class Test {
    int a = 1;          // 实例变量（成员变量）
    static int b = 2;   // 静态变量（类变量）

    public static void main(String[] args) {
        Test t1 = new Test();
        t1.a = 10;      // t1.a 现在是 10（不影响其他对象）

        t1.b = 20;      // 修改静态变量 b（所有对象共享）实际上是 Test.b = 20（影响所有对象）

        Test t2 = new Test();
        System.out.println(t2.a + ", " + t2.b); // 输出什么？t2.a=1，t2.b=20（Test.b = 20）
    }
}

---

运算符

类别	运算符	描述
算术运算符	+ - * / %	加、减、乘、除、取模（余数）例:-10/3=-3;10/-3=3
	++（前缀/后缀）--（前缀/后缀）	自增1、自减1
赋值运算符	=	基本赋值
	+= -= *= /= %= &= |= ^= <<= >>= >>>=	复合赋值（如 a += b 等价于 a = a + b）
关系运算符	== != > < >= <=	比较相等性、大小关系，返回布尔值
逻辑运算符	&&（短路与） ||（短路或） !（非）	布尔逻辑运算（短路特性：若左边可确定结果，右边不执行）
	&（按位与） |（按位或） ^（按位异或）	也可用于布尔逻辑（无短路特性）
位运算符	& | ^ ~（按位取反）	对整数的二进制位操作
	<<（左移） >>（带符号右移） >>>（无符号右移）	移位操作
条件运算符	? :	三元运算符（如 x = (a > b) ? a : b）
instanceof	instanceof	检查对象是否为指定类/接口的实例（如 obj instanceof String）
其他	()（括号） []（数组访问） .（成员访问） new（对象创建）	方法调用、数组索引、对象成员访问、创建对象等

break和continue

break 类型	作用	例子
普通 break	跳出当前这层循环	只停止检查当前房间的藏身点
带标签的 break	跳出指定标签的那层循环	直接结束整个游戏（所有房间都不找了）

如：游戏结束:  // ← 这是一个标签（可以叫任何名字，比如"stop"）
for (int 房间 = 1; 房间 <= 3; 房间++) {
    System.out.println("正在搜索房间 " + 房间);
    for (int 藏身点 = 1; 藏身点 <= 3; 藏身点++) {
        if (藏身点 == 2) {
            System.out.println("在藏身点 " + 藏身点 + " 找到人了！游戏结束！");
            break 游戏结束;  // ← 直接跳出带标签的循环（所有循环都结束）
        }
    }
}

continue:跳过当前循环，继续下一次循环

程序逻辑控制

选择控制

1. if语句

// 简单if
if (condition) {
    // 条件为true时执行
}

// if-else
if (condition) {
    // 条件为true时执行
} else {
    // 条件为false时执行
}

// if-else if-else
if (condition1) {
    // 条件1为true时执行
} else if (condition2) {
    // 条件2为true时执行
} else {
    // 所有条件都为false时执行
}

注：condition必须是true或false，条件必须是布尔表达式

2. switch语句

switch (expression) {
    case value1:
        // 当expression等于value1时执行
        break;
    case value2:
        // 当expression等于value2时执行
        break;
    // 可以有任意数量的case语句
    default:
        // 当expression不匹配任何case时执行
}

 循环控制

1. while循环

while (condition) {
    // 循环体
    // 当condition为true时继续执行
}

2. do-while循环

do {
    // 循环体
    // 至少执行一次，然后检查条件
} while (condition);

3. for循环

for (初始化; 循环条件; 迭代操作) {
    // 循环体
}

// 示例
for (int i = 0; i < 10; i++) {
    System.out.println(i);
}

4. 增强for循环（for-each）

for (elementType element : collection) {
    // 对集合中的每个元素执行操作
}

// 示例
int[] numbers = {1, 2, 3, 4, 5};
for (int num : numbers) {
    System.out.println(num);
}