👏🏻 你好！欢迎访问IT教程网，0门教程，教程全部原创，计算机教程大全，全免费！

🔥 新增教程

《黑神话 悟空》游戏开发教程，共40节，完全免费，点击学习

《AI副业教程》，完全原创教程，点击学习

发表更新编程 / Java小白6 分钟读完 (大约954个字)

25 面向对象编程基础之类和对象的基本概念

在本章中，我们将探讨 Java 语言的面向对象编程（OOP）基础，其中重点介绍 类 和 对象 的基本概念。这些概念是学习面向对象编程的基石，理解它们对于后续的学习尤为重要。

1. 类的定义

在 Java 中，类 是一种模拟现实世界事物的蓝图或模板。通过类，我们可以定义对象的属性和行为。类中包含的数据被称为属性（或成员变量），而类中的方法被称为行为（或成员方法）。

示例：定义一个简单的类

1
2
3
4
5
6
7
8
9
10
public class Dog {
    // 属性
    String name;
    int age;

    // 行为
    void bark() {
        System.out.println(name + " says: Woof!");
    }
}

在上面的例子中，Dog 类定义了两个属性：name 和 age，以及一个行为：bark 方法。这是一个简单的类定义，展示了如何使用类来表示一个事物——在这里是狗。

2. 对象的概念

对象 是类的具体实例。通过类的构造，我们可以创建任意数量的对象，而每个对象都有自己独特的属性值。对象由类定义，但是对象本身包含具体的数据。

示例：创建对象

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Main {
    public static void main(String[] args) {
        // 创建 Dog 类的对象
        Dog myDog = new Dog();
        
        // 为对象的属性赋值
        myDog.name = "Buddy";
        myDog.age = 3;

        // 调用对象的方法
        myDog.bark(); // 输出: Buddy says: Woof!
    }
}

在这个示例中，我们通过 new 关键词创建了一个 Dog 类的对象 myDog。然后我们给这个对象的属性 name 和 age 赋值，并调用了 bark 方法。

3. 类与对象的关系

在面向对象编程中，类是对对象的抽象，而对象是类的具体体现。每个对象都有从类中获得的属性和行为，但具体的属性值可能不同，这使得每个对象都是独特的。

  • 类是模板，而对象是基于模板创建的实例。
  • 类定义了对象可以拥有的数据和可以执行的操作。

4. 封装

封装 是面向对象编程中的一个重要概念，指将数据（属性）和操作（方法）封装在一个类中，并提供访问控制，以保护这些数据。通常，我们会将类的属性设为private，并通过public方法进行访问。

