Java（六）声明，this关键字，using objects, overloading方法重载，overriding，initialize blocks，enum

lin-*_*

已于 2023-10-31 07:32:28 修改

阅读量82

点赞数

分类专栏： java 文章标签： java 开发语言

于 2023-10-25 19:39:56 首次发布

本文链接：https://blog.csdn.net/m0_47261113/article/details/134041437

版权

java 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

文章目录

一. Class Declaration 类声明
二. class member declarations 类成员声明
三. this关键字
四. using objects
五. overloading方法重载
六. Overriding
七. Hiding methods
八. Initializer Blocks
- 1. 实例初始化块（Instance Initialization Block）
- 2. 静态初始化块（Static Initialization Block）
九. Enum types

一. Class Declaration 类声明

类声明（Class Declaration）是面向对象编程中的关键概念，用于定义类的结构和特征。在 Java 中，类声明是创建类的基础。

1. 类的定义

类声明是用来定义类的结构的。一个类是一种抽象的数据类型，它可以包括数据成员（字段或属性）和方法成员。类定义通常以关键字 class 开始，然后是类的名称和类体，类体通常包括类的成员变量和方法。

类名首字母大写
declaring classes_oracle

public class MyClass {
    // 成员变量（属性）
    int myField;

    // 方法
    void myMethod() {
        // 方法的实现
    }
}

2.访问修饰符 modifiers

类声明可以包括访问修饰符，用于指定类的可见性。常用的访问修饰符包括 public、private、protected 和默认（无修饰符）。这些修饰符决定了类的可见性和访问级别。

在 Java 中，修饰符（Modifiers）用于修改类、变量、方法和其他程序元素的访问级别、性质和行为。修饰符充当了代码中的元数据，以控制对程序元素的访问和行为。

（1）访问修饰符

public: 公共访问级别，可以被任何类访问。
private: 私有访问级别，只能在声明它们的类内部访问。
protected: 受保护的访问级别，可以在同一包内的类和子类中访问。
默认（无修饰符）：包级别的访问，只能在同一包内的类中访问。

public class MyClass {
    public int publicField;
    private int privateField;
    protected int protectedField;
    int defaultField;
}

（2）静态修饰符 (static)

static 修饰符用于创建静态成员，这些成员属于类本身，而不是类的实例。
静态成员可以通过类名直接访问，而不需要创建类的实例。

public class MyClass {
    static int staticField;
    static void staticMethod() {
        // 静态方法的实现
    }
}

（3）终态修饰符 (final)

final 修饰符用于表示一个类、变量或方法是不可改变的。

对于类，final 表示类不能被继承。
对于变量，final 表示变量的值不可更改。
对于方法，final 表示方法不能被子类重写。

public final class MyFinalClass {
    final int finalField = 10;
    final void finalMethod() {
        // 方法的实现
    }
}

（4）抽象修饰符 (abstract)

abstract 修饰符用于表示一个类或方法是抽象的，不能被实例化或需要在子类中重写。
抽象类不能实例化，通常用作基类，包含抽象方法，需要在子类中实现。
抽象方法没有方法体，需要在子类中提供具体实现。

public abstract class MyAbstractClass {
    abstract void abstractMethod();
}

【（5）同步修饰符 (synchronized)】

synchronized 修饰符用于实现多线程同步，确保在多个线程之间正确地访问共享资源。
可以用于方法或代码块，并需要一个对象作为锁。

public synchronized void synchronizedMethod() {
    // 同步方法的实现
}

3.构造方法 Constructors

类可以包括构造方法，用于对象的初始化。构造方法的名称与类名相同 the same name as the class，不返回任何值 no return type。
一个类可以有多个构造方法，它们可以根据参数列表的不同来重载。这使得可以在创建对象时传递不同的参数来满足不同的需求。
A constructor is a special method that is automatically executed when an instance is created.
construtors_oracle

public class MyClass {
    int myField;

    // 构造方法
    public MyClass() {
        myField = 0;
    }
}

4.继承和实现接口

类声明可以包括继承另一个类或实现一个或多个接口。继承是通过 extends 关键字（一对一）实现的，而接口（可以一对多）的实现是通过 implements 关键字实现的。

public class SubClass extends SuperClass {
    // 子类继承父类
}

public class MyClass implements MyInterface1，MyInterface2 {
    // 类实现接口
}

接口

