1.1. 是什么
局部变量就是在 方法内部 或者 代码块内部 定义的变量。 它们就像是方法里的小临时工👷♀️， 只在这个方法或代码块内部工作， 方法或代码块执行完毕， 它们也就完成了任务， 可以“下班”了。
1.2. 局部变量的声明和使用
public void calculateSum(int a, int b) { // a 和 b 是方法的参数，它们也是局部变量
int sum = a + b; // sum 是一个局部变量，它只在这个 calculateSum 方法内部有效
System.out.println("The sum is: " + sum);
}
1.3. 局部变量的作用域 (Scope)
作用域指的是一个变量可以被访问的范围。 局部变量的作用域就是 从它被声明的地方开始， 到它所在的代码块结束
public void myMethod() {
int x = 10; // x 的作用域从这里开始
if (x > 5) {
int y = 20; // y 的作用域从这里开始，到 if 代码块结束
System.out.println(x + y);
} // y 的作用域在这里结束
// System.out.println(y); // 错误！y 的作用域已经结束了，这里不能访问 y
System.out.println(x); //x的作用域是方法内部，所以可以访问
} // x 的作用域在这里结束
1.4. 局部变量的生命周期
生命周期指的是一个变量从创建到销毁的整个过程。 生命周期和它的作用域是一致的。
1.5. 注意事项📢
局部变量没有默认值： 你必须先给局部变量赋值， 然后才能使用它， 不然 Java 会报错。局部变量的名字不能和方法参数的名字相同： 不然 Java 会分不清你到底想用哪个变量。
2. 成员变量 (Instance Variables)：对象的属性
如果说局部变量是方法里的小临时工👷♀️， 那么成员变量就是 对象的小管家****🧑💼， 它们负责管理对象的各种属性
一辆汽车🚗有很多属性， 比如品牌 (brand)、 颜色 (color)、 最大速度 (maxSpeed) 等等， 这些属性就可以用成员变量来表示
2.1. 是什么
成员变量是定义在 类内部、 方法外部 的变量。 它们是属于对象的， 每个对象都有自己的一份成员变量的拷贝
2.2. 成员变量的声明和使用
访问修饰符： public、 private、 protected 等， 用于控制成员变量的访问权限 (我们以后会详细学习)。 暂时我们可以先用 public。数据类型： 可以是任何 Java 数据类型， 包括基本数据类型和引用数据类型。变量名： 遵循 Java 变量命名规范。初始值： 可以给成员变量一个初始值， 也可以不给。 如果不给初始值， 成员变量会有默认值 (数值类型为 0， 布尔类型为 false， 引用类型为 null)
举个栗子🌰
在这个 Dog 类中， name、 age 和 breed 就是成员变量， 它们描述了一只狗狗🐶的属性。
public class Dog {
public String name; // 名字
public int age; // 年龄
public String breed; // 品种
public void bark() {
System.out.println(name + " is barking!");
}
public void displayInfo() {
System.out.println("Name: " + name);
System.out.println("Age: " + age);
System.out.println("Breed: " + breed);
}
}
2.3. 如何访问成员变量？
成员变量需要通过 对象 来访问：对象名.成员变量名
public class Main {
public static void main(String[] args) {
Dog myDog = new Dog(); // 创建一个 Dog 对象
myDog.name = "Buddy"; // 设置 myDog 的 name 为 "Buddy"
myDog.age = 3; // 设置 myDog 的 age 为 3
myDog.breed = "Golden Retriever"; // 设置 myDog 的 breed 为 "Golden Retriever"
myDog.bark(); // 输出：Buddy is barking!
myDog.displayInfo(); // 输出狗狗的信息
}
}
2.4. 成员变量的作用域
成员变量的作用域是 整个对象内部。 在对象的任何方法 (非静态方法) 中， 都可以直接访问和修改它的成员变量
2.5. 成员变量的生命周期
成员变量的生命周期是和对象绑定的：
创建： 当使用 new 关键字创建一个对象时， 它的成员变量也同时被创建， Java 会为它们分配内存空间销毁： 当对象不再被使用， 被垃圾回收器回收时， 它的成员变量也同时被销毁， 内存空间被释放。
2.6. 成员变量的默认值
如果我们没有给成员变量赋初始值， 它们会有一个默认值：
数值类型 (byte, short, int, long, float, double)： 默认值为 0 或 0.0boolean 类型： 默认值为 falsechar 类型： 默认值为 \u0000 (空字符)引用类型 (String, 数组, 其他类)： 默认值为 null (表示空， 不指向任何对象)
3. 静态变量 (Static Variables)：类的共享财产
如果说成员变量是每个对象👨💼👩💼的小管家， 那么静态变量就是整个班级👨👩👧👦的班费💰管理员！ 它不属于某个对象， 而是属于整个类， 被这个类的所有对象共享！
3.1. 什么是静态变量？
静态变量是用 static 关键字修饰的成员变量。 它也被称为 类变量。 静态变量不属于某个特定的对象， 而是属于类本身。 无论创建多少个对象， 静态变量都只有一份拷贝， 被所有对象共享。
3.2. 静态变量的声明和使用：
访问修饰符： public、 private、 protected 等， 用于控制静态变量的访问权限 (我们以后会详细学习)。 暂时我们可以先用 public。static 关键字： 这是必须的， 用于标识这是一个静态变量。数据类型： 可以是任何 Java 数据类型。变量名： 遵循 Java 变量命名规范。初始值： 可以给静态变量一个初始值， 也可以不给。 如果不给初始值， 静态变量会有默认值 (规则和成员变量一样)
举个栗子🌰：
在这个 Counter 类中， count 就是一个静态变量， 它用来统计 Counter 对象被创建的次数。 每创建一个 Counter 对象， count 的值就会加 1。 由于 count 是静态的， 它是被所有 Counter 对象共享的， 所以 c1.displayCount()、 c2.displayCount() 和c3.displayCount()输出的都是 count 的当前值。
public class Counter {
public static int count = 0; // 静态变量，用于统计 Counter 对象的数量
public Counter() {
count++; // 在构造函数中，每次创建对象，count 加 1
}
public void displayCount() {
System.out.println("Counter objects created: " + count);
}
public static void main(String[] args) {
Counter c1 = new Counter();
c1.displayCount(); // 输出: Counter objects created: 1
Counter c2 = new Counter();
c2.displayCount(); // 输出: Counter objects created: 2
Counter c3 = new Counter();
c3.displayCount(); // 输出: Counter objects created: 3
// 也可以直接通过类名访问静态变量
System.out.println(Counter.count); // 输出: 3
}
}
3.3. 如何访问静态变量？
虽然可以通过对象名来访问静态变量， 但是这种方式 不推荐， 因为它容易让人误以为静态变量是属于某个对象的， 而实际上它是属于类的。 推荐使用类名来访问静态变量， 这样更清晰。
3.4. 静态变量的作用域
静态变量的作用域是 整个类内部。 在类的任何地方 (静态方法或非静态方法) 都可以访问和修改静态变量
3.5. 生命周期
静态变量的生命周期是 从类被加载到 JVM 开始， 到类被卸载为止
创建： 当程序启动， 类被加载到 JVM 时， 静态变量就被创建， Java 会为它们分配内存空间， 并赋予默认值 (如果没有初始化的话)。销毁： 当程序结束， 类被卸载时， 静态变量被销毁， 内存空间被释放。
再举个栗子****🌰
public class Dog {
public String name;
public int age;
public String breed;
public static int dogCount = 0; // 静态变量，用于统计 Dog 对象的数量
// 静态方法，用于获取 dogCount 的值
public static int getDogCount() {
return dogCount;
}
public Dog(String name, int age, String breed) {
this.name = name;
this.age = age;
this.breed = breed;
dogCount++; // 每次创建一个 Dog 对象，dogCount 加 1
}
public void bark() {
System.out.println(name + " is barking!");
}
public void displayInfo() {
System.out.println("Name: " + name);
System.out.println("Age: " + age);
System.out.println("Breed: " + breed);
}
public static void main(String[] args) {
// 创建一些 Dog 对象，并测试 dogCount 是否正确
Dog dog1 = new Dog("Buddy", 3, "Golden Retriever");
Dog dog2 = new Dog("Lucy", 5, "Labrador");
Dog dog3 = new Dog("Max", 2, "German Shepherd");
System.out.println("Total number of dogs: " + Dog.getDogCount()); // 使用类名调用静态方法
System.out.println("Total number of dogs: " + dog1.getDogCount()); // 也可以使用对象名调用静态方法(但是不推荐)
}
}
4. 常量 (Constants)：永恒不变的值
如果说静态变量是类的共享财产💰， 那么常量就是编程世界里 **“刻在石头上的规则”**🪨， 一旦设定， 就永远不会改变！ 它们通常用来表示一些固定不变的值， 比如圆周率π、 一年的月份数等等。
4.1. 什么是常量？
在 Java 中， 常量是用 final 关键字修饰的变量。 final 的含义是 “最终的， 不可改变的”。 一旦一个变量被 final 修饰， 它的值就不能再被修改了。 我们通常将 final 和 static 一起使用来创建 类级别的常量
4.2. 常量的声明和使用
[访问修饰符] static final 数据类型 常量名 = 初始值;
public class MathConstants {
public static final double PI = 3.14159265358979323846;
public static final int DAYS_IN_A_WEEK = 7;
public static final String MY_CONSTANT = "Hello, World!";
}
4.3. 如何访问常量？
类名.常量名
public class PhysicsConstants {
// 定义常量
public static final int SPEED_OF_LIGHT = 299792458;
public static final double GRAVITATIONAL_CONSTANT = 6.67430e-11;
public static void main(String[] args) {
// 测试常量
System.out.println("Speed of light: " + PhysicsConstants.SPEED_OF_LIGHT + " m/s");
System.out.println("Gravitational constant: " + PhysicsConstants.GRAVITATIONAL_CONSTANT + " N⋅m²/kg²");
// 尝试修改常量的值 (这会导致编译错误)
// PhysicsConstants.SPEED_OF_LIGHT = 300000000; // 错误：无法为最终变量 SPEED_OF_LIGHT 分配值
}
}
4.4. 常量的作用域
常量的作用域和静态变量一样， 是 整个类内部。