在Java中，泛型是一个强大的特性，它允许我们在类、接口和方法中使用类型参数，从而在编译时提供类型安全。在进行Java进阶学习时，理解泛型及其应用非常重要。本节将详细介绍泛型的基本概念以及类型通配符的使用。

1. 泛型基础

1.1 什么是泛型？

泛型是Java的一种机制，允许我们在定义类、接口和方法时使用类型参数。泛型的主要目的是增强类型安全性和代码重用性。

1.2 定义泛型类

你可以定义一个泛型类如下：

1
2
3
4
5
6
7
8
9
10
11

public class Box<T> {
    private T content;

    public void setContent(T content) {
        this.content = content;
    }

    public T getContent() {
        return content;
    }
}

在这个例子中，Box类定义了一个类型参数 T，可以在类的内部使用该类型。

1.3 使用泛型类

创建 Box 实例时可以指定具体类型：

1
2
3
4
5
6
7
8
9
10
11

public class Main {
    public static void main(String[] args) {
        Box<String> stringBox = new Box<>();
        stringBox.setContent("Hello, World!");
        System.out.println(stringBox.getContent());

        Box<Integer> integerBox = new Box<>();
        integerBox.setContent(123);
        System.out.println(integerBox.getContent());
    }
}

2. 类型通配符

2.1 什么是类型通配符？

类型通配符允许我们在使用泛型时指定不确定的类型。通配符通常用 ? 表示，可以用于方法参数、集合等。

2.2 通配符的基本使用

2.2.1 无限定通配符

无限定通配符 ? 可以匹配任何类型，例如：

1
2
3

public void printBox(Box<?> box) {
    System.out.println(box.getContent());
}

2.2.2 有界通配符

有界通配符用于限制通配符的类型范围。可以使用上界和下界。

• 上界通配符：<? extends T>，表示类型可以是 T 或 T 的子类型。

1
2
3

public void printBox(Box<? extends Number> box) {
    System.out.println(box.getContent());
}

• 下界通配符：<? super T>，表示类型可以是 T 或 T 的父类型。

1
2
3

public void addToBox(Box<? super Integer> box) {
    box.setContent(42);
}

2.3 通配符的使用场景

使用通配符的一个典型场景是处理同一类型的多个子类的集合。

2.3.1 使用上界通配符的例子

假设我们有一个方法，可以处理任何 Number 类型的 Box。

1
2
3
4

public void processNumbers(Box<? extends Number> box) {
    Number num = box.getContent();
    System.out.println("Processing number: " + num);
}

2.3.2 使用下界通配符的例子

如果想要填充一个 Box，而不关心其具体类型：

1
2
3
4

public void addIntegers(Box<? super Integer> box) {
    box.setContent(10);
    box.setContent(20);
}

3. 总结

在Java中，泛型和类型通配符是重要的特性，便于增强代码的灵活性和安全性。通过使用泛型，我们可以创建可以处理多种数据类型的通用类和方法，而类型通配符则允许我们在处理不确定类型时提供更多的灵活性。在实际开发中，掌握这些概念能够帮助我们编写更安全、更整洁的代码。

参考

• Java 官方文档 - 泛型
• Java 官方文档 - 类型通配符

希望本节内容能帮助你更好地理解和应用Java中的泛型与类型通配符！

1. 环境准备

在开始学习Java之前，您需要准备好开发环境。以下是设置环境的步骤：

1.1 安装Java Development Kit (JDK)

1. 下载JDK：访问 Oracle官网 或 OpenJDK 下载适合您操作系统的JDK版本。
2. 安装JDK：按照安装程序的指示完成安装。
3. 配置环境变量：
   • 对于Windows用户，您需要将JDK的 bin 目录添加到系统的 PATH 环境变量中。例如：C:\Program Files\Java\jdk-11.0.11\bin。
   • 对于macOS和Linux用户，您可以在终端中添加以下行到~/.bash_profile或~/.bashrc：

     1 2	export JAVA_HOME=/Library/Java/JavaVirtualMachines/jdk-11.0.11.jdk/Contents/Home export PATH=$JAVA_HOME/bin:$PATH

1.2 安装开发工具

您可能希望安装一个集成开发环境（IDE）来编写和运行Java代码。推荐的 IDE 有：

• Eclipse：功能强大的开源IDE。
• IntelliJ IDEA：JetBrains出品的高效IDE，尤其适合Java开发。
• NetBeans：另一个开源的IDE，支持多种编程语言。

选择您喜欢的IDE并进行安装。

2. 编写第一个Java程序

现在，我们就来编写我们第一个Java程序。这将是一个简单的“Hello, World!”程序，打印出这句话。

2.1 创建 Java 文件

1. 打开您的IDE，新建一个项目（例如：HelloWorld）。
2. 在项目中创建一个新的Java文件，命名为 HelloWorld.java。

2.2 编写代码

在 HelloWorld.java 文件中，输入以下代码：

1
2
3
4
5

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

代码解释：

