---

目录

一.Java的特性

二.注释

三.数据类型

基本数据类型

包装类

引用数据类型

四.运算符

五.逻辑控制

选择语句

循环语句

六.数组

七.方法

八.类与对象

构造方法

内部类

九.继承和多态

十.抽象类与接口

抽象类

接口

十一.异常

---

一.Java的特性

Java最初由Sun Microsystems的詹姆斯·高斯林于1991年开始设计，早期的设计目标是为了开发家电设备上运行的小程序。1995年Sun Microsystems发布了Java语言，该语言具有简单、安全、可移植和面向对象的特性。同时，詹姆斯·高斯林也被称作是Java之父。

Java最大的一个特性就是一次编译，到处运行，和c语言c++最大的区别就是，Java代码可以在任何平台上运行，因为内部存在JVM虚拟机使得代码拥有了非常好的可移植性。Java为我们提供了编译和运行的命令

• 编译命令：javac
• 运行命令：java

我们将Java的特性总结如下：

1. 面向对象：Java是一种面向对象的编程语言，支持封装、继承和多态等面向对象的概念，使得程序更加模块化和易于维护。
2. 跨平台性：Java被设计为一种跨平台的语言，可以在不同的操作系统上运行，只需要在相应的平台上安装Java虚拟机（JVM）即可。
3. 简单性：Java语言的语法相对简单，去除了一些复杂的特性和语法，使得程序员更容易理解和编写代码。
4. 安全性：Java提供了安全性的机制，例如通过字节码验证和安全性管理器来防止恶意代码对计算机系统的攻击。此外，Java还提供了一些加密和认证的API，用于保护数据和网络通信的安全。
5. 高性能：Java通过即时编译器（JIT）和垃圾收集来提高程序的性能。即时编译器将Java字节码编译成本地机器代码，从而加快程序的执行速度，而垃圾收集则自动回收不再使用的内存，减少了程序员对内存的手动管理。
6. 可移植性：由于Java的跨平台特性，编写的Java程序可以在不同的操作系统和硬件上运行，无需修改代码。
7. 多线程支持：Java提供了内置的线程支持，可以方便地创建和管理多个线程，实现并发编程。
8. 开放性：Java是一种开放源代码的语言，拥有庞大的开发者社区，可以通过共享和重用代码来加快开发速度。
9. 大型库的支持：Java拥有丰富的类库和API，可以用于解决各种问题和开发各种应用程序，如图形界面、数据库访问、网络通信等。

Java是一种面向对象编程语言，他当然也有面向对象的三大特性

• 继承
• 封装
• 多态 

对于继承，封装，多态的知识点总结如下：万字详解Java的三大特性：封装 | 继承 | 多态

---

二.注释

在Java中，注释是用来给代码加上描述、解释或提供其他信息的一种方式。Java注释有三种类型：

1. 单行注释：以双斜线（//）开始，后面跟随注释内容。这种注释只在当前行有效。

// 这是一个单行注释

2. 多行注释：以斜线星号（/*）开始，以星号斜线（*/）结束，中间的内容都被视为注释。这种注释可以跨越多行。

/*
这是一个多行注释，
可以跨越多行
*/

3. 文档注释：以斜线星号（/**）开始，以星号斜线（*/）结束。文档注释通常用于生成程序的文档，可以通过工具将其提取出来。文档注释可以包含HTML标记，用于格式化文档。

/**
 * 这是一个文档注释
 */

注释在编译时会被Java编译器忽略，不会对程序的执行产生任何影响。然而，良好的注释可以提高代码的可读性和可维护性，帮助其他程序员理解代码的意图和功能。

---

三.数据类型

基本数据类型

Java为我们提供了8大基本数据类型：

• byte —— 1个字节
• short —— 2个字节
• int —— 4个字节
• long —— 8个字节
• float —— 4个字节
• double —— 8个字节
• char —— 2个字节
• boolean —— 没有明确规定

对于以上的基本数据类型，Java都提供的对应的包装类，而这些基本数据实际上只是这些包装类的一部分。Java的包装类是指Java中提供的用于封装基本数据类型的类。包装类提供了一些方法和属性，可以方便地对基本数据类型进行操作。

包装类

Java中提供了以下包装类：

