Java 面向对象程序设计综合复习总结

202302151217

第一章：初识Java与面向对象程序设计

1.1 第一个Java程序：HelloWorld！

           在环境搭建完毕后，编写第一个Java程序是验证开发环境是否正常的好方法。Java程序由类（Class）构成，每个Java程序必须有一个main方法，这是程序的入口点。

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

运行上述代码时，控制台会输出：

Hello, World!

解析：

• public class HelloWorld：定义一个公共类HelloWorld，类名应与文件名相同。
• public static void main(String[] args)：main方法是程序的入口，所有的Java程序都从main方法开始执行。
• System.out.println("Hello, World!");：输出语句，打印“Hello, World!”到控制台。

1.2 Java常用开发工具 

• IDE（集成开发环境）：IntelliJ IDEA、Eclipse、NetBeans等都是非常强大的Java开发工具，提供代码自动补全、调试功能、项目管理等便利。

总结

       本章内容覆盖了Java语言的基本概念以及面向对象编程的核心思想。通过简单的代码示例，我们可以更好地理解封装、继承和多态等基本概念。搭建Java开发环境和编写第一个Java程序是入门Java的重要步骤。在学习过程中，我们不仅要掌握理论知识，还需要通过大量的实践来加深理解和应用。 

 第二章：Java编程基础

2.1 变量与常量

• 变量：变量是程序中用于存储数据的基本单位。Java中声明变量时需要指定数据类型，常见的数据类型包括整数类型（int、long）、浮点类型（float、double）、字符类型（char）、布尔类型（boolean）等。
• 常量：常量是指在程序运行过程中其值不可更改的变量。Java中使用final关键字声明常量。

java
int age = 25; // 变量
final double PI = 3.14159; // 常量

2.2 运算符与表达式

• 运算符：运算符是用于执行数学或逻辑操作的符号。Java中的常见运算符包括算术运算符、关系运算符、逻辑运算符等。 
• 表达式是由操作数（变量、常量）和运算符组成的计算式。例如，a + b是一个简单的算术表达式，a > b是一个逻辑表达式。

2.3 选择结构 

2.3.1 if语句

if语句是最基本的选择结构，根据条件的真假来决定程序的执行路径。

示例代码：

public class IfExample {
    public static void main(String[] args) {
        int age = 18;
        if (age >= 18) {
            System.out.println("Adult");
        } else {
            System.out.println("Minor");
        }
    }
}

2.3.2 switch语句

switch语句是一种多分支选择结构，适用于当条件涉及多个值时，可以提高代码的可读性。

示例代码：

public class SwitchExample {
    public static void main(String[] args) {
        int day = 3;
        switch (day) {
            case 1:
                System.out.println("Monday");
                break;
            case 2:
                System.out.println("Tuesday");
                break;
            case 3:
                System.out.println("Wednesday");
                break;
            default:
                System.out.println("Invalid day");
                break;
        }
    }
}

2.4. 循环结构

2.4.1 for循环

for循环是最常用的循环结构，通常用于已知循环次数的场景。

示例代码：

public class ForLoopExample {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            System.out.println("i = " + i);
        }
    }
}

2.4.2 while循环

while循环通常用于当条件成立时反复执行某一段代码，直到条件不成立为止。

示例代码：

public class WhileLoopExample {
    public static void main(String[] args) {
        int i = 0;
        while (i < 5) {
            System.out.println("i = " + i);
            i++;
        }
    }
}

2.4.3 do-while循环

do-while循环与while类似，不同之处在于它会先执行一次循环体，再判断条件。

示例代码：

public class DoWhileLoopExample {
    public static void main(String[] args) {
        int i = 0;
        do {
            System.out.println("i = " + i);
            i++;
        } while (i < 5);
    }
}

2.4.4 跳转语句 

• break：跳出当前循环或switch语句。
• continue：跳过当前循环中的剩余语句，进入下一次循环。
• return：结束方法并返回一个值。

2.5 方法

方法是Java中的一种代码块，用于执行特定任务。方法通常由方法名、返回类型、参数列表、方法体四部分组成。

示例代码：

public class MethodExample {
    public static void main(String[] args) {
        int result = add(5, 3);  // 调用方法
        System.out.println("Result: " + result);
    }

