JAVA_07_面向对象

JAVA的面向对象跟C++很像，就不写了，记录一下容易错的：

01_问题1

首先是数据安全的问题，如果直接调用类里面的成员变量的话，数据可以随便赋值，比如age=-200，这很明显不符合认知，而在main中进行判断，会很麻烦，因此我们采用下面的方式：

1.成员变量 "int age" 改为 "private int age"

2.使用setAge(int num){}来设置age

3.使用getAge(){}来调用age

原：

修改后：

Dog.java:

java 复制代码

public class Dog {
    int age;

    public void setAge(int num) {
        if (num >= 0 && num <= 15) {
            this.age = num;
        } else {
            System.out.println("当前的 " + num + " 不在合理范围内");
        }
    }

    public int getAge() {
        return this.age;
    }
}

test.java:

java 复制代码

package com.itheima.oop.test5;

public class Test {
    public static void main(String[] args) {
        Dog d = new Dog();
        d.setAge(2);
        System.out.println(d.getName() + "，" + d.getAge() + "岁");
    }
}

总结：

02_问题2：

03_构造方法

04_static

Student.java (学生类)

java 复制代码

package com.itheima.staticvariabletest1;

public class Student {
    String name; // 姓名
    int age;     // 年龄

    // 一个的学生共享一个老师
    static String teacherName; // 老师的名字
}

Test.java (测试类)

java 复制代码

package com.itheima.staticvariabletest1;

public class Test {
    public static void main(String[] args) {
        /*
         利用static模拟上述效果

         关于static需要重点掌握的内容：
         1. 静态变量，被当前类所有的对象共享
            共享：
            赋值只要赋值一次
            只要有一个对象修改了静态变量，其他对象再次访问
         2. 调用方式：
            方式一：类名调用（推荐）
            方式二：对象名调用
         */

        // 创建第一个学生对象
        Student stu1 = new Student();
        stu1.name = "小诗诗";
        stu1.age = 19;
        Student.teacherName = "小雯老师"; // 使用类名调用静态变量（推荐方式）
        //stu1.teacherName = "小雯老师"; //这样的话stu2的老师是null

        // 为了演示效果，我们再创建一个学生对象
        Student stu2 = new Student();
        stu2.name = "小明";
        stu2.age = 20;

        // 演示静态变量的共享特性
        System.out.println("学生1信息：");
        System.out.println("姓名：" + stu1.name + "，年龄：" + stu1.age + "，老师：" + stu1.teacherName);

        System.out.println("学生2信息：");
        System.out.println("姓名：" + stu2.name + "，年龄：" + stu2.age + "，老师：" + stu2.teacherName);

        // 修改老师名字
        System.out.println("\n--- 修改老师名字 ---");
        stu1.teacherName = "张老师"; // 通过对象修改静态变量

        System.out.println("学生1现在的老师：" + stu1.teacherName);
        System.out.println("学生2现在的老师：" + stu2.teacherName); // 看看学生2的老师是否也变了
    }
}

运行结果：

java 复制代码

学生1信息：
姓名：小诗诗，年龄：19，老师：小雯老师
学生2信息：
姓名：小明，年龄：20，老师：小雯老师

--- 修改老师名字 ---
学生1现在的老师：张老师
学生2现在的老师：张老师

初始状态：两个学生（小诗诗和小明）的老师都会显示为"小雯老师"。
修改后 ：当你把 stu1的老师改为"张老师"后，打印 stu2的老师时，也会发现变成了"张老师"。

这完美演示了 static关键字的核心特性：静态变量属于类，被所有对象共享。

而对于static的方法，class中的public static 方法可以不用创建对象，直接调用这个方法，因为class里的static 方法不依赖于对象，可以理解为这个class的固有属性，例如：

// 方案A：不合理的非静态方法（如果这么写）

java 复制代码

class Calculator {
    public int max(int a, int b) { // 这个方法需要创建Calculator对象
        return a > b ? a : b;
    }
}

// 使用时：
Calculator cal = new Calculator(); // 第一步：先创建一个计算器对象
int result = cal.max(10, 20);      // 第二步：再用它计算最大值

// 方案B：合理的静态方法（应该这么写）

java 复制代码

class MathUtils {
    public static int max(int a, int b) { // 这个方法与对象无关
        return a > b ? a : b;
    }
}

// 使用时：
int result = MathUtils.max(10, 20); // 一步到位！不需要创建对象

就好比可以直接使用JAVA中的自带的一些类里的属性一样，可以先导入之后直接调用，比如system.out.println()

05_final

final的核心含义就是**"最终的、不可改变的"**。

简单来说，一旦你用 final修饰了一个变量，这个变量就变成了一个常量，它的值在赋值后就不能再变了。

我们需要区分两种情况：基本数据类型 和引用数据类型。

1. 修饰基本数据类型 (如 int, double, boolean)

含义：

final修饰基本数据类型时，意味着变量里记录的数据本身是不可变的。

"变量里面记录的是真实的数据"

"final int a = 10; 此时变量里面记录的数据无法发生改变"

例子：

复制代码

public class FinalDemo {
    public static void main(String[] args) {
        final int MAX_SPEED = 120; // 定义一个常量，代表最高限速
        
        System.out.println("最高限速是：" + MAX_SPEED);
        
        // MAX_SPEED = 150; // 错误！编译器会报错，告诉你不能修改 final 变量
        // 这就好比"光速"是一个常数，你不能把它改成 3000000000。
    }
}