示例：封装

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class Person {
    // 私有属性
    private String name;
    private int age;

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

    // 公共方法获取属性值
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

通过上面的示例，Person 类的属性 name 和 age 是私有的（private），外部代码无法直接访问它们。我们提供了 getName 和 getAge 方法来获取这些属性的值，从而实现了封装。

创建对象并访问属性

1
2
3
4
5
6
7
8
public class Main {
    public static void main(String[] args) {
        Person person = new Person("Alice", 30);
        
        System.out.println("Name: " + person.getName()); // 输出: Name: Alice
        System.out.println("Age: " + person.getAge());   // 输出: Age: 30
    }
}

5. 小结

在本章中，我们介绍了 类 和 对象 的基本概念，理解了它们的定义和使用方法。我们还认识了 封装 这一概念，了解了如何保护数据并提供安全的访问方式。

通过学习类和对象，我们将为后续深入研究面向对象编程的其他特性做好准备，如继承和多态等。在下一章中，我们将详细介绍 构造方法 的使用，继续扩展我们的知识基础。

分享转发

发表更新编程 / Java小白7 分钟读完 (大约1060个字)

26 面向对象编程基础之构造方法

在上一章中，我们介绍了类和对象的基本概念。在本章中，我们将探讨构造方法，它们在对象创建过程中扮演着重要的角色。构造方法不仅用于初始化对象的状态，还能为对象的创建提供必要的逻辑。

1. 什么是构造方法

构造方法是一种特殊的方法，用于创建类的实例（即对象）。它有几个显著的特点：

  • 名称与类名相同：构造方法的名称必须与类的名称完全相同。
  • 没有返回值：构造方法不返回任何类型，包括void。
  • 可以重载：构造方法可以被重载，即同一个类中可以定义多个构造方法，参数列表不同即可。

构造方法的作用主要在于初始化对象的属性及执行必要的启动逻辑。

2. 构造方法的基本语法

构造方法的基本语法和普通方法相似。例如，以下是一个简单的Person类及其构造方法的示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class Person {
    private String name;
    private int age;

    // 无参数构造方法
    public Person() {
        this.name = "unknown"; // 默认值
        this.age = 0;          // 默认值
    }

    // 带参数的构造方法
    public Person(String name, int age) {
        this.name = name;      // 初始化 name
        this.age = age;        // 初始化 age
    }

    // 打印个人信息的方法
    public void display() {
        System.out.println("Name: " + this.name + ", Age: " + this.age);
    }
}

在上面的Person类中，我们定义了两个构造方法：

  • 无参数构造方法 Person()：创建一个Person对象时，如果没有提供任何参数，将使用默认值。
  • 带参数的构造方法 Person(String name, int age)：允许在创建对象时直接指定name和age的值。

3. 使用构造方法创建对象

接下来，我们将看看如何使用这些构造方法来创建Person对象。

1
2
3
4
5
6
7
8
9
10
11
public class Main {
    public static void main(String[] args) {
        // 使用无参数构造方法
        Person person1 = new Person();
        person1.display(); // 输出: Name: unknown, Age: 0

        // 使用带参数构造方法
        Person person2 = new Person("Alice", 25);
        person2.display(); // 输出: Name: Alice, Age: 25
    }
}

在上面的Main类中，我们通过调用构造方法来创建Person对象。我们可以看到根据不同的构造方法，创建的对象状态有所不同。

4. 默认构造方法

如果开发者没有定义任何构造方法，Java编译器会提供一个默认的无参数构造方法。这时，所有实例属性会被初始化为其类型的默认值，例如0、null等。

示例：

1
2
3
4
5
6
7
8
9
10
11
12
public class Animal {
    private String species;

    // 默认构造方法将由编译器自动提供
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Animal();
        // species 默认为 null
    }
}

在这个例子中，Animal类没有定义任何构造方法，Java自动提供一个默认构造方法。

5. 构造方法的访问修饰符

构造方法的访问修饰符（如public、private、protected）决定了谁可以创建该类的实例。比如，若构造方法为private，则无法在类的外部直接创建对象。

