java中final和 finally的区别 - 面试宝典

川长思鸟来 2023-10-15 11:49 20阅读 0赞

**目录**

讲解

代码示例

代码讲解

final关键字：

finally关键字：

--------------------

#  #

# 讲解 #

Java中`final`和`finally`是两个完全不同的关键字。 `final`是一个修饰符，可以用于类、方法和变量。当用于类时，表示该类不能被继承；当用于方法时，表示该方法不能被重写；当用于变量时，表示该变量只能被赋值一次，即为常量。`final`关键字提供了不可变性的特性，用于确保特定的类、方法或变量的不可更改性。 `finally`是一个关键字，用于结构化异常处理中的`try-catch-finally`块。`finally`块中的代码无论异常是否发生，都会被执行。通常在`finally`块中放置一些必须执行的清理代码，例如关闭打开的文件、释放资源等。`finally`块的作用是确保代码块中的资源被正确释放，即使发生了异常也能保证执行。 因此，`final`和`finally`在Java中具有完全不同的作用和用法。`final`用于修饰类、方法和变量，用于实现不可变性；而`finally`用于结构化异常处理中的清理代码块，用于确保资源的正确释放。

# 代码示例 #

以下是使用`final`和`finally`关键字的示例代码：

javaCopy code// 使用final修饰类
    final class FinalClass {
       // 使用final修饰方法
       final void finalMethod() {
          // final修饰的方法不能被子类重写
       }
       
       // 使用final修饰变量
       final int finalVariable = 10;
       // final修饰的变量只能被赋值一次，即为常量
    }
    public class FinallyExample {
       public static void main(String[] args) {
          try {
             int result = divide(10, 0);
             System.out.println("Result: " + result);
          } catch (ArithmeticException e) {
             System.out.println("Error: " + e.getMessage());
          } finally {
             System.out.println("Finally block executed");
          }
       }
       
       public static int divide(int num1, int num2) {
          try {
             return num1 / num2;
          } catch (ArithmeticException e) {
             throw e;
          }
       }
    }

# 代码讲解 #

在上面的示例代码中，`FinalClass`类被使用`final`修饰，表示它不能被继承。`finalMethod()`方法被使用`final`修饰，表示它不能被重写。`finalVariable`变量被使用`final`修饰，表示它只能被赋值一次。 在`FinallyExample`类中，`divide()`方法用于进行两个数相除的操作。在`main()`方法中，调用`divide()`方法可能会抛出`ArithmeticException`异常。在`try-catch`块中捕获该异常并处理，然后无论是否发生异常，`finally`块中的代码都会被执行。最后，程序输出相应的结果和`Finally block executed`信息。

![4ac0f0156d8a521253ac3bad85d875d2.png][]

在Java中，final和finally是两个不同的关键字，具有不同的作用。

# final关键字： #

`final` 关键字是在编程语言中用来修饰变量、方法和类的关键字，其历史和原理如下所述： **历史：** `final` 关键字最早出现在 C++ 编程语言中，用来修饰类的成员变量和成员函数。它的作用是禁止对变量进行修改或对方法进行重写。随后，Java、C\#、Python 等主流编程语言也引入了 `final` 关键字，并对其进行了扩展和用法的增加。 **原理：** `final` 关键字的原理取决于它所修饰的内容，可以分为以下几种情况：

1.  修饰变量：
    
     *  当 `final` 修饰一个变量时，该变量被称为一个常量或不可变变量。它的值在声明后不能被修改。
     *  `final` 修饰的变量必须在声明时进行初始化，并且只能被赋值一次。
     *  常量通常使用全大写字母命名，以增加可读性和区分度。
     *  `final` 修饰的变量可以是基本数据类型或引用类型。
2.  修饰方法：
    
     *  当 `final` 修饰一个方法时，该方法不能被子类重写。
     *  `final` 方法在父类中定义后，子类不能对其进行重写，保持了方法的一致性。
     *  `final` 方法的主要应用场景是在设计模式中，如模板方法模式，其中父类中的某些方法需要固定实现，而子类不能进行修改。