    // 定义方法
    public static int add(int a, int b) {
        return a + b;
    }
}

2.6 数组

数组是存储多个相同类型数据的容器。Java中数组的长度是固定的，且可以存储基本数据类型或对象类型的数据。

示例代码：

public class ArrayExample {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};  // 声明并初始化数组
        for (int i = 0; i < arr.length; i++) {
            System.out.println("arr[" + i + "] = " + arr[i]);
        }
    }
}

2.7 JVM中的堆内存与栈内存

2.7.1 堆内存

堆内存用于存储对象实例。Java中的对象是动态分配内存的，存储在堆中。堆内存的管理由JVM的垃圾回收机制（GC）来负责。

2.7.2 栈内存 

栈内存用于存储局部变量和方法调用时的栈帧。栈内存的大小是固定的，并且由系统自动管理。

总结

       第二章主要是为后续的面向对象编程做铺垫，学习了Java的基础语法、数据类型、运算符、控制结构等内容。掌握这些基础知识是进一步学习和理解Java面向对象编程的关键。

第三章：面向对象程序设计（基础）

3.1 面向对象的概念

核心概念
• 面向对象编程（OOP）：一种编程范式，使用对象和类来模拟现实世界中的实体和它们的行为。
• 对象：具有状态、行为和标识的实体。
• 类：对象的蓝图，定义了对象的属性（状态）和方法（行为）。
示例代码

// 定义一个类
class Car {
    String model;
    int year;

    // 构造方法
    public Car(String model, int year) {
        this.model = model;
        this.year = year;
    }

    // 方法
    public void displayInfo() {
        System.out.println("Model: " + model + ", Year: " + year);
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建对象
        Car myCar = new Car("Toyota", 2020);
        myCar.displayInfo();  // 输出：Model: Toyota, Year: 2020
    }
}

 3.2 面向对象编程

核心概念
• 类的定义：使用class关键字定义类。
• 对象的创建：使用new关键字创建类的新实例。

3.3 构造方法

构造方法（Constructor）是用于创建对象时初始化其属性的特殊方法。构造方法的特点是：

• 构造方法的名称与类名相同。
• 没有返回类型，甚至没有void关键字。
• 可以重载同名构造方法，以便用不同的参数创建对象。

示例代码：

class Person {
    String name;
    int age;

    // 构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void introduce() {
        System.out.println("My name is " + name + " and I am " + age + " years old.");
    }
}

public class Main {
    public static void main(String[] args) {
        Person p1 = new Person("Alice", 25);
        p1.introduce();  // 输出：My name is Alice and I am 25 years old.
    }
}

3.4 this 关键字

核心概念

this关键字指代当前对象的引用，它在类的方法中用于访问当前对象的属性和方法。this在以下几种情况下非常有用：

• 解决方法参数与实例变量同名的冲突。
• 在构造方法中调用其他构造方法。

3.5 static 关键字 

核心概念

static关键字用于声明类级别的成员，意味着该成员属于类本身，而不是某个对象。静态变量和静态方法可以通过类名直接访问，而不需要实例化对象。

• 静态变量：类的所有对象共享同一个静态变量。
• 静态方法：可以通过类名调用静态方法，静态方法无法访问类的实例变量和实例方法。

示例代码:

class Counter {
    static int count = 0;  // 静态变量

    // 静态方法
    public static void increment() {
        count++;
    }

    public static void display() {
        System.out.println("Count: " + count);
    }
}

public class Main {
    public static void main(String[] args) {
        Counter.increment();
        Counter.display();  // 输出：Count: 1
        Counter.increment();
        Counter.display();  // 输出：Count: 2
    }
}

3.6 包

核心概念

包（Package）是Java中组织类和接口的机制。包有助于组织代码，避免命名冲突。Java中的包分为：

• 预定义包：如java.util，java.io等。
• 自定义包：用户定义的包，通常与项目的功能模块相对应。

示例代码：

// 在自定义包中定义一个类
package com.example;

public class Person {
    public String name;

    public Person(String name) {
        this.name = name;
    }

    public void greet() {
        System.out.println("Hello, " + name);
    }
}

// 在另一个类中使用自定义包
import com.example.Person;