接口的概念：接口是一种抽象的类，它只包含方法的签名（方法名、参数和返回类型），没有方法的实现。类通过实现接口来承诺实现接口中定义的方法。
接口用于描述类应该具有哪些方法，但不涉及这些方法的具体细节。

// 定义一个接口
interface Shape {
    double getArea(); // 定义一个抽象方法，返回形状的面积
    double getPerimeter(); // 定义另一个抽象方法，返回形状的周长
}

// 实现接口的类
class Circle implements Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }

    @Override
    public double getPerimeter() {
        return 2 * Math.PI * radius;
    }
}

class Rectangle implements Shape {
    private double width;
    private double height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    @Override
    public double getArea() {
        return width * height;
    }

    @Override
    public double getPerimeter() {
        return 2 * (width + height);
    }
}
/*
在上面的示例中，我们定义了一个名为 Shape 的接口，其中包含两个抽象方法：getArea() 和 getPerimeter()。
然后，我们创建了两个类 Circle 和 Rectangle，它们都实现了 Shape 接口。
每个实现接口的类都必须提供这两个抽象方法的具体实现。
例如，Circle 类提供了计算圆形面积和周长的具体方法，而 Rectangle 类提供了矩形的面积和周长的具体实现。
*/

接口允许我们定义一组方法，以确保具体类具有这些方法，但不关心方法的实际实现细节。这有助于实现代码的模块化和多态性，使代码更易于维护和扩展。

5.静态成员

类可以包括静态成员，这些成员属于类本身，而不是类的实例。静态成员使用 static 关键字修饰。

（1）静态字段（Static Fields）

静态字段是与类关联的属性，而不是与类的实例关联的属性。它们在类的所有实例之间共享相同的值。静态字段通常用于存储与整个类相关的信息，例如计数器或常量。

（2）静态方法（Static Methods）

静态方法是不依赖于类的实例的方法。它们可以直接通过类名调用，而不需要创建类的实例。静态方法通常用于执行与整个类相关的操作，而不需要访问实例特定的数据。

public class MyClass {
    static int staticField;//静态字段，它属于类 MyClass，而不是类的实例。

    // 静态方法
    static void staticMethod() {
        public static int add(int a, int b) {
        	return a + b;
    	}// 静态方法的实现
    	//add 是一个静态方法，它可以通过类名 staticMethod.add(3, 5) 直接调用。
    }
}

（3）访问静态成员

可以通过类名来访问静态字段和静态方法，也可以通过类的实例来访问静态字段，但不推荐这样做。

int x = MyClass.count; // 通过类名访问静态字段
int y = new MyClass().count; // 通过类的实例访问静态字段（不推荐）

int result = staticMethod.add(3, 5); // 调用静态方法

（4）静态块（Static Blocks）

静态块是用于初始化静态字段的代码块。它在类加载时执行，并且仅执行一次。静态块通常用于执行一些初始化操作，例如加载配置文件或建立数据库连接

public class AppConfig {
    static {
        // 初始化代码
    }
}

静态成员在许多情况下非常有用，例如用于创建单例模式、实现工具类、在不创建实例的情况下执行操作等。然而，需要谨慎使用静态成员，因为它们具有全局性，可能会导致并发和维护问题。

类声明是面向对象编程的核心，它定义了类的属性和方法，允许创建类的实例并使用类的功能。合理的类设计和声明是编程中的重要方面，它影响代码的可维护性和可扩展性。

二. class member declarations 类成员声明

类成员声明是用于定义类的成员（字段和方法）的语法。
oracle

1. 字段成员声明

字段成员是类的属性，用于存储对象的状态信息。字段成员的声明通常包括数据类型、访问修饰符和名称。
数据类型：指定了字段成员可以存储的数据类型，如整数、字符串、布尔值等。
访问修饰符：控制了字段成员的可见性和访问权限，常见的修饰符包括 public、private、protected 和默认（包级别）等。
名称：字段成员的名称用于标识和访问该成员。

public class MyClass {
    // 字段成员声明
    public int age; // 公共字段成员
    private String name; // 私有字段成员
}

2.方法成员声明

方法成员是类的函数，用于定义对象的行为和功能。方法成员的声明包括返回类型、方法名、参数列表和方法体。
返回类型：指定了方法成员的返回值类型，可以是整数、字符串、对象等。
方法名：方法成员的名称，用于调用和标识该方法。
参数列表：指定了方法接受的参数，包括参数的数据类型和名称。
方法体：包含了方法的实际实现代码。