• Integer：封装int类型的数据，提供了一些方法用于int类型的操作，例如转换成字符串、比较大小等。
• Float：封装float类型的数据，提供了一些方法用于float类型的操作，例如转换成字符串、比较大小等。
• Character：封装char类型的数据，提供了一些方法用于char类型的操作，例如转换成大写字母、判断是否是字母等。
• Boolean：封装boolean类型的数据，提供了一些方法用于boolean类型的操作，例如取反、判断是否为真等。
• Byte：封装byte类型的数据，提供了一些方法用于byte类型的操作，例如转换成字符串、比较大小等。
• Short：封装short类型的数据，提供了一些方法用于short类型的操作，例如转换成字符串、比较大小等。
• Long：封装long类型的数据，提供了一些方法用于long类型的操作，例如转换成字符串、比较大小等。
• Double：封装double类型的数据，提供了一些方法用于double类型的操作，例如转换成字符串、比较大小等。

包装类在Java中的主要作用是在基本数据类型和引用数据类型之间进行转换。可以通过包装类的构造方法来创建包装类对象，也可以通过包装类的静态方法来进行基本数据类型和包装类之间的转换。例如，通过Integer类的parseInt()方法可以将一个字符串转换成int类型的数据，通过Integer类的valueOf()方法可以将一个int类型的数据转换成Integer对象。

使用包装类可以方便地进行基本数据类型的操作和类型转换，同时也提供了一些额外的方法和属性，方便程序的开发和编写。

引用数据类型

引用数据类型指的是非基本数据类型，包括：

• 类（Class）：表示具有相同属性和方法的对象
• 接口（Interface）：表示定义了一组方法的协议
• 数组（Array）：表示相同类型的多个元素的集合

引用数据类型需要通过new关键字来创建对象，然后才能赋值和使用。除了这些内置的变量类型，Java还支持自定义的变量类型，可以通过创建类、接口和数组来定义自己的变量类型。

---

四.运算符

在Java中，运算符用于执行各种数学和逻辑操作。以下是Java中常见的运算符：

1. 算术运算符：

• 加法运算符（+）：用于将两个值相加。
• 减法运算符（-）：用于将一个值减去另一个值。
• 乘法运算符（*）：用于将两个值相乘。
• 除法运算符（/）：用于将一个值除以另一个值。
• 取模运算符（%）：用于计算两个值的余数。

2. 自增和自减运算符：

• 自增运算符（++）：将变量的值增加1。
• 自减运算符（--）：将变量的值减少1。

3. 关系运算符：

• 等于运算符（==）：检查两个值是否相等。
• 不等于运算符（!=）：检查两个值是否不相等。
• 大于运算符（>）：检查一个值是否大于另一个值。
• 小于运算符（<）：检查一个值是否小于另一个值。
• 大于等于运算符（>=）：检查一个值是否大于或等于另一个值。
• 小于等于运算符（<=）：检查一个值是否小于或等于另一个值。

4. 逻辑运算符：

• 与运算符（&&）：当两个条件都为true时，返回true。
• 或运算符（||）：当至少有一个条件为true时，返回true。
• 非运算符（!）：用于取反一个条件的值。

5. 赋值运算符：

• 等号运算符（=）：将右边的值赋给左边的变量。
• 加等运算符（+=）：将右边的值与左边的变量相加，并将结果赋给左边的变量。

6. 位运算符：

• 与运算符（&）：将两个值的对应位进行逻辑与操作。
• 或运算符（|）：将两个值的对应位进行逻辑或操作。
• 异或运算符（^）：将两个值的对应位进行逻辑异或操作。

7. 条件运算符：

• 三元运算符（? :）：根据一个条件的真假选择两个表达式之一。

8. 移位运算符：

• 左移运算符（<）：将数按照二进制往左移动一位
• 右移运算符（>）：将数按照二进制往右移动一位
• 无符号右移（>>>）：将数按照二进制往右移动一位，但是空缺的数值位补0

---

五.逻辑控制

选择语句

switch 语句

其中float double boolean long类型不能作为switch语句的参数

switch (表达式) {
   case 值1:
       // 如果表达式的值等于值1，执行这里的代码
       break;
   case 值2:
       // 如果表达式的值等于值2，执行这里的代码
       break;
   // 可以继续添加更多的case语句
   default:
       // 如果表达式的值不等于任何一个case的值，执行这里的代码
       break;
}

if 语句

其中条件必须为boolean类型，这点和c语言并不一样，c语言中我们可以将0当作false作为if语句的参数，但是再Java里面是不可以的

if (条件) {
   // 如果条件为真，执行这里的代码
} else {
   // 如果条件为假，执行这里的代码
}

循环语句

while 循环