public class Main {
    public static void main(String[] args) {
        Person person = new Person("Alice");
        person.greet();  // 输出：Hello, Alice
    }
}

总结

        Java的面向对象编程基础是每一个Java开发者必须掌握的核心内容，类、对象、封装、构造方法、this 和 static 等概念和技巧构成了Java程序设计的基石。通过不断的练习和实际应用，我们能够逐步掌握这些概念，并能够在实际开发中灵活运用。

第四章：Java面向对象程序设计（进阶）

4.1 封装（Encapsulation）

封装是面向对象程序设计的基本特性之一。它指的是将对象的状态（属性）和行为（方法）封装在一起，并隐藏对象的内部实现细节，只暴露出必要的接口，供外部调用。

示例代码：

public class Person {
    private String name;  // 私有属性，不能直接访问
    private int age;

    // 公共的 getter 和 setter 方法，提供访问权限
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age >= 0) {
            this.age = age;
        }
    }
}

4.2 继承（Inheritance）

继承是面向对象程序设计的另一个重要特性。它允许子类继承父类的属性和方法，进而增强代码的复用性。子类不仅可以继承父类的成员，还可以对其进行扩展或修改。 

示例代码：

// 父类
public class Animal {
    public void eat() {
        System.out.println("动物吃饭");
    }
}

// 子类
public class Dog extends Animal {
    public void bark() {
        System.out.println("狗叫");
    }
}

在上面的示例中，Dog 类继承了 Animal 类，并且能够使用 Animal 类中的 eat 方法，同时添加了自己的 bark 方法。

4.3 super关键字

super 关键字用于访问父类的构造方法、属性和方法。它可以在子类中调用父类的构造方法或方法，帮助解决继承中的一些问题。

示例代码：

class Animal {
    public Animal() {
        System.out.println("动物类的构造方法");
    }

    public void sound() {
        System.out.println("动物发出声音");
    }
}

class Dog extends Animal {
    public Dog() {
        super(); // 调用父类构造方法
        System.out.println("狗类的构造方法");
    }

    public void sound() {
        super.sound(); // 调用父类的方法
        System.out.println("狗叫");
    }
}

通过 super()，子类可以调用父类的构造方法；通过 super.method()，可以调用父类的实例方法。 

4.4 final关键字

final 关键字在 Java 中有多个用途：

• 用于定义常量；
• 用于修饰方法，表示该方法不能被重写；
• 用于修饰类，表示该类不能被继承。

示例代码：

// final类不能被继承
public final class FinalClass {
    // final方法不能被重写
    public final void finalMethod() {
        System.out.println("这是一个不能重写的方法");
    }
}

// final常量
public class TestFinal {
    public static final double PI = 3.14159;
}

在示例中，FinalClass 不能被继承，finalMethod 不能被重写，PI 被定义为常量。

4.5 Object类

Object 类是所有类的根类，它定义了 Java 中所有类都继承的方法。常见的方法包括 toString()、equals()、hashCode() 等。

示例代码：

public class Person {
    private String name;

    public Person(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "'}";
    }
}

public class TestObject {
    public static void main(String[] args) {
        Person person = new Person("Alice");
        System.out.println(person.toString());
    }
}

在上面的代码中，toString() 被重写，用来返回 Person 类的字符串表示。

4.6 多态（Polymorphism）

多态是面向对象编程的重要特性，它允许不同类的对象以相同的接口进行操作。通过多态，可以使得程序更加灵活和扩展性更强。多态通常表现为方法重载（compile-time polymorphism）和方法重写（runtime polymorphism）。

示例代码：

class Animal {
    public void makeSound() {
        System.out.println("动物发出声音");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("狗叫");
    }
}

class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("猫叫");
    }
}

public class TestPolymorphism {
    public static void main(String[] args) {
        Animal animal1 = new Dog();
        Animal animal2 = new Cat();

        animal1.makeSound(); // 输出：狗叫
        animal2.makeSound(); // 输出：猫叫
    }
}

通过多态，Animal 类型的变量 animal1 和 animal2 可以指向不同的子类对象，在运行时自动调用相应的 makeSound 方法。

4.7 抽象类（Abstract Class）

抽象类是不能被实例化的类，它只能作为其他类的父类。抽象类可以包含抽象方法和非抽象方法。抽象方法没有方法体，必须由子类实现。