public class MyClass {
    // 方法成员声明
    public void greet(String name) {
        System.out.println("Hello, " + name + "!");
    }
}

3.其他成员声明

除了字段和方法，Java中还支持其他类型的成员声明，如构造方法、嵌套类、枚举、接口等。
构造方法用于对象的初始化，嵌套类用于定义类内部的类，枚举用于定义一组常量，接口用于定义抽象方法集合。

public class MyClass {
    // 构造方法声明
    public MyClass() {
        // 构造方法体
    }
}

类成员声明是类定义的核心部分，它定义了类的属性和行为。字段成员用于存储对象的状态信息，而方法成员用于描述对象的行为。通过成员声明，您可以创建具有不同属性和行为的类，并通过实例化对象来使用它们。访问修饰符和其他修饰符用于控制类成员的可见性和行为。

三. this关键字

Within instance methods and constructors, the this keyword refers to the object whose or constructor is being called.
在Java中，this 是一个关键字，用于引用当前对象的实例。它通常用于解决在类中成员变量（字段）和方法参数之间的名称冲突，以便明确指示正在操作的是对象的字段还是方法参数。
this_oracle

1. 引用当前对象

当一个对象实例化后，它在内存中有自己的一组成员变量（字段）和方法。在方法内部，您可以使用 this 来引用当前对象的实例。这使得您可以访问对象的字段和方法。
引用的是类的实例属性而不是局部变量。

2.解决名称冲突 disambiguating field names from parameters

在类的方法中，如果存在与成员变量同名的方法参数或局部变量，编译器无法区分两者。这时，可以使用 this 来明确指示您要操作的是对象的成员变量。这消除了名称冲突。

public class MyClass {
    private int value; // 成员变量

    public MyClass(int value) {
        // 使用this来引用成员变量和方法参数
        this.value = value; // "this.value"表示成员变量，"value"表示方法参数
    }

    public void printValue() {
        System.out.println("Value: " + this.value); // 使用this来引用成员变量
    }
}

3. 在构造方法中

在构造方法中，this 可以用于调用其他构造方法（构造方法重载）calling other construtors。这使得可以在不同的构造方法中共享相同的初始化代码。

public class MyClass {
    private int value;

    public MyClass() {
        this(0); // 调用另一个构造方法
    }

    public MyClass(int value) {
        this.value = value;
    }
}

4. 链式调用

this 还可以用于支持链式方法调用。通过在每个方法调用后返回 this，可以连续调用多个方法。

 public class MyClass {
    private int value;

    public MyClass setValue(int value) {
        this.value = value;
        return this;
    }

    public int getValue() {
        return this.value;
    }
}

// 链式方法调用
MyClass obj = new MyClass().setValue(42);
int val = obj.getValue(); // 返回42

四. using objects

在Java中使用对象意味着利用已创建的对象实例来执行特定的任务、操作或访问对象的成员（字段和方法）。
oracle

Outside a class

an object reference followed by the dot ‘.’ operator must be used:

1. 访问成员变量

您可以使用对象来访问其成员变量（字段），并读取或修改它们的值。

MyClass obj = new MyClass(); // 创建对象
obj.value = 42; // 设置对象的成员变量
int val = obj.value; // 读取对象的成员变量

2. 调用方法

对象的方法是其行为的定义。使用对象来调用方法，执行方法内的代码。

MyClass obj = new MyClass(); // 创建对象
obj.printValue(); // 调用对象的方法

3. 传递参数

您可以将对象作为参数传递给方法，以便方法可以操作特定对象的数据。

public void processObject(MyClass obj) {
    obj.value = 100; // 修改对象的成员变量
    obj.printValue(); // 调用对象的方法
}

MyClass obj = new MyClass(); // 创建对象
processObject(obj); // 传递对象作为参数

4. 返回对象

方法可以返回对象，允许您使用返回的对象来执行后续操作。

public MyClass createObject() {
    MyClass obj = new MyClass(); // 创建对象
    obj.value = 50; // 设置对象的成员变量
    return obj; // 返回对象
}

MyClass newObj = createObject(); // 调用方法并获取返回的对象
int val = newObj.value; // 读取对象的成员变量

5. 操作多个对象

您可以创建多个对象，并使用它们来执行不同的操作。每个对象独立存储其状态和数据。