while (条件) {
    // 循环执行的代码块
}

for 循环

for (初始值; 条件; 操作) {
    // 循环执行的代码块
}

do...while 循环

do {
    // 循环执行的代码块
} while (条件);

增强for循环

用于遍历数组或集合中的元素，不需要指定索引或迭代器，简化了代码的书写。

for (元素类型 元素变量 : 数组名或集合名) {
    // 循环执行的代码块
}

break语句

for (int i = 0; i < 10; i++) {
    if (i == 5) {
        break; // 在i等于5时跳出循环
    }
}

 continue语句

for (int i = 1; i <= 10; i++) {
    if (i % 2 == 0) {
        continue; // 在i为偶数时跳过当前迭代
    }
    System.out.println(i);
}

---

六.数组

在Java中，数组是一种容器，用于存储多个相同类型的元素。数组在声明时需要指定数组的类型和长度。在使用数组时，可以通过索引访问和修改数组中的元素。

申明数组：

int[] numbers; // 声明一个整型数组
double[] grades; // 声明一个双精度浮点型数组
String[] names; // 声明一个字符串数组

 创建数组：

int[] numbers = new int[5]; // 创建一个长度为5的整型数组
double[] grades = new double[10]; // 创建一个长度为10的双精度浮点型数组
String[] names = new String[3]; // 创建一个长度为3的字符串数组

初始化数组：

int[] numbers = {1, 2, 3, 4, 5}; // 初始化整型数组
double[] grades = {98.5, 87.2, 93.7}; // 初始化双精度浮点型数组
String[] names = {"Alice", "Bob", "Charlie"}; // 初始化字符串数组

 需要注意的是二维数组的使用，在创建的时候，可以直接声明二维数组的具体大小，也可以缺省申明，但是只能缺省列数，不能缺省行数，这一点上是与c语言不一样的

    int[][] nums = new int[10][10];//正确
    int[][] nums = new int[10][];//正确
    int[][] nums = new int[][10];//错误
    int[][] nums = new int[][];//错误

---

七.方法

在Java中，方法是一段可执行的代码块，用于完成特定的任务。方法可以定义在类中或者在类外部，它可以接受输入参数并返回结果。以下是Java中定义方法的一般语法：

[可见性修饰符] [static] [返回类型] [方法名]([参数列表]) {
    // 方法体
}

其中，各部分的含义如下：

• 可见性修饰符：指定方法可以被哪些类访问，例如 public,private,protected 或者不使用任何修饰符。
• static：表示该方法属于类而不是类的实例，可以通过类名直接调用，不需要创建对象。
• 返回类型：指定方法返回的数据类型，可以是任何合法的Java数据类型，或者void表示不返回任何值。
• 方法名：方法的唯一标识符，用于在其他地方调用该方法。
• 参数列表：指定方法接受的输入参数的类型和名称，多个参数之间使用逗号分隔。
• 方法体：方法的实际执行代码，用于完成特定的任务。

Java中的方法重载（Overloading）与方法重写（Overriding）是两个重要的概念。

方法重载是指在一个类中，可以有多个方法拥有相同的名称，但是参数列表不同。编译器会根据调用时传入的参数类型和数量来判断调用哪个方法。方法重载可以提高代码的可读性和可维护性。需要注意，方法重载的判断与返回值并无关系。

方法重写是指在一个子类中，重新定义了父类中已经存在的方法。子类中的方法名称、参数列表和返回类型必须与父类中的方法相同。通过方法重写，子类可以根据自己的需要对继承自父类的方法进行修改或补充。方法重写是实现多态性的基础。

class Animal {
    public void makeSound() {
        System.out.println("Animal is making sound");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog is barking");
    }
    
    public void makeSound(String sound) {
        System.out.println(sound);
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.makeSound(); // 输出：Animal is making sound
        
        Dog dog = new Dog();
        dog.makeSound();    // 输出：Dog is barking
        dog.makeSound("Woof!"); // 输出：Woof!
    }
}

在上面的示例中，Animal类定义了一个makeSound方法，子类Dog通过方法重写重新定义了makeSound方法。另外，Dog类还定义了一个makeSound方法，在方法重载的情况下，编译器会根据传入的参数类型和数量来确定调用哪个方法。

---

八.类与对象

Java中的类是定义对象的模板，包含对象的属性和行为。类是实现面向对象编程的基本单位。在Java中，每个类都是通过class关键字来定义的。