示例代码：

abstract class Animal {
    public abstract void sound();  // 抽象方法

    public void breathe() {
        System.out.println("动物呼吸");
    }
}

class Dog extends Animal {
    @Override
    public void sound() {
        System.out.println("狗叫");
    }
}

在上面的代码中，Animal 类是一个抽象类，包含一个抽象方法 sound()，而 Dog 类实现了该方法。

4.8 接口（Interface）

接口是 Java 中一种特殊的类，它只包含抽象方法（从 Java 8 开始，可以包含默认方法和静态方法）。接口提供了一种规范，要求实现该接口的类必须实现接口中的所有抽象方法。

示例代码：

interface Animal {
    void sound(); // 接口中的抽象方法

    default void breathe() { // Java 8 引入的默认方法
        System.out.println("动物呼吸");
    }
}

class Dog implements Animal {
    @Override
    public void sound() {
        System.out.println("狗叫");
    }
}

通过 implements 关键字，Dog 类实现了 Animal 接口，必须提供 sound() 方法的实现。

4.9 内部类概述（Inner Class）

内部类是定义在另一个类中的类。Java 中的内部类有很多类型，包括成员内部类、静态内部类、局部内部类和匿名内部类。内部类可以访问外部类的成员，包括私有成员。

示例代码：

class Outer {
    private String message = "外部类的消息";

    class Inner {
        public void showMessage() {
            System.out.println(message);
        }
    }
}

public class TestInnerClass {
    public static void main(String[] args) {
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner();
        inner.showMessage();
    }
}

在上面的示例中，Inner 类是 Outer 类的一个成员内部类，能够访问 Outer 类的 message 成员。

总结

        Java 的面向对象编程（OOP）具有强大的功能，通过封装、继承、多态等机制，使得程序更加模块化、灵活和易于维护。在第四章的复习中，我们学习了封装、继承、super 和 final 关键字、多态、抽象类和接口等核心概念，它们是掌握 Java 编程语言的基础，也是写出高效、可维护代码的关键。通过实践和不断的学习，能够更好地理解这些概念，并将其应用到实际的编程中。

第五章：异常

5.1 异常概述

在Java中，异常是指程序在执行过程中出现的错误或不正常的情况。当异常发生时，Java会中断正常的控制流，转而寻找可以处理异常的代码路径。如果没有找到合适的处理方式，程序会终止运行。

5.1.1 异常的类型

Java中的异常主要分为两类：

• 编译时异常（Checked Exception）：这些异常必须显式地进行处理（例如通过try-catch语句块）。它们通常是可以预见并且可能会发生的异常，如文件未找到、网络连接问题等。

  常见的检查型异常：
  IOException, SQLException, ClassNotFoundException等。

• 运行时异常（Unchecked Exception）：这些异常通常由程序的逻辑错误导致，不需要强制捕获或声明。运行时异常一般是由程序员的失误引起的，如除零、数组越界等。

  常见的运行时异常：
  NullPointerException, ArrayIndexOutOfBoundsException, ArithmeticException等。

5.1.2 异常类体系结构

Java的异常类体系如下图所示：

Throwable
│
├── Error      (系统错误，通常不进行捕获)
└── Exception  (异常)
    ├── RuntimeException  (运行时异常)
    └── 非运行时异常（Checked Exception）

 其中，Throwable是所有错误和异常的基类，Exception类继承自Throwable，而RuntimeException类继承自Exception，因此运行时异常是检查型异常的一个子类。

5.2 异常处理

Java提供了专门的语法结构来处理异常，确保程序能够在遇到错误时采取适当的措施，而不是直接崩溃。异常处理的核心概念是try-catch语句。

5.2.1 try-catch语法

try {
    // 可能会抛出异常的代码块
} catch (ExceptionType e) {
    // 异常处理代码块
}

5.2.2 finally语句

finally语句块用于在异常发生与否的情况下，执行一些清理工作。无论try块是否抛出异常，finally块中的代码都会执行。

try {
    // 可能会抛出异常的代码
} catch (Exception e) {
    // 异常处理
} finally {
    // 无论是否发生异常都会执行的代码
}

示例代码：