MyClass obj1 = new MyClass();
MyClass obj2 = new MyClass();

obj1.value = 10;
obj2.value = 20;

int val1 = obj1.value;
int val2 = obj2.value;

6. 引用其他对象

在Java中，您可以使用对象引用来引用其他对象，这允许您操作多个对象，将一个对象的引用分配给另一个对象。

MyClass obj1 = new MyClass();
MyClass obj2 = obj1; // 将obj2引用分配给obj1

obj2.value = 30; // 修改obj2的成员变量，也会影响obj1
int val = obj1.value; // 读取obj1的成员变量

Within instance methods

the object’s fields and methods can be accessed directly by name, (optionally with the this keyword)

1. fieldName or methodName()

2. this.fieldName or this.methodName()

五. overloading方法重载

方法重载（Method Overloading）是Java中的一个重要概念，它允许在同一个类中定义多个方法，这些方法具有相同的名称但具有不同的参数列表return different arguments(number, type, order)。

方法重载通过参数的数量、类型或顺序的不同来区分方法。
You can overload constructor.
体现了多态性compile-time polymorphism

1. 方法签名

方法的签名由方法的名称和参数列表组成。方法重载要求方法名称相同，但参数列表必须不同。

2. 不同的参数列表

在方法重载中，参数列表必须有所区别。这可以通过以下方式实现：

参数数量不同。
参数类型不同。
参数类型的顺序不同。

public class Calculator {
    // 方法重载：参数数量不同
    public int add(int a, int b) {
        return a + b;
    }

    public double add(double a, double b) {
        return a + b;
    }

    // 方法重载：参数类型不同
    public int multiply(int a, int b) {
        return a * b;
    }

    public double multiply(double a, double b) {
        return a * b;
    }

    // 方法重载：参数类型顺序不同
    public int subtract(int a, int b) {
        return a - b;
    }

    public int subtract(double a, int b) {
        return (int) (a - b);
    }
}

3. 编译器决定

在调用重载的方法时，编译器会根据提供的参数来确定应该调用哪个方法。编译器会匹配最接近的方法签名。

Calculator calc = new Calculator();
int result1 = calc.add(5, 10); // 调用第一个add方法
double result2 = calc.add(5.5, 10.2); // 调用第二个add方法

4. 返回类型不是方法签名的一部分

方法重载的关键是参数列表，而不是返回类型。重载的方法可以具有不同的返回类型，只要参数列表不同。

public int process(int value) {
    return value * 2;
}

public double process(int value) {
    return value * 2.0;
}

5. 方法重载的优点

方法重载允许您使用相同的方法名称来处理不同类型的数据，从而使代码更具灵活性和可读性。它提供了重用方法名称的机会，而不必为每种情况创建不同的方法名称。

方法重载是Java编程语言中的一个强大功能，它可以提高代码的清晰度和可维护性，并使您能够以一种更自然的方式处理不同的情况。

六. Overriding

覆盖（Override）是指在子类中重新定义（实现）从父类继承的方法，以满足子类的特定需求。
在Java中，覆盖方法必须具有与父类方法相同的名称、参数列表和返回类型。
覆盖方法提供了新的实现，覆盖了父类中的方法，从而使子类能够自定义其行为。
在运行时，调用被覆盖的方法时，实际执行的是子类中的方法，这体现了多态性。

1. 概念

（1）方法签名匹配

在子类中覆盖方法时，必须确保方法签名与父类中的方法完全匹配。方法签名包括方法的名称、参数列表和返回类型。如果子类方法的签名与父类方法不匹配，编译器将报错。

（2） @Override 注解

为了明确指示你的意图是要覆盖父类方法，可以使用 @Override 注解。这个注解有助于提高代码的可读性，并确保你没有意外地创建了一个新的方法而不是覆盖父类的方法。

（3）访问权限不可降低

在子类中覆盖方法时，访问权限不能低于父类中的方法。例如，如果父类的方法是公共的（public），那么子类中覆盖的方法也必须是公共的。

（4）抛出的异常不能更多

在子类中覆盖方法时，不允许抛出比父类方法更多的异常。如果父类方法没有声明异常，那么子类覆盖的方法也不能声明异常。如果父类方法声明了异常，子类覆盖的方法可以声明相同的异常，但不能声明更多的异常。

（5）方法的返回类型