对象是类的一个实例，具有类定义的属性和行为。在Java中，可以使用new关键字创建一个对象。创建对象后，可以访问对象的属性和调用对象的方法。

public class Car {
    // 类的属性
    private String brand;
    private String color;
    
    // 类的构造方法
    public Car(String brand, String color) {
        this.brand = brand;
        this.color = color;
    }
    
    // 类的方法
    public void drive() {
        System.out.println("Driving the " + color + " " + brand + " car.");
    }
    
    // 类的get方法和set方法
    public String getBrand() {
        return brand;
    }
    
    public void setBrand(String brand) {
        this.brand = brand;
    }
    
    public String getColor() {
        return color;
    }
    
    public void setColor(String color) {
        this.color = color;
    }
}

// 创建Car对象
Car myCar = new Car("Toyota", "red");

// 访问对象的属性
System.out.println(myCar.getBrand()); // 输出：Toyota
System.out.println(myCar.getColor()); // 输出：red

// 调用对象的方法
myCar.drive(); // 输出：Driving the red Toyota car.

构造方法

在Java中，构造方法是一种特殊的方法，用于创建和初始化对象。构造方法具有以下特点：

1. 构造方法的名称必须与类名完全相同。
2. 构造方法没有返回类型，包括void。这是因为构造方法的主要目的是创建对象，而不是返回值。
3. 构造方法在使用new关键字实例化对象时自动调用。
4. 如果一个类没有定义构造方法，Java会提供一个默认的无参构造方法。如果一个类定义了构造方法，Java将不会提供默认构造方法。
5. 构造方法可以重载，即可以定义多个具有不同参数的构造方法。
6. 构造方法可以使用this关键字来调用同一类的其他构造方法。这种方式称为构造方法的链式调用。

构造方法的作用是初始化对象的状态，可以在构造方法中为对象的实例变量赋初值。例如，以下是一个简单的例子：

public class Car {
    private String color;
    private int speed;
    
    // 无参构造方法
    public Car() {
        color = "Red";
        speed = 0;
    }
    
    // 带参构造方法
    public Car(String color, int speed) {
        this.color = color;
        this.speed = speed;
    }
    
    // 获取颜色
    public String getColor() {
        return color;
    }
    
    // 获取速度
    public int getSpeed() {
        return speed;
    }
}

// 使用构造方法创建对象
Car car1 = new Car();                // 调用无参构造方法，color为"Red"，speed为0
Car car2 = new Car("Blue", 80);      // 调用带参构造方法，color为"Blue"，speed为80

System.out.println(car1.getColor()); // 输出"Red"
System.out.println(car1.getSpeed()); // 输出0

System.out.println(car2.getColor()); // 输出"Blue"
System.out.println(car2.getSpeed()); // 输出80

内部类

Java中的内部类是指在一个类内部定义的类。内部类可以访问外部类的成员变量和方法，包括私有成员。在Java中，内部类可以分为四种类型：成员内部类、局部内部类、匿名内部类和静态内部类。

成员内部类：成员内部类是定义在外部类中的类。它可以访问外部类的成员，并且可以使用外部类的实例化对象来创建内部类的对象。成员内部类有自己的成员变量和方法，可以被外部类或其他类实例化使用。

public class Outer {
    private int x;
    
    public void outerMethod() {
        Inner inner = new Inner();
        inner.innerMethod();
    }
    
    public class Inner {
        private int y;
        
        public void innerMethod() {
            System.out.println("Inner method");
        }
    }
}

局部内部类：局部内部类是定义在方法体或作用域内的类。它只能在定义它的方法中使用，并且不能被其他方法或类访问。局部内部类可以访问外部类和方法的成员变量和方法。

public class Outer {
    private int x;
    
    public void outerMethod() {
        int y = 10;
        
        class Inner {
            public void innerMethod() {
                System.out.println("Inner method: " + x + " " + y);
            }
        }
        
        Inner inner = new Inner();
        inner.innerMethod();
    }
}

 匿名内部类：匿名内部类是没有名字的内部类，它通常用作接口或抽象类的实现类。匿名内部类只能在创建对象时使用，并且只能使用一次。它可以访问外部类的成员变量和方法。

public class Outer {
    private int x;
    
    public void outerMethod() {
        new Interface() {
            @Override
            public void method() {
                System.out.println("Anonymous inner class");
            }
        }.method();
    }
    
    interface Interface {
        void method();
    }
}