• public class HelloWorld： 这是类的定义，Java程序是以类为基础的，每个程序至少应该有一个类。
• public static void main(String[] args)：主方法，是Java程序的入口点。JVM（Java虚拟机）会从这里开始执行程序。
  • String[] args：这是一个字符串数组，存储运行时传递给程序的命令行参数。
• System.out.println("Hello, World!");：这行代码用于打印信息到控制台。System.out是标准输出流，而 println 是一个方法，用于输出文本并换行。

2.3 编译和运行程序

2.3.1 使用IDE

如果您使用的是IDE，通常会有图形界面选项来编译和运行程序，您只需点击“运行”按钮即可。

2.3.2 使用命令行

如果您使用命令行，可以按照以下步骤操作：

1. 打开终端或命令提示符，导航到包含 HelloWorld.java 的目录。

2. 编译Java文件：

   1	javac HelloWorld.java

   这条命令会生成一个 HelloWorld.class 文件，这是经过编译的字节码文件。

3. 运行Java程序：

   1	java HelloWorld

   您应该会看到输出：

   1	Hello, World!

3. 总结

恭喜您完成了您的第一个Java程序！在本节中，我们：

• 学习了如何安装和配置Java开发环境。
• 编写了一个简单的Java程序，输出 Hello, World!。
• 学习了如何通过IDE和命令行编译和运行程序。

下一步是深入学习Java的基本语法和概念，以便您继续开发更复杂的程序。

在Java中，异常是一种重要的机制，用于处理程序中的错误和不可预期的情况。深入理解异常机制不仅有助于编写健壮的代码，还能提高程序的可读性和可维护性。

1. 什么是异常

在Java中，异常是指程序执行过程中发生的事件，这些事件会打断程序的正常执行流程。异常通常是由于各种原因造成的，例如：

• 输入/输出操作失败
• 数组越界
• 数字格式不正确
• 网络连接失败

2. 异常的分类

Java中的异常可以分为两大类：

• 已检查异常（Checked Exception）: 编译器强制要求处理的异常。这类异常通常是程序在运行时可能发生的，开发者应该通过try-catch块或者在方法签名中使用throws声明来处理。常见的例子有IOException和SQLException。

• 未检查异常（Unchecked Exception）: 编译器不强制要求处理的异常。这类异常通常是由编程错误引起的，比如NullPointerException、ArrayIndexOutOfBoundsException等。未检查异常的处理方式通常是在代码逻辑中避免发生这些异常。

3. 异常的层次结构

Java中的异常均继承自Throwable类。Throwable类下有两个主要子类：

• Error类: 通常表示系统级错误，比如OutOfMemoryError，一般不应被捕获和处理。
• Exception类: 代表程序中的异常情况，必须进行处理。

3.1 常见异常类

• RuntimeException: 这是一类未检查异常，其子类包括NullPointerException、IndexOutOfBoundsException和IllegalArgumentException。
• IOException: 这是一种已检查异常，处理输入输出过程中可能出现的错误。

4. 异常处理机制

异常处理是通过try-catch块来实现的，基本语法如下：

1
2
3
4
5
6
7
8
9

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

4.1 try-catch示例

以下是一个简单的示例，演示了如何使用try-catch块处理异常：

1
2
3
4
5
6
7
8
9
10
11
12
13

public class ExceptionExample {
    public static void main(String[] args) {
        try {
            int[] numbers = {1, 2, 3};
            // 这里会引发 ArrayIndexOutOfBoundsException
            System.out.println(numbers[5]);
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("数组下标越界了！" + e.getMessage());
        } finally {
            System.out.println("此代码将始终执行。");
        }
    }
}

5. 自定义异常

Java允许开发者自定义异常，以满足特定业务需求。自定义异常需要继承Exception类或其子类。

5.1 自定义异常示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

public class MyCustomException extends Exception {
    public MyCustomException(String message) {
        super(message);
    }
}

public class CustomExceptionDemo {
    public static void main(String[] args) {
        try {
            throw new MyCustomException("这是一个自定义异常");
        } catch (MyCustomException e) {
            System.out.println("捕获到自定义异常: " + e.getMessage());
        }
    }
}

6. 异常的规范

在编写Java代码时，遵循以下异常处理规范：

1. 捕获特定异常: 避免捕获Exception或Throwable，应尽量捕获具体异常，以避免隐藏潜在错误。

2. 适当地使用finally: finally块中的代码将始终执行，适合用于释放资源，如关闭数据库连接或关闭文件。

3. 记录异常: 捕获异常时，应该适当地记录日志，便于后续问题的排查。

4. 避免空的catch块: 不要使用空的catch块，这样会导致异常被完全忽略，可能使问题更加严重。

7. 总结

Java异常机制为我们提供了一种优雅的错误处理方式。掌握异常的分类、处理和自定义，有助于开发高质量的Java应用程序。在实际工作中，不仅要能处理异常，还要能理解异常产生的原因，从而编写出更健壮的代码。