私有构造方法示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Singleton {
    private static Singleton instance;

    // 私有构造方法
    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

在这个Singleton例子中，构造方法是私有的，因此外部类无法直接实例化该类。相反，我们提供了一个静态方法getInstance()来获取唯一的实例。

总结

构造方法是面向对象编程中不可或缺的部分，可以帮助我们在创建对象时进行初始化。在本章中，我们学习了构造方法的基本语法、使用方式以及修饰符的影响。掌握构造方法将为我们深入理解面向对象编程奠定坚实的基础。

在下一章中，我们将进一步探讨访问控制修饰符，以帮助我们更好地理解类和对象的封装特性。

分享转发

发表更新编程 / Java小白7 分钟读完 (大约994个字)

27 面向对象编程基础之访问控制修饰符

在Java中，面向对象编程是核心思想之一，而访问控制修饰符则是实现这一思想的关键部分之一。通过合理使用访问控制修饰符，我们可以有效地保护类的数据成员不被非法访问，从而提高程序的安全性和可维护性。

访问控制修饰符类型

Java中主要有四种访问控制修饰符，它们分别是：

  1. public：公共访问修饰符，成员可以被任何其他类访问。
  2. protected：受保护访问修饰符，成员可以被同一个包中的类以及所有子类访问。
  3. default：默认访问修饰符，如果没有指定修饰符，默认是包级访问，成员可以被同一个包中的类访问。
  4. private：私有访问修饰符，成员只能被同一个类访问。

接下来，我们将详细探讨每种修饰符的使用及其影响。

1. public 修饰符

使用 public 修饰符的成员可以被任何其他类访问。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class PublicExample {
    public int publicVariable = 10;

    public void publicMethod() {
        System.out.println("This is a public method");
    }
}

class Test {
    public static void main(String[] args) {
        PublicExample example = new PublicExample();
        System.out.println(example.publicVariable); // 访问public变量
        example.publicMethod(); // 调用public方法
    }
}

在上述示例中，publicVariable 和 publicMethod 可以被 Test 类直接访问。

2. protected 修饰符

protected 修饰符可以在同一包中的类以及所有子类中访问。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class ProtectedExample {
    protected int protectedVariable = 20;

    protected void protectedMethod() {
        System.out.println("This is a protected method");
    }
}

class SubExample extends ProtectedExample {
    public void display() {
        System.out.println(protectedVariable); // 访问protected变量
        protectedMethod(); // 调用protected方法
    }
}

class Test {
    public static void main(String[] args) {
        SubExample example = new SubExample();
        example.display(); // 可以通过子类访问protected成员
    }
}

在这个例子中，protectedVariable 和 protectedMethod 可以被 SubExample 访问，但不能被其他包中的类直接访问。

3. default 修饰符

当一个类的成员没有修饰符时，即是使用了默认访问级别，只能在同一个包中访问。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class DefaultExample {
    int defaultVariable = 30; // 默认访问权限

    void defaultMethod() {
        System.out.println("This is a default method");
    }
}

class Test {
    public static void main(String[] args) {
        DefaultExample example = new DefaultExample();
        System.out.println(example.defaultVariable); // 访问default变量
        example.defaultMethod(); // 调用default方法
    }
}

在这个示例中，defaultVariable 和 defaultMethod 可以在同一个包中的类中访问，但如果想从不同包访问时就不可行了。

4. private 修饰符

private 修饰符使得成员只能被定义它的类访问。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class PrivateExample {
    private int privateVariable = 40;

    private void privateMethod() {
        System.out.println("This is a private method");
    }

    public void accessPrivate() {
        System.out.println(privateVariable); // 通过公有方法访问私有变量
        privateMethod(); // 通过公有方法调用私有方法
    }
}

class Test {
    public static void main(String[] args) {
        PrivateExample example = new PrivateExample();
        example.accessPrivate(); // 访问私有成员的方法
        // System.out.println(example.privateVariable); // 访问不到，会报错
    }
}

在这个示例中，privateVariable 和 privateMethod 无法被其他类直接访问，只有通过 accessPrivate 方法才能访问。

访问控制的总结

通过上述例子，我们可以总结出每种修饰符的访问规则及其适用场景：

  • 使用 public 修饰符时，成员对所有类可见，适合于 API 接口。
  • 使用 protected 修饰符时，成员仅对同包类和子类可见，适合于继承。
  • 使用 default 修饰符时，成员仅对同包类可见，适合于包内部逻辑。
  • 使用 private 修饰符时，成员仅对类内部可见，适合于隐藏实现细节，增强封装性。

结语

了解和合理使用访问控制修饰符是进行面向对象编程的基础之一。通过控制访问权限，可以保护数据，并确保类的封装性。在接下来的章节中，我们将探讨Java中常用的类，字符串类的使用及其特性。

分享转发

发表更新编程 / Java小白7 分钟读完 (大约995个字)

28 Java常用类之字符串类

在上一章中，我们讨论了面向对象编程中的访问控制修饰符，掌握了如何控制类、方法和变量的可见性。在这一章，我们将重点关注Java中的字符串类，String，以及它的一些常用操作。

1. 什么是字符串

在Java中，字符串是一个不可变的字符序列。也就是说，一旦创建，字符串的内容就不能被更改。字符串在Java中是用String类来表示的。

字符串的创建可以通过两种方式：

  • 字面量创建：String str = "Hello, World!";
  • 使用new关键字：String str = new String("Hello, World!");

虽然这两种方式都可以创建字符串，但更推荐使用字面量创建方式，因为这样会更高效。

2. 字符串的基本操作

2.1 获取字符串长度

可以使用length()方法来获取字符串的长度。例如：

1
2
3
String str = "Hello, World!";
int length = str.length();
System.out.println("字符串长度: " + length); // 输出: 字符串长度: 13

2.2 字符串拼接

在Java中，可以使用+运算符或concat()方法来拼接字符串。

1
2
3
4
String str1 = "Hello";
String str2 = "World";
String result = str1 + ", " + str2 + "!";
System.out.println(result); // 输出: Hello, World!

使用concat()方法：

1
2
String result = str1.concat(", ").concat(str2).concat("!");
System.out.println(result); // 输出: Hello, World!

2.3 字符串比较

String类提供了equals()方法和compareTo()方法来检查字符串的相等性和排序。

1
2
3
4
5
6
7
8
9
String str1 = "abc";
String str2 = "abc";
String str3 = new String("abc");

System.out.println(str1.equals(str2)); // 输出: true
System.out.println(str1.equals(str3)); // 输出: true
System.out.println(str1 == str3); // 输出: false，因为引用不同

System.out.println(str1.compareTo(str2)); // 输出: 0，相等

2.4 提取子字符串

可以使用substring()方法提取字符串的子字符串。

1
2
3
String str = "Hello, World!";
String substr = str.substring(7, 12);
System.out.println(substr); // 输出: World

2.5 查找字符或子字符串

可以使用indexOf()方法查找字符或子字符串的位置。

1
2
3
String str = "Hello, World!";
int index = str.indexOf("World");
System.out.println("World的起始位置: " + index); // 输出: World的起始位置: 7

2.6 字符串的替换

可以使用replace()方法进行字符串的替换操作。

1
2
3
String str = "Hello, World!";
String newStr = str.replace("World", "Java");
System.out.println(newStr); // 输出: Hello, Java!

2.7 字符串分割

使用split()方法可以将字符串按指定分隔符分割成字符串数组。

1
2
3
4
5
String str = "Java,Python,C++,JavaScript";
String[] languages = str.split(",");
for (String language : languages) {
    System.out.println(language); // 输出: Java, Python, C++, JavaScript
}

3. 字符串的常用方法总结

以下是一些常用的字符串方法：

  • length(): 获取字符串长度
  • charAt(int index): 获取指定索引的字符
  • substring(int beginIndex): 从指定索引获取子字符串
  • substring(int beginIndex, int endIndex): 获取指定范围的子字符串
  • indexOf(String str): 查找子字符串第一个出现的位置
  • replace(CharSequence target, CharSequence replacement): 替换指定字符/字符串
  • split(String regex): 按照正则表达式分割字符串

4. 案例：字符串处理

假设我们有一个字符串数据，其中包含多个用户的电子邮件地址。我们希望提取出这些电子邮件的用户名部分，以便后续处理。

1
2
3
4
5
6
7
8
9
10
11
public class EmailExtractor {
    public static void main(String[] args) {
        String emails = "alice@example.com,bob@example.com,charlie@example.com";
        String[] emailArray = emails.split(",");
        
        for (String email : emailArray) {
            String username = email.substring(0, email.indexOf("@"));
            System.out.println("用户名: " + username);
        }
    }
}

运行上述代码，将输出：

1
2
3
用户名: alice
用户名: bob
用户名: charlie

5. 结束语

在这一章中，我们详细讨论了Java中的字符串类String的基本概念及其常用操作。字符串是程序员日常编程中非常重要的基本数据类型，掌握字符串的各种操作将为后续编程打下坚实的基础。

在下一章中，我们将学习Java中的日期类，掌握如何处理和操作日期数据。

分享转发

发表更新编程 / Java小白6 分钟读完 (大约834个字)

29 Java常用类之日期类

在上一章中，我们详细探讨了Java中的字符串类，包括如何创建、操作和处理字符串。在本章中，我们将关注Java中的日期类，了解如何处理和操作日期和时间。

1. Java日期类的概述

在Java中，处理日期和时间的类主要包括：

  • java.util.Date
  • java.util.Calendar
  • java.time包中的一系列类，例如 LocalDate, LocalTime, LocalDateTime 等

这些类提供了丰富的 API，用于创建、比较和格式化日期和时间。

2. 使用 java.util.Date

Date 类是表示特定时刻的类，精确到毫秒。以下是如何使用 Date 类的基本示例：

创建 Date 对象

1
2
3
4
5
6
7
8
9
import java.util.Date;

public class DateExample {
    public static void main(String[] args) {
        // 创建一个当前时刻的 Date 对象
        Date now = new Date();
        System.out.println("当前日期和时间: " + now);
    }
}

获取时间戳

Date 类可以通过 getTime() 方法获取自 1970 年 1 月 1 日 00:00:00 GMT 以来的毫秒数：

1
2
long timestamp = now.getTime();
System.out.println("当前时间戳: " + timestamp);

3. 使用 java.util.Calendar

Calendar 类是一个抽象类，提供了更灵活的日期和时间操作功能。下面是如何使用它的示例：

创建 Calendar 对象

1
2
3
4
5
6
7
8
9
10
11
12
import java.util.Calendar;

public class CalendarExample {
    public static void main(String[] args) {
        // 创建一个 Calendar 实例 
        Calendar calendar = Calendar.getInstance();
        
        // 获取当前年份
        int year = calendar.get(Calendar.YEAR);
        System.out.println("当前年份: " + year);
    }
}

设置和获取日期

1
2
3
4
5
calendar.set(Calendar.YEAR, 2023);
calendar.set(Calendar.MONTH, Calendar.AUGUST); // 注意：月份是从0开始的
calendar.set(Calendar.DAY_OF_MONTH, 1);
Date newDate = calendar.getTime();
System.out.println("设置的日期: " + newDate);

4. 使用 Java 8 及以上版本的 java.time 包

Java 8 引入了新的日期时间 API，大大改善了日期时间的处理。这里我们将介绍几个常用的类。

创建 LocalDate

LocalDate 表示一个日期，不包含时间信息：

1
2
3
4
5
6
7
8
9
10
11
12
import java.time.LocalDate;

public class LocalDateExample {
    public static void main(String[] args) {
        LocalDate today = LocalDate.now();
        System.out.println("今天的日期: " + today);
        
        // 自定义日期
        LocalDate specificDate = LocalDate.of(2023, 8, 1);
        System.out.println("自定义日期: " + specificDate);
    }
}

日期比较

1
2
3
4
5
6
LocalDate date1 = LocalDate.of(2023, 8, 1);
LocalDate date2 = LocalDate.of(2023, 9, 1);

if (date1.isBefore(date2)) {
    System.out.println(date1 + " 在 " + date2 + " 之前");
}

获取当前日期的组成部分

1
2
3
4
int year = today.getYear();
int month = today.getMonthValue();
int day = today.getDayOfMonth();
System.out.printf("今天的年份: %d, 月份: %d, 日: %d%n", year, month, day);

格式化日期

使用 DateTimeFormatter 格式化日期：

1
2
3
4
5
import java.time.format.DateTimeFormatter;

DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy/MM/dd");
String formattedDate = today.format(formatter);
System.out.println("格式化后的日期: " + formattedDate);

5. 注意事项

  • java.util.Date 和 java.util.Calendar 是可变的，这可能导致线程安全问题。而 java.time 包提供的类是不可变的，更加安全。
  • 使用 java.time 包可以更方便地进行时间和日期的计算和格式化。

6. 总结

在本章中，我们介绍了Java中常用的日期和时间类，学习了如何创建、操作和格式化这些类。Java 8及以上版本的java.time包为我们提供了更强大和灵活的日期时间处理方式，在后续的学习中，将会更加常用。

在下一章中，我们将深入探讨Java的集合类，包括各种集合的使用和特性，敬请期待！

分享转发

发表更新编程 / Java小白6 分钟读完 (大约949个字)

30 Java常用类之集合类

在前一章中，我们讨论了 Java 的日期类及其在处理日期和时间时的重要性。本章将重点介绍 Java 的集合类，它们是数据存储和操作的核心工具。集合类提供了多种数据结构来存储对象，并为我们提供了许多便利的方法，以提高程序的易用性和灵活性。

1. 集合框架概述

Java 集合框架包含了一组接口和类，它们可以对一组对象进行存储和操作。集合框架的核心包含：

  • 集合（Collection）：根接口，用于存储一组对象。
  • 映射（Map）：用于存储键值对。

1.1 集合的主要接口

  • List：有序集合，可以存储重复元素。
  • Set：不允许重复元素的集合。
  • Queue：用于存储排队的元素，遵循先进先出（FIFO）原则。
  • Deque：双端队列，允许在两端插入和删除元素。

1.2 映射的主要接口

  • Map：键值对集合，允许用键（Key）来查找值（Value）。
  • SortedMap：有序的 Map 接口。

2. 常用集合类

2.1 ArrayList

ArrayList 是用于存储可变数量的元素的列表。它实现了 List 接口，允许插入重复元素。

1
2
3
4
5
6
7
8
9
10
11
12
13
import java.util.ArrayList;

public class ArrayListExample {
    public static void main(String[] args) {
        ArrayList<String> fruits = new ArrayList<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Cherry");
        fruits.add("Banana"); // 允许重复

        System.out.println("Fruits: " + fruits);
    }
}

输出：

1
Fruits: [Apple, Banana, Cherry, Banana]

2.2 LinkedList

LinkedList 也是 List 接口的实现，适合频繁插入和删除操作的场景。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import java.util.LinkedList;

public class LinkedListExample {
    public static void main(String[] args) {
        LinkedList<String> cities = new LinkedList<>();
        cities.add("New York");
        cities.add("Los Angeles");
        cities.add("Chicago");

        cities.remove("Los Angeles"); // 删除操作

        System.out.println("Cities: " + cities);
    }
}

输出：

1
Cities: [New York, Chicago]

2.3 HashSet

HashSet 实现了 Set 接口，不允许重复元素，并且不保证存储顺序。

1
2
3
4
5
6
7
8
9
10
11
12
import java.util.HashSet;

public class HashSetExample {
    public static void main(String[] args) {
        HashSet<String> uniqueFruits = new HashSet<>();
        uniqueFruits.add("Apple");
        uniqueFruits.add("Banana");
        uniqueFruits.add("Apple"); // 不会添加，因重复

        System.out.println("Unique Fruits: " + uniqueFruits);
    }
}

输出：

1
Unique Fruits: [Banana, Apple]

2.4 HashMap

HashMap 是 Map 接口的一个实现，支持快速访问和插入，允许使用 null 作为键和/或值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import java.util.HashMap;

public class HashMapExample {
    public static void main(String[] args) {
        HashMap<String, Integer> scores = new HashMap<>();
        scores.put("Alice", 90);
        scores.put("Bob", 85);
        scores.put("Charlie", 92);

        scores.put("Alice", 95); // 更新 Alice 的分数

        System.out.println("Scores: " + scores);
    }
}

输出：

1
Scores: {Alice=95, Bob=85, Charlie=92}

3. 遍历集合

遍历集合是操作集合中的元素的常见方法。不同的集合类可能有不同的遍历方式。

3.1 使用迭代器

对于 ArrayList 和 HashSet，我们可以使用 Iterator 进行遍历。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import java.util.ArrayList;
import java.util.Iterator;

public class IteratorExample {
    public static void main(String[] args) {
        ArrayList<String> colors = new ArrayList<>();
        colors.add("Red");
        colors.add("Green");
        colors.add("Blue");

        Iterator<String> iterator = colors.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

输出：

1
2
3
Red
Green
Blue

3.2 使用增强的 for 循环

增强的 for 循环（也称为“for-each”循环）也可用于遍历 Iterable。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import java.util.HashSet;

public class ForEachExample {
    public static void main(String[] args) {
        HashSet<String> animals = new HashSet<>();
        animals.add("Dog");
        animals.add("Cat");
        animals.add("Rabbit");

        for (String animal : animals) {
            System.out.println(animal);
        }
    }
}

输出：

1
2
3
Dog
Cat
Rabbit

4. 结论

通过本章的学习，我们对 Java 的集合类有了初步的了解。不同的集合类适用于不同的场景，理解这些集合的特性将帮助我们在编写 Java 程序时选择合适的工具。

在下一章节中，我们将介绍 Java 的输入输出流，这对于处理数据的读取和写入是至关重要的。希望大家能继续保持学习的热情，与我一起深入 Java 的世界。

分享转发

×