public class FinallyDemo {
    public static void main(String[] args) {
        try {
            System.out.println("开始尝试打开文件");
            // 模拟可能抛出的异常
            int result = 10 / 0;
        } catch (ArithmeticException e) {
            System.out.println("捕获异常: " + e.getMessage());
        } finally {
            System.out.println("无论是否异常都会执行的代码");
        }
    }
}

输出：

开始尝试打开文件
捕获异常: / by zero
无论是否异常都会执行的代码

5.3 异常进阶

5.3.1 自定义异常

除了使用Java内建的异常类，Java还允许我们创建自己的异常类。自定义异常类通常继承自Exception或RuntimeException，可以根据程序需求抛出和捕获这些自定义异常。

// 自定义异常类
class InvalidAgeException extends Exception {
    public InvalidAgeException(String message) {
        super(message);
    }
}

// 使用自定义异常
public class CustomExceptionDemo {
    public static void main(String[] args) {
        try {
            int age = -5;
            if (age < 0) {
                throw new InvalidAgeException("年龄不能为负数！");
            }
        } catch (InvalidAgeException e) {
            System.out.println("错误: " + e.getMessage());
        }
    }
}

输出：

错误: 年龄不能为负数！

5.3.2 方法重写中的异常

       重写方法时的异常处理：子类重写的方法可以抛出父类方法声明抛出的异常类型或其子类型，以保持异常处理的一致性。
示例代码：

class ParentClass {
    public void someMethod() throws IOException {
        // Parent class method logic
    }
}
class ChildClass extends ParentClass {
    @Override
    public void someMethod() throws IOException {
        // Child class method logic
    }
}


                          

总结

       异常处理是Java程序设计中的一项重要技能，它能够帮助程序在遇到错误时避免崩溃，并且通过精确的错误处理逻辑改善用户体验。理解异常的类型（检查型异常和运行时异常）、掌握try-catch-finally语法结构、学习如何自定义异常类及异常链的概念，都是我们在学习Java面向对象程序设计时必须掌握的知识。 在编写程序时，合理地使用异常处理不仅能够增强程序的健壮性和可维护性，还能够提高代码的可读性和错误处理的精确度。

第六章：Java常用类

6.1 包装类（Wrapper Classes）

在Java中，基本数据类型（如int, char, boolean等）与对象之间的转换通常通过包装类来实现。包装类的作用是将基本数据类型转换为对象，并为基本数据类型提供一些附加的功能。

核心概念

• 每个基本数据类型都有对应的包装类：

  • int → Integer
  • char → Character
  • boolean → Boolean
  • double → Double
  • float → Float
  • long → Long
  • short → Short
  • byte → Byte

• 包装类提供了：

  • 类型转换方法（如intValue(), doubleValue()等）
  • 常用常量（如Integer.MAX_VALUE, Double.NaN等）
  • 静态方法（如parseInt(), valueOf()等）

示例代码：

public class WrapperExample {
    public static void main(String[] args) {
        // 自动装箱
        Integer num = 10; 
        // 拆箱
        int value = num;  
        System.out.println("原始数值：" + value);
        
        // 使用包装类的方法
        int parsedValue = Integer.parseInt("123");
        System.out.println("字符串转数字：" + parsedValue);
    }
}

6.2 String类概述

String类是Java中用于表示字符串的类，它是不可变的（immutable）。这意味着一旦创建了一个String对象，它的内容就不能被改变。

核心概念

• String是一个特殊的类，可以直接用字符串字面量初始化。
• 字符串的拼接使用+运算符，但推荐使用StringBuilder或StringBuffer来处理大量字符串拼接，以提高性能。
• String类常用方法：
  • length()：返回字符串的长度。
  • charAt()：返回指定位置的字符。
  • substring()：截取字符串。
  • equals()：比较两个字符串是否相等。

示例代码：

public class StringExample {
    public static void main(String[] args) {
        String str = "Hello, Java!";
        System.out.println("字符串长度：" + str.length());
        System.out.println("第三个字符：" + str.charAt(2));
        System.out.println("子字符串：" + str.substring(7, 11));
        System.out.println("字符串比较：" + str.equals("hello, java!")); // false
    }
}

6.3 StringBuffer类与StringBuilder类