静态内部类：静态内部类是定义在外部类中的静态类。它可以直接访问外部类的静态成员，并且可以在没有外部类对象的情况下创建内部类对象。静态内部类与外部类的关系不是紧密的，可以独立存在。

public class Outer {
    private static int x;
    
    public static void outerMethod() {
        Inner inner = new Inner();
        inner.innerMethod();
    }
    
    public static class Inner {
        private int y;
        
        public void innerMethod() {
            System.out.println("Inner method: " + x);
        }
    }
}

---

九.继承和多态

在Java中，继承是面向对象编程的一个重要概念。它允许一个类继承另一个类的属性和方法。通过继承，子类可以重用父类的代码，并且可以在不修改父类的情况下添加新的功能或修改现有功能。在这里笔者只是简单的解释一下，对于继承和多态的详细解读可以点击这篇文章：

万字详解Java的三大特性：封装 | 继承 | 多态

使用关键字"extends"可以创建一个子类，该子类继承了父类的属性和方法。子类可以访问父类的公共（public）和受保护（protected）成员，但不能访问父类的私有（private）成员。

例如，我们有一个父类Animal和一个子类Dog：

class Animal {
    public void eat() {
        System.out.println("Animal is eating");
    }
}

class Dog extends Animal {
    public void bark() {
        System.out.println("Dog is barking");
    }
}

在上面的例子中，Dog类继承了Animal类，并添加了一个新的方法bark()。现在我们可以创建一个Dog对象并调用父类的方法和子类的方法：

Dog dog = new Dog();
dog.eat(); // 输出 "Animal is eating"
dog.bark(); // 输出 "Dog is barking"

多态是Java中另一个重要的概念，它允许使用一个父类的引用来引用子类的对象。这意味着可以使用父类类型的引用来调用子类对象中重写的方法。

例如，我们有一个Animal类和一个子类Dog：

class Animal {
    public void makeSound() {
        System.out.println("Animal is making a sound");
    }
}

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

现在我们可以使用Animal类的引用来引用Dog对象：

Animal animal = new Dog();
animal.makeSound(); // 输出 "Dog is barking"

在上面的例子中，animal引用的是一个Dog对象，但是调用的是Dog类中重写的makeSound()方法。这就是多态的效果。

---

十.抽象类与接口

抽象类

在Java中，抽象类是一种不能被实例化的类，只能被子类继承的类。抽象类不能创建对象，但可以被用作其他类的父类。

抽象类通过关键字"abstract"来声明，可以包含抽象方法和具体方法。抽象方法是没有具体实现的方法，必须由子类来实现。具体方法是有具体实现的方法。

抽象类的定义示例：

abstract class Animal {
   abstract void sound(); // 抽象方法
   
   void sleep() {
      System.out.println("睡觉"); // 具体方法
   }
}

子类继承抽象类时，必须实现所有的抽象方法，否则子类也必须声明为抽象类。示例：

class Dog extends Animal {
   void sound() {
      System.out.println("汪汪"); // 实现抽象方法
   }
}

抽象类可以拥有构造方法，但是不能被实例化。抽象类可以有字段和非抽象的方法。子类可以通过使用"super"关键字来调用抽象类的构造方法和方法。

接口

抽象类的主要目的是为了提供一种模板或封装方法的机制，使得子类能够共享父类的规范。它可以帮助我们更好地设计和组织代码，提高代码的可重用性和可维护性。

在Java中，接口是一个抽象类型，它定义了一组方法的签名，但没有提供方法的具体实现。接口可以被类实现，实现类必须实现接口中定义的所有方法。接口通过关键字`interface`定义。

接口可以包含以下内容：

• 常量：接口中的常量都是公共的静态常量，可以直接通过接口名称访问。
• 抽象方法：接口中的方法没有具体的实现，只有方法的声明。实现类必须提供方法的具体实现。
• 默认方法（Default Methods）：Java 8引入的新特性，允许在接口中提供方法的默认实现。默认方法通过关键字`default`定义，并且可以在实现类中选择性地覆盖。
• 静态方法（Static Methods）：Java 8引入的新特性，允许在接口中定义静态方法。静态方法通过关键字`static`定义，并且只能在接口中调用。
• 私有方法（Private Methods）：Java 9引入的新特性，允许在接口中定义私有方法。私有方法通过关键字`private`定义，并且只能在接口内部调用。

接口的主要作用是定义一组规范，可以被多个类实现。实现接口的类可以提供不同的实现，但是必须满足接口定义的方法签名。这种设计可以实现多态和代码重用。接口和抽象类十分的类似，接口内部的方法也是默认抽象的，不可在内部实例化的，只能由接口的调用者去实现，调用接口需要使用implements关键字。