子类覆盖的方法可以返回与父类方法相同的类型或其子类型。这被称为协变返回类型。

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

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

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

public class Main {
    public static void main(String[] args) {
        Animal myPet = new Dog();
        //这行代码演示了Java中的多态性（Polymorphism）和方法覆盖（Method Overriding）的概念。
        myPet.makeSound(); // 调用Dog类的makeSound方法，覆盖了父类的方法
    }
}

“Overriding” 用于覆盖父类的实例方法，体现多态性，子类提供新的实现。

2. 类型

（1）Instance Methods（实例方法）

实例方法是与对象实例相关联的方法，每个对象都可以有自己的实例方法调用。
在覆盖实例方法时，子类提供了对从父类继承的实例方法的新实现。
覆盖实例方法要求子类方法具有与父类方法相同的名称、参数列表和返回类型。
子类可以提供自己的实现，从而定制方法的行为。

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

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

（2）Class Methods（类方法）

类方法是与类本身相关联的方法，而不是与对象实例相关。它们使用关键字 static 声明。
在覆盖类方法时，子类可以提供自己的实现，但不会覆盖父类的类方法。这是因为类方法是与类相关的，而不是对象实例相关的。

class Parent {
    static void sayHello() {
        System.out.println("父类说：Hello");
    }
}

class Child extends Parent {
    static void sayHello() {
        System.out.println("子类说：Hello");
    }
}

“Overriding” 适用于实例方法，子类可以覆盖父类的实例方法，并提供新的实现。
类方法（使用 static 关键字声明的方法）不能被覆盖，子类可以提供新的类方法，但不会影响父类的类方法。

3. overloading & overriding

“Overriding” 是针对继承关系中的方法，子类重写父类的方法，关注的是相同方法名和参数列表。
“Overloading” 是在同一个类中的方法多态性，通过不同的参数来定义多个方法，关注的是相同方法名但不同的参数。

七. Hiding methods

Hiding 是在子类中重新定义静态方法（被 static 修饰）的概念。
隐藏方法在子类中也必须具有与父类中被隐藏的方法相同的名称和参数列表，但隐藏方法不需要与父类方法具有相同的返回类型。
隐藏方法提供了新的静态实现，它与父类中的静态方法没有多态性关系，只是将父类方法的实现替换为子类方法的实现。

class Parent {
    static void sayHello() {
        System.out.println("父类说：Hello");
    }
}

class Child extends Parent {
    static void sayHello() {
        System.out.println("子类说：Hello");
    }
}

public class Main {
    public static void main(String[] args) {
        Parent.sayHello(); // 调用父类的静态方法
        Child.sayHello();  // 调用子类的静态方法，隐藏了父类的方法
    }
}

“Hiding” 用于隐藏父类的静态方法，不体现多态性，只是提供新的静态实现。

八. Initializer Blocks

在Java中，初始化块（Initializer Blocks）是用于执行类初始化的一种机制。Java有两种类型的初始化块：实例初始化块和静态初始化块。
oracle

1. 实例初始化块（Instance Initialization Block）

实例初始化块用于初始化实例变量。它在创建类的对象实例时执行，并在构造函数之前运行。实例初始化块不包含static关键字，因此它属于类的实例。以下是一个实例初始化块的示例：

public class MyClass {
    int instanceVariable;

    {
        // 实例初始化块
        instanceVariable = 10;
    }

    public MyClass() {
        // 构造函数
        instanceVariable = 20;
    }
}

2. 静态初始化块（Static Initialization Block）

静态初始化块用于初始化静态变量。它在类加载时执行，仅执行一次，因此适用于类级别的初始化。静态初始化块包含static关键字。以下是一个静态初始化块的示例：

public class MyClass {
    static int staticVariable;

    static {
        // 静态初始化块
        staticVariable = 30;
    }
}

九. Enum types

在Java中，枚举类型（Enum types）是一种特殊的数据类型，它定义了一组有限的常量值，通常用于表示一组相关的常量。枚举类型在编程中非常有用，因为它们可以提供更多的类型安全性和可读性。
An enumerated type is defined with the enum keyword.
oracle
practice

1. 定义枚举类型

枚举类型使用enum关键字定义。

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

2. 访问枚举常量

枚举常量可以通过枚举类型的名称和.运算符进行访问。

Day today = Day.MONDAY;

3. Switch语句中的枚举