StringBuffer和StringBuilder类都用于处理可变的字符序列，相较于String，它们在处理大量字符串拼接时性能更高。

核心概念

• StringBuffer和StringBuilder都可以动态地添加、删除和修改字符，且不会创建新的对象。
• 区别：StringBuffer是线程安全的，而StringBuilder是非线程安全的，因此StringBuilder的性能略优。

示例代码：

public class StringBufferBuilderExample {
    public static void main(String[] args) {
        // StringBuffer示例
        StringBuffer buffer = new StringBuffer("Hello");
        buffer.append(", World!");
        System.out.println(buffer.toString());
        
        // StringBuilder示例
        StringBuilder builder = new StringBuilder("Java");
        builder.append(" Programming");
        System.out.println(builder.toString());
    }
}

6.4 时间和日期相关类

Java提供了一些类来处理时间和日期，其中包括Date、Calendar和Java 8引入的java.time包。特别是java.time包包含了更加灵活和强大的时间操作类。

核心概念

• Date类表示特定的时间点，已经过时，推荐使用Calendar或java.time包。
• Calendar类是Date的更高层次封装，提供了操作日期的方法。
• Java 8开始，推荐使用java.time包，它是更现代和功能强大的时间API。

示例代码：

import java.time.LocalDate;
import java.time.LocalTime;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

public class DateTimeExample {
    public static void main(String[] args) {
        // 获取当前日期和时间
        LocalDate today = LocalDate.now();
        LocalTime now = LocalTime.now();
        LocalDateTime currentDateTime = LocalDateTime.now();
        
        // 格式化日期时间
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String formattedDate = currentDateTime.format(formatter);
        
        System.out.println("当前日期：" + today);
        System.out.println("当前时间：" + now);
        System.out.println("当前日期和时间：" + formattedDate);
    }
}

6.5. 其他常用类

6.5.1 Math类

Math类包含了许多常用的数学操作方法，所有的方法都是静态的。

核心概念

• Math类提供了常见的数学计算功能，如：sqrt()、pow()、abs()、max()、min()等。

示例代码：

public class MathExample {
    public static void main(String[] args) {
        System.out.println("平方根：" + Math.sqrt(25));
        System.out.println("最大值：" + Math.max(10, 20));
        System.out.println("绝对值：" + Math.abs(-15));
    }
}

6.5.2 Random类

Random类用于生成伪随机数，支持生成各种类型的随机数（如整数、浮点数等）。

核心概念

• nextInt()：生成一个随机的整数。
• nextDouble()：生成一个随机的浮点数。

示例代码:

import java.util.Random;

public class RandomExample {
    public static void main(String[] args) {
        Random rand = new Random();
        System.out.println("随机整数：" + rand.nextInt(100)); // 0到99之间的随机整数
        System.out.println("随机浮点数：" + rand.nextDouble());
    }
}

6.5.3 UUID类

UUID类用于生成全球唯一标识符（UUID）。

核心概念

• UUID.randomUUID()方法生成一个随机的UUID。

示例代码:

import java.util.UUID;

public class UUIDExample {
    public static void main(String[] args) {
        UUID uuid = UUID.randomUUID();
        System.out.println("生成的UUID：" + uuid);
    }
}

6.5.4 枚举类（Enum）

enum是Java中一种特殊的类，用于表示一组常量。

核心概念

• enum类是一个固定的常量集合，每个常量是枚举类型的一个实例。
• 可以为枚举添加字段、构造方法和方法。

示例代码:

enum Day {
    SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY
}

public class EnumExample {
    public static void main(String[] args) {
        Day today = Day.MONDAY;
        System.out.println("今天是：" + today);
    }
}

总结

       通过学习Java常用类，第六章为我们提供了许多强大而实用的工具类，使得我们可以在日常编程中更加高效地处理各种常见任务。无论是基本数据类型的包装类，还是处理字符串的类、日期时间的类，亦或是数学运算和生成随机数的类，它们都为我们提供了丰富的功能，帮助我们更加便捷地完成任务。

       掌握这些常用类的使用，不仅能提升我们的编程能力，还能让我们的代码更加简洁、易读。在实际开发中，我们应根据需求灵活选择合适的类，从而提高开发效率和代码质量。