2. 修饰引用数据类型 (如数组, 对象)

含义：

final修饰引用数据类型时，变量里记录的"内存地址"是不可变的 ，但对象内部的属性值是可以变的。

"除了上面四类八种，其他所有的数据类型都是引用类型"

"stu里面的记录对象的内存地址，不可改变的是stu记录的内存地址"

"而对象里面的属性值，是可以发生改变"

通俗比喻：

想象你有一个**"名牌"（final变量）** ，这个名牌一旦挂在一个**"柜子（对象）"**上，就不能再换到另一个柜子上去了（地址不变）。但是，你依然可以打开这个柜子，往里面放东西或者拿东西（属性值改变）。

例子：

复制代码

public class FinalDemo {
    public static void main(String[] args) {
        final Student stu = new Student();
        stu.name = "张三"; // ✅ 允许！这是在修改柜子（对象）里的东西
        stu.age = 18;      // ✅ 允许！
        
        // stu = new Student(); // ❌ 错误！这是想换一个新柜子，名牌（stu）不允许换地方
        // stu = null;          // ❌ 错误！同理，也不能把名牌摘下来（指向空）
        
        System.out.println(stu.name); // 输出：张三
    }
}

class Student {
    String name;
    int age;
}

总结

final 修饰基本类型 = 数据本身锁死了，动不了。
final 修饰引用类型 = 指向的地址锁死了，不能换对象，但对象里面的内容可以改。

"final修饰哪个变量，这个变量里面记录的内容就无法再次发生改变"

06_枚举

EnumTest1.java

java 复制代码

package com.itheima.enumtest;

import com.itheima.enumtest.OrderState; // 导入枚举类

public class EnumTest1 {
    public static void main(String[] args) {
        /*
         * 电商项目中，订单的状态只有以下6种，请编写代码实现。
         * 待支付 PAYMENT_PENDING
         * 处理中 PROCESSING
         * 已发货 SHIPPED
         * 配送中 OUT_FOR_DELIVERY
         * 已送达 DELIVERED
         * 已取消 CANCELLED
         */

        // 1. 获取枚举类的对象
        // 细节：
        // 所有的枚举项，默认使用public static final修饰的
        OrderState o1 = OrderState.PAYMENT_PENDING;
        System.out.println("当前订单状态: " + o1.getName());

        // 2. 使用 switch 语句进行匹配
        // 枚举与 switch 是绝配，代码清晰且安全
        System.out.println("\n--- 订单状态处理逻辑 ---");
        switch (o1) {
            case PAYMENT_PENDING -> System.out.println("状态提示: 待支付");
            case PROCESSING -> System.out.println("状态提示: 处理中");
            case SHIPPED -> System.out.println("状态提示: 已发货");
            case OUT_FOR_DELIVERY -> System.out.println("状态提示: 配送中");
            case DELIVERED -> System.out.println("状态提示: 已送达");
            case CANCELLED -> System.out.println("状态提示: 已取消");
            // 注意：使用枚举时，通常不需要 default 分支，因为编译器会检查是否覆盖了所有情况
        }
    }
}

OrderState.java

java 复制代码

package com.itheima.enumtest;

public enum OrderState {
    // 在枚举类的第一行，把所有的对象都罗列出来了
    PAYMENT_PENDING("待支付"),
    PROCESSING("处理中"),
    SHIPPED("已发货"),
    OUT_FOR_DELIVERY("配送中"),
    DELIVERED("已送达"),
    CANCELLED("已取消");

    private String name;

    private OrderState(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

用最简单的话来说：

枚举，就是帮你"做选择"的工具。

想象一下，你开了一家奶茶店。顾客点单时，杯型只有三种选择：中杯、大杯、超大杯。你不能让顾客说"我要个巨无霸杯"，因为店里根本没这个选项。

没有枚举的时候 ，你可能用数字或单词来代表杯型，比如 1是中杯，"large"是大杯。这就容易出错：服务员可能手滑记成 4，或者拼错成 "lage"。

用了枚举之后，事情就变简单了：
复制代码
enum CupSize { MEDIUM, LARGE, EXTRA_LARGE }
这样一来：

选择是固定的 ：全世界只能用 MEDIUM、LARGE、EXTRA_LARGE这三种写法，不可能出现其他选项。

名字就是意思 ：一看 MEDIUM就知道是中杯，比记数字 1清楚多了。

还能附带信息 ：就像你的例子，每个状态不光有英文名（PAYMENT_PENDING），还能绑定一个中文描述（"待支付"）。

最常用的场景：

订单状态（就像你的例子）：待支付、已发货、已完成...

星期几：周一、周二...

用户类型：普通用户、VIP用户、管理员...

方向：上、下、左、右...

**简单来说，枚举就是 Java 帮你列出一个"标准答案清单"，以后所有用到的地方，都必须从这个清单里挑，不能自己乱编。** 这样代码更安全、更好懂，也更容易维护。

JAVA_07_面向对象

01_问题1

02_问题2：

03_构造方法

04_static

05_final

1. 修饰基本数据类型 (如 int, double, boolean)

2. 修饰引用数据类型 (如 数组, 对象)

总结

06_枚举

2. 修饰引用数据类型 (如数组, 对象)