枚举类型特别适用于switch语句，因为它们可以帮助在代码中处理一组特定的常量值。

switch (today) {
    case MONDAY:
        System.out.println("It's Monday!");
        break;
    case TUESDAY:
        System.out.println("It's Tuesday!");
        break;
}

4. 自定义枚举属性和方法

您可以为枚举类型添加属性和方法。例如，您可以为每个枚举常量添加属性，也可以为枚举类型添加方法。这使得枚举类型更加灵活。

public enum Season {
    SPRING("Warm"), SUMMER("Hot"), FALL("Cool"), WINTER("Cold");

    private String description;

    Season(String description) {
        this.description = description;
    }

    public String getDescription() {
        return description;
    }
}

分类

（1）may have other fields

枚举类型的定义可能包括其他属性或字段。在Java中，枚举常量通常仅表示一组已知的命名值，但您也可以将额外的数据与每个枚举常量相关联。这些额外的数据被定义为枚举类型的字段或属性。

enum Day {
    MONDAY("Start of the workweek", 1),
    TUESDAY("Second day of the workweek", 2),
    // ...
    
    private String description;
    private int dayNumber;
    
    Day(String description, int dayNumber) {
        this.description = description;
        this.dayNumber = dayNumber;
    }

    public String getDescription() {
        return description;
    }
    
    public int getDayNumber() {
        return dayNumber;
    }
}
//在这个示例中，Day 枚举类型包含两个附加的字段：description 和 dayNumber。
//每个枚举常量都在构造函数中初始化这些字段。这使得每个枚举常量能够存储与它们相关的描述信息和数字。

（2）may have methods

枚举类型可以包含方法。枚举类型中的每个常量可以具有自己的方法，这些方法可以用于执行与该枚举常量相关的操作。这使得枚举类型可以更灵活地处理不同常量之间的逻辑。

enum TrafficLight {
    RED, YELLOW, GREEN;

    public void startFlashing() {
        if (this == RED) {
            System.out.println("Red light is flashing!");
        } else {
            System.out.println("No flashing for " + this);
        }
    }
}

（3）may use constructors

可以为枚举类型定义构造函数。这允许您为枚举常量提供初始化数据，以便更灵活地创建和初始化它们。

enum Season {
    SPRING("Mild"), SUMMER("Hot"), AUTUMN("Cool"), WINTER("Cold");

    private String description;

    Season(String description) {
        this.description = description;
    }

    public String getDescription() {
        return description;
    }
}
//在这个示例中，Season 枚举类型具有一个带有参数的构造函数，用于为每个季节常量设置描述信息。
//这使得每个季节常量都可以包含与季节相关的描述信息。
//通过使用构造函数，可以将额外的数据传递给枚举常量，以便在初始化时进行个性化设置。

（4）can be used as argument to iterators

use static values() method)

枚举类型可以通过静态的 values() 方法获取包含所有枚举常量的数组，并将该数组用作迭代器的参数。

Java 的枚举类型自动具有名为 values() 的静态方法，该方法返回一个包含所有枚举常量的数组。这意味着可以轻松地使用 values() 方法获取枚举类型中的所有常量，然后遍历它们。

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

public class EnumIterationExample {
    public static void main(String[] args) {
        // 获取 Day 枚举类型的所有常量
        Day[] days = Day.values();

        // 使用迭代器遍历枚举常量
        for (Day day : days) {
            System.out.println(day);
        }
    }
}

调用

（1）调用枚举常量

假设你有一个名为 Day 的枚举类型，其中包含了一些常量，如 SUNDAY, MONDAY, 等等。你可以直接通过枚举类型的名称和常量名来引用它们。

Day today = Day.MONDAY; // 定义一个枚举常量
System.out.println("Today is " + today); // 输出 "Today is MONDAY"

（2）访问枚举字段

如果枚举类型包含了额外的字段（例如前面示例中的 mass 和 radius），你可以使用常量的名称来访问这些字段。

Planet earth = Planet.EARTH;
double mass = earth.getMass();
double radius = earth.getRadius();
System.out.println("Earth's mass is " + mass + " kg");
System.out.println("Earth's radius is " + radius + " meters");

（3）调用枚举方法

如果枚举类型包含了方法（例如前面示例中的 printInfo()），你可以使用常量的名称调用这些方法。

Color red = Color.RED;
red.printInfo(); // 输出 "This is a color: RED"