3.  修饰类：
    
     *  当 `final` 修饰一个类时，该类不能被继承。
     *  `final` 类的设计初衷是为了防止类的进一步扩展和修改，以确保类的稳定性和安全性。
     *  `final` 类通常被用于工具类、不可变类或安全类等场景。
     *  `final` 类中的成员变量和方法默认为 `final` 修饰，除非显式声明为 `final` 或使用 `static`、`private` 等限定符。 `final` 关键字的应用使得变量、方法和类具有了更强的不可变性和稳定性。它可以在代码中起到限制和保护的作用，防止意外的修改和扩展，同时提高了代码的可读性和可维护性。

final关键字可以用来修饰类、方法和变量，具有以下作用：

*  当final修饰类时，表示该类不能被继承。
 *  当final修饰方法时，表示该方法不能被子类重写。
 *  当final修饰变量时，表示该变量的值不能被修改。 以下是一些示例代码：

javaCopy code// final修饰类
    final class FinalClass {
        // ...
    }
    // 继承final类会报错
    class SubClass extends FinalClass {
        // ...
    }
    // final修饰方法
    class ParentClass {
        final void finalMethod() {
            // ...
        }
    }
    class ChildClass extends ParentClass {
        // 无法重写final方法
        void finalMethod() {
            // ...
        }
    }
    // final修饰变量
    class FinalVariable {
        final int finalValue = 10;
        // 尝试修改final变量的值会报错
        void modifyFinalVariable() {
            finalValue = 20;
        }
    }

# finally关键字： #

`finally` 关键字是在编程语言中用来定义一个代码块，表示无论发生什么情况，该代码块总是会被执行。它的历史和原理如下所述： **历史：** `finally` 关键字最早出现在 C++ 编程语言中。由于 C++ 是一种面向对象的语言，它的异常处理机制也较为完善。C++ 的 `try-catch-finally` 结构中，`finally` 关键字被用来定义一个代码块，用于在异常处理后进行清理操作。由于 C++ 在异常处理方面的成功，其他编程语言也开始采纳这个特性。随后，Java、C\#、Python 等主流编程语言也引入了 `finally` 关键字。 **原理：** 在程序执行过程中，当发生异常时，会中断当前的代码执行流程，转而执行异常处理流程。`try-catch-finally` 结构就是为了处理这种异常情况而设计的。该结构的原理如下：

1.  程序首先执行 `try` 代码块中的内容。
2.  如果 `try` 代码块中的代码发生异常，那么程序将会跳转到匹配异常类型的 `catch` 代码块中进行异常处理。
3.  在 `catch` 代码块中进行异常处理后，程序会继续执行 `finally` 代码块中的内容。
4.  如果 `try` 代码块中的代码没有发生异常，那么 `catch` 代码块会被跳过，直接执行 `finally` 代码块中的内容。
5.  无论是否发生异常，`finally` 代码块中的代码都会被执行。 `finally` 代码块的执行具有以下特点：
6.  `finally` 代码块中的代码总是会被执行，无论是否发生异常。
7.  如果在 `try` 代码块中发生了异常，那么 `finally` 代码块会在相应的 `catch` 代码块之后执行。
8.  如果在 `try` 代码块中没有发生异常，那么 `catch` 代码块会被跳过，直接执行 `finally` 代码块。
9.  当 `finally` 代码块执行完毕后，程序会继续执行 `try-catch-finally` 结构之后的代码。 总结来说，`finally` 关键字的原理就是确保在异常处理后，无论是否发生异常，`finally` 代码块中的代码都会被执行，以进行必要的清理操作。它在异常处理和资源管理方面起到了重要的作用。

finally关键字用于定义在try-catch语句中的一个代码块，在无论是否发生异常的情况下都会执行。它通常用于资源的释放或清理操作。 以下是一个示例代码：

javaCopy codepublic class FinallyExample {
        public static void main(String[] args) {
            try {
                int result = divide(10, 0);
                System.out.println("Result: " + result);
            } catch (ArithmeticException e) {
                System.out.println("Error: " + e.getMessage());
            } finally {
                System.out.println("Finally block executed");
            }
        }
        public static int divide(int dividend, int divisor) {
            return dividend / divisor;
        }
    }

在上面的代码中，由于除数为0，会发生ArithmeticException异常。不管是否发生异常，finally块中的代码都会被执行，并输出"Finally block executed"。

[4ac0f0156d8a521253ac3bad85d875d2.png]: https://img-blog.csdnimg.cn/img_convert/4ac0f0156d8a521253ac3bad85d875d2.png