Java中的Comparator接口定义了用于比较对象的方法。以下是Comparator接口的示例代码：

import java.util.*;

public class ExampleComparator {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(5, 3, 8, 1, 2);

        // 使用Comparator接口的方法进行排序
        Collections.sort(numbers, new CustomComparator());

        // 打印排序后的结果
        for (Integer number : numbers) {
            System.out.println(number);
        }
    }
}

class CustomComparator implements Comparator<Integer> {
    @Override
    public int compare(Integer num1, Integer num2) {
        // 按照降序进行比较
        return num2 - num1;
    }
}

在这个示例中，我们定义了一个CustomComparator类实现了Comparator接口，并重写了compare方法。在main方法中，我们使用Collections.sort方法进行排序，并将CustomComparator的实例传递给它。这样，我们就可以通过Comparator接口定义的规则对数字进行降序排序。这只是一个简单的示例，实际上Java中的接口有很多应用场景，可以用于定义回调方法，实现多态等。

---

十一.异常

本文只是简单介绍，对于异常体系结构的详解可以参考这篇文章：

详解Java中的异常体系结构（throw，throws，try-catch，finally，自定义异常）

在Java中，异常（Exception）是程序运行过程中出现的错误或意外事件。异常分为两种类型：受检异常和非受检异常。

受检异常是指在程序编译时就被检查出来的异常，需要在代码中进行处理或声明抛出。常见的受检异常包括IOException、SQLException等。

非受检异常是指在程序运行时才会出现的异常，也称为运行时异常（RuntimeException）。这些异常通常是由程序中的错误逻辑或错误使用API引起的，例如NullPointerException、ArrayIndexOutOfBoundsException等。非受检异常不需要在代码中显式声明或捕获，如果不进行处理，程序会在异常发生时终止并抛出异常信息。

Java中的异常可以使用try-catch语句捕获和处理。try块中包含可能抛出异常的代码，catch块用于捕获并处理异常。如果try块中的代码发生异常，则程序会跳转到相应的catch块进行处理。可以使用多个catch块来处理不同类型的异常，还可以使用finally块来执行无论是否发生异常都要执行的代码。

try {
    // 可能会抛出异常的代码
} catch (Exception e) {
    // 处理异常的代码
} finally {
    //一定会执行的内容
}

除了捕获和处理异常，还可以使用throws关键字在方法的声明中抛出异常。这表示该方法可能会抛出指定的异常，调用该方法的代码需要进行相应的处理或再次抛出。

以下是一个Java异常处理的示例：

public class ExceptionHandlingExample {
    public static void main(String[] args) {
        try {
            int[] numbers = {1, 2, 3, 4, 5};
            System.out.println(numbers[10]); // 非法的数组索引，将抛出ArrayIndexOutOfBoundsException异常
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("发生了数组索引越界异常");
            e.printStackTrace(); // 打印异常堆栈信息
        } finally {
            System.out.println("无论是否发生异常，都会执行finally块");
        }
    }
}

在这个示例中，我们尝试访问一个不存在的数组索引。由于这是一个非法操作，将会抛出ArrayIndexOutOfBoundsException异常。我们使用try-catch语句来捕获并处理这个异常。在catch块中，我们打印出异常消息并使用printStackTrace()方法打印异常的堆栈信息。无论是否发生异常，finally块中的代码都会被执行。在这个示例中，我们简单地打印出一条信息。

输出结果应该类似于：

发生了数组索引越界异常
java.lang.ArrayIndexOutOfBoundsException: 10
        at ExceptionHandlingExample.main(ExceptionHandlingExample.java:7)
无论是否发生异常，都会执行finally块

在Java中，异常类是从Throwable类派生的。Java提供了很多内置的异常类，还可以自定义异常类来表示特定的异常情况。自定义异常类需要继承Exception或RuntimeException类。异常是Java中处理错误和意外事件的机制。它可以帮助程序员在程序出错时进行适当的处理，提高程序的可靠性和稳定性。

---

---

---

 本次的分享就到此为止了，希望我的分享能给您带来帮助，也欢迎大家三连支持，你们的点赞就是博主更新最大的动力！如有不同意见，欢迎评论区积极讨论交流，让我们一起学习进步！有相关问题也可以私信博主，评论区和私信都会认真查看的，我们下次再见