Java 面向对象笔记：从面向过程到 static 关键字

一、面向过程 vs 面向对象：两种编程思维

1. 面向过程
   核心特点：侧重过程，把问题拆解成一个个步骤，按顺序执行。
   优点：逻辑直接，入门简单。
   缺点：代码量变大后，维护性极差 —— 改一个步骤，可能要牵连整个流程，复用性也很低。

2. 面向对象
   核心特点：侧重对象，用 “上帝视角” 看待问题，把现实中的事物抽象成对象，通过对象的属性和行为解决问题。就像 “把大象放进冰箱”，不用关心具体步骤，只需要关注冰箱和大象这两个对象。
   优点：可扩展性极强，维护成本低，代码复用性高。
   缺点：新手入门时，思维转换会有点难，上手门槛比面向过程高。
   二、类与对象：面向对象的基石
   类和对象是 Java 面向对象的核心概念，我们可以用 “图纸和实例” 来理解：
   类（Class）：是对象的抽象模板，定义了对象的属性（成员变量）和行为（成员方法）。
   比如下面的Car类，定义了车的属性和动作：
   public class Car {
   // 属性：颜色
   String color;
   // 属性：品牌
   String brand;

   // 方法：跑
   public void run() {
   System.out.println("汽车在跑！");
   }

   // 方法：鸣笛
   public void di() {
   System.out.println("汽车在鸣笛！");
   }
   }
   对象（Instance）：是类的具体实例，是根据类的模板 “造出来的实物”。
   // 根据Car类创建对象
   Car myCar = new Car();
   // 给对象的属性赋值
   myCar.color = "红色";
   myCar.brand = "大众";
   // 调用对象的方法
   myCar.run();
   三、this 关键字：指代当前对象
   this关键字的核心作用是指代当前正在操作的对象，在代码里主要有两个场景：
   区分成员变量和局部变量
   当方法的局部变量和类的成员变量同名时，用this.成员变量名明确指向成员变量，避免歧义：
   public class Person {
   String name;

   public void setName(String name) {
   // this.name 指类的成员变量，name 指方法的参数
   this.name = name;
   }
   }
   调用本类的其他构造方法
   在构造方法中，可以用this(参数)调用本类的其他构造方法，减少重复代码（后面构造方法重载会详细说）。
   四、构造方法：对象的 “初始化器”
   构造方法是类中一种特殊的方法，作用是创建对象时给对象的属性做初始化。

3. 构造方法的特点
   方法名必须和类名完全一致（包括大小写）。
   没有返回值类型，连void都不能写。
   当你不写任何构造方法时，编译器会自动提供一个无参的默认构造方法；一旦你写了有参构造方法，默认的无参构造就会消失，需要手动补充。
   public class Car {
   String color;
   String brand;

   // 无参构造方法
   public Car() {
   System.out.println("无参构造方法执行了！");
   }

   // 有参构造方法：初始化属性
   public Car(String color, String brand) {
   this.color = color;
   this.brand = brand;
   System.out.println("有参构造方法执行了！");
   }
   }
   五、构造方法的重载：多种方式创建对象
   和普通方法一样，构造方法也支持重载，核心规则是方法名相同，参数列表不同（参数个数、类型、顺序不同），目的是提供多种初始化对象的方式。
   比如我们给上面的Car类加一个重载的构造方法：
   public class Car {
   String color;
   String brand;
   int price;

   // 无参构造
   public Car() {}

   // 两个参数的构造
   public Car(String color, String brand) {
   this.color = color;
   this.brand = brand;
   }

   // 三个参数的构造（重载）
   public Car(String color, String brand, int price) {
   // 用this调用本类的两个参数构造方法，减少重复代码
   this(color, brand);
   this.price = price;
   }
   }
   使用时可以根据需要选择不同的构造方法创建对象：
   // 方式1：用无参构造创建对象，后续手动赋值
   Car car1 = new Car();
   car1.color = "蓝色";

// 方式2：用两个参数的构造创建对象
Car car2 = new Car("黑色", "丰田");

// 方式3：用三个参数的构造创建对象
Car car3 = new Car("白色", "特斯拉", 250000);
六、小练习：用面向对象写一个小游戏
笔记里有个 “植物大战僵尸” 的小练习，我们可以用面向对象的思想来实现：

1. 定义Zombie（僵尸）类
   public class Zombie {
   String name;
   int hp;
   int attack;

   // 构造方法
   public Zombie(String name, int hp, int attack) {
   this.name = name;
   this.hp = hp;
   this.attack = attack;
   }

   // 攻击方法
   public void fight(Plant plant) {
   System.out.println(this.name + " 在攻击 " + plant.name);
   plant.hp -= this.attack;
   System.out.println(plant.name + " 的剩余血量：" + plant.hp);
   }
   }

2. 定义Plant（植物）类
   public class Plant {
   String name;
   int hp;
   int attack;

   public Plant(String name, int hp, int attack) {
   this.name = name;
   this.hp = hp;
   this.attack = attack;
   }

   public void fight(Zombie zombie) {
   System.out.println(this.name + " 在攻击 " + zombie.name);
   zombie.hp -= this.attack;
   System.out.println(zombie.name + " 的剩余血量：" + zombie.hp);
   }
   }

3. 测试运行
   public class TestGame {
   public static void main(String[] args) {
   Zombie normalZombie = new Zombie("普通僵尸", 100, 10);
   Plant peashooter = new Plant("豌豆射手", 80, 15);

   normalZombie.fight(peashooter);
   peashooter.fight(normalZombie);
   }
   }
   运行结果：
   普通僵尸 在攻击 豌豆射手
   豌豆射手 的剩余血量：70
   豌豆射手 在攻击 普通僵尸
   普通僵尸 的剩余血量：85
   七、static 关键字：静态的世界
   static关键字是 Java 里的重点，它修饰的成员变量、方法属于类本身，而不是某个具体的对象。

4. static 的核心特点
   数据共享：被static修饰的成员变量，是所有对象共享的，只要一个对象修改了它的值，所有对象访问到的都是修改后的值。
   属于类，不属于对象：静态成员直接通过类名.成员名访问，不需要创建对象。
   加载时机早：静态成员在类加载时就初始化了，优先于对象的创建。

5. 静态变量的例子
   public class Person {
   String name;
   // 静态变量：所有Person对象共享的“国家”属性
   static String country = "中国";

   public Person(String name) {
   this.name = name;
   }
   }
   测试代码：
   public class Test {
   public static void main(String[] args) {
   Person p1 = new Person("张三");
   Person p2 = new Person("李四");

   // 静态变量可以通过类名直接访问
   System.out.println(Person.country); // 输出：中国
   System.out.println(p1.country); // 输出：中国
   System.out.println(p2.country); // 输出：中国

   // 修改静态变量的值
   Person.country = "美国";
   // 所有对象访问到的值都会改变
   System.out.println(p1.country); // 输出：美国
   System.out.println(p2.country); // 输出：美国
   }
   }

6. 静态方法的特点
   静态方法同样属于类，直接通过类名.方法名()调用即可。
   静态方法中不能直接使用this关键字，也不能直接访问非静态成员变量或方法，因为静态方法加载时，对象可能还没创建。
   静态方法里可以直接访问静态成员变量或方法。
   public class Person {
   static String country = "中国";
   String name;

   // 静态方法
   public static void printCountry() {
   // 静态方法可以直接访问静态变量
   System.out.println(country);
   // 错误！静态方法不能直接访问非静态变量
   // System.out.println(name);
   // 错误！静态方法里不能用this
   // System.out.println(this.name);
   }

   // 非静态方法
   public void printInfo() {
   // 非静态方法可以访问静态变量
   System.out.println(country);
   // 也可以访问非静态变量
   System.out.println(name);
   }
   }