JAVASE语法零基础——异常

已于 2022-12-16 21:34:03 修改
阅读量153 收藏
点赞数 2
分类专栏： JAVASE 0基础入门 文章标签： jvm java 服务器
于 2022-07-16 09:52:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62160964/article/details/125797677
版权
本文详细介绍了Java中的异常处理机制，包括异常的概念、异常体系结构、异常的分类（受查异常与非受查异常）、异常的处理（try-catch-finally、throws声明）以及自定义异常。通过实例展示了如何在代码中处理异常，强调了异常处理在程序设计中的重要性，并提供了异常处理的最佳实践。
摘要由CSDN通过智能技术生成

Java系列文章目录

在这里插入图片描述

Write once,Runanywhere.🔥🔥🔥

💥 💥 💥如果你觉得我的文章有帮助到你，还请【关注➕点赞➕收藏】，得到你们支持就是我最大的动力!!!
💥 💥 💥

⚡版权声明：本文由【马上回来了】原创、在CSDN首发、需要转载请联系博主。
版权声明：本文为CSDN博主「马上回来了」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。

在这里插入图片描述

🚀🚀🚀 新的知识开始喽🚀🚀🚀
在这里插入图片描述

文章目录

1 异常的概念

在java中，将程序执行不正常的行为称为异常。

1.1 常见的异常

算数异常：
在这里插入图片描述
数组越界异常
在这里插入图片描述

1.2 常见错误Error

在这里插入图片描述

1.3区分语法错误与异常

在这里插入图片描述

2 异常体系结构

2.1 异常其实也是类。

在这里插入图片描述
异常类的体系结构(部分)：
在这里插入图片描述

  1. Throwable：Throwable是异常体系的顶层类，它派生出两个重要的子类，Error和Exception。
  2. Error：Error指的是虚拟机无法解决的严重问题，比如：JVM的内部错误、资源耗尽等。典型代表：StackOverflowError和OutOfMemoryError。一旦发生回力乏术。
  3. Exception：异常发生后程序员可以通过代码进行处理，使程序继续进行。

2.2 异常的分类

异常可以发生在编译时，也可以发生在运行时，根据不同的发生时机可以分为：

1.受查异常

程序在编译期间发生的异常，称为编译时异常，也称为受查异常(Checked Exception)受查异常必须在编译时期处理(对受查异常进行捕获(trycatch)或申明(throws)),否者编译无法通过!!!
在这里插入图片描述

2.非受查异常

在程序运行期间发生的异常，称为运行异常，也称之为非受查异常(Unchecked Exception)。
RunTimeException以及其子类对应的异常，都称为运行时异常。比如：NullPointerException、ArrayIndexOutOfBoundsException、ArithmeticException。
非受查异常报错会发生在运行时期!!!

注意：编译时出现的语法性错误，不能称之为异常。
例如将System.out.println 拼写错了, 写成了system.out.println. 此时编译过程中就会出错, 这是 “编译期” 出错。而运行时指的是程序已经编译通过得到class 文件了, 再由 JVM 执行过程中出现的错误。

3 异常的处理

1.主要处理方式

错误在代码中是客观存在的.。因此我们要让程序出现问题的时候及时通知程序猿。 主要的方式：

  1. LBYL: Look Before You Leap. 在下一步 操作之前就做充分的检查. 即：事前防御型
boolean ret = false;
ret = 登陆游戏();
if (!ret) {
处理登陆游戏错误;
return;
}
 ret = 开始匹配();
if (!ret) {
处理匹配错误;
return;
} 
ret = 游戏确认();
if (!ret) {
处理游戏确认错误;
return;
} 
ret = 选择英雄();
if (!ret) {
处理选择英雄错误;
return;
} 
ret = 载入游戏画面();
if (!ret) {
处理载入游戏错误;
return;
}
......

缺陷：正常流程和错误处理流程代码混在一起, 代码整体显的比较混乱。

  1. EAFP: It’s Easier to Ask Forgiveness than Permission. “事后获取原谅比事前获取许可更容易”. 也就是先操作, 遇到问题再处理. 即：事后认错型
try {
登陆游戏();
开始匹配();
游戏确认();
选择英雄();
载入游戏画面();
...
} catch (登陆游戏异常) {
处理登陆游戏异常;
} catch (开始匹配异常) {
处理开始匹配异常;
} catch (游戏确认异常) {
处理游戏确认异常;
} catch (选择英雄异常) {
处理选择英雄异常;
} catch (载入游戏画面异常) {
处理载入游戏画面异常;
}
......

优势：正常流程和错误流程是分离开的, 程序员更关注正常流程，代码更清晰，容易理解代码异常处理的核心思想就是 EAFP。
在Java中，异常处理主要的5个关键字：throw、try、catch、finally、throws。

2 异常的抛出

在编写程序时，如果程序出现错误，此时需要将错误的信息告知给调用者，比如：参数检测。
运行时异常在我们没有定义异常时,一般是由JVM帮我我们抛出(如最开始的算数异常和数组越界异常),如果程序员要自定义异常并且手动抛出就需要使用throw关键字.抛出一个指定的异常对象，将错误信息告知给调用者。程序员手动抛出异常的具体语法如下：

throw new XXXException("异常产生的原因");

1 .运行时异常

如果抛出的是一个非受查异常,就不需要对这个异常进行处理.
示例：实现一个获取数组任意元素位置的方法。

public class Test1 {
    public static int getElement(int[] arry,int index){
        if(arry == null){
            throw new NullPointerException("传递的数组为null");//括号里里异常的信息
        }
        if (index<0 || index>=arry.length){
            throw new ArrayIndexOutOfBoundsException("传递的数组下标越界");
        }
        return arry[index];
    }
    public static void main(String[] args) {
        int[] arr = {1,2,3};
        getElement(arr,3);//传递的数组下标越界
    }
}

运行结果：
在这里插入图片描述

2 编译时异常

如果抛出的是一个受查异常就必须对异常进行处理(捕获try/catch;声明throws),否者编译无法通过.
示例：Student类实现克隆接口。

public class Exception {
    public static void fun(int n) throws CloneNotSupportedException {
        if (n < 0){
            throw new CloneNotSupportedException("受查异常继续处理");
        }

    }
    public static void main(String[] args) throws CloneNotSupportedException {
        fun(-1);
    }
}

在这里插入图片描述

注意事项：

  1. throw必须写在方法体内部
  2. 抛出的对象必须是Exception 或者 Exception 的子类对象
  3. 如果抛出的是 RunTimeException 或者 RunTimeException 的子类，则可以不用处理，代码运行后,直接交给JVM来处理.
  4. 如果抛出的是编译时异常，用户必须处理，通过throws来声明异常，否则无法通过编译。
    5. 异常一旦抛出，其后的代码就不会执行，即遇到异常代码终止
    在这里插入图片描述

3 异常的捕获

异常的捕获，也就是异常的具体处理方式，主要有两种：异常声明throws 以及 try-catch捕获处理。

1 异常声明throws

处在方法声明的参数列表之后，当方法中抛出编译时异常时，用户在此处不想处理该异常，此时就可以借助throws将异常抛给方法调用者来处理。即：当前方法不处理异常，提醒方法的调用来处理异常。

语法格式：
修饰符 返回值类型 方法名(参数列表) throws 异常类型1，异常类型2...{
}

示例1：克隆
在这里插入图片描述
示例2：加载指定的配置文件config.ini
在这里插入图片描述

public class Config {
    File file;
    //打开文件
    public  void openConfig(String filename) throws FileNotFoundException {
        if(filename.equals("config.ini")){
            throw new FileNotFoundException("配置文件名不对");
        }
    }

    public static void main(String[] args) throws FileNotFoundException {
        Config config = new Config();
        config.openConfig("config.ini");

    }
}

注意事项：
1.throws必须写在方法的参数列表之后。
2.声明的异常必须是Exception或者Exception的子类。
3.方法内部如果跑出了多个异常，throws后面必须要跟多个异常类型，之间用逗号隔开，如果抛出的类型具有父子关系，直接声明父类即可。
示例:throw抛出多个受查异常

public class Config {
    File file;
    //打开文件
    public  void openConfig(String filename) throws IOException {//throw后面跟一个父类,不建议这么写,不知道具体声明的是哪个异常类
        // public void OpenConfig(String filename) throws IOException,FileNotFoundException{  //throws后面跟多个异常类
        // FileNotFoundException 继承自 IOException
        if(filename.endsWith(".ini")){
            throw new IOException("文件不是.ini文件");
        }
        if(filename.equals("config.ini")){
            throw new FileNotFoundException("配置文件名不对");
        }
    }

    public static void main(String[] args) throws IOException {//方法的调用者也必须处理这个异常
        Config config = new Config();
        config.openConfig("config.ini");

    }
}

在这里插入图片描述
4.方法的调用者必须处理该方法里用throws声明的异常:
try-catch捕获/throws声明
4.1 通过try/catch来捕获
在这里插入图片描述
4.2 通过throws来声明
在这里插入图片描述
总结:throws并没有真正的处理throw抛出的异常,只是声明了该异常,将异常交给该带有异常方法的调用者来处理.throws只是能使代码能够顺利通过编译.

在这里插入图片描述

2 try-catch捕获并处理

throws并没有将异常真正的处理，而是将异常报告抛出给异常方法的调用者，由调用者处理。如果需要真正对异常进行处理，就需要try-catch。

语法格式：
try{
// 将可能出现异常的代码放在这里
}catch(要捕获的异常类型 e){
// 如果try中的代码抛出异常了，此处catch捕获时,异常类型与try中抛出的异常类型一致时，或者是try中抛出异常的子类时，就会被捕获到

// 对异常就可以正常处理，处理完成后，跳出try-catch结构，继续执行后序代码
}[catch(异常类型 e){
// 对异常进行处理
}finally{
// 此处代码一定会被执行到
}]
// 后序代码
// 当异常被捕获到时，异常就被处理了，这里的后序代码一定会执行
// 如果捕获了，由于捕获时类型不对，那就没有捕获到，这里的代码就不会被执行
注意：
1. []中表示可选项，可以添加，也可以不用添加
2. try中的代码可能会抛出异常，也可能不会

public class Exception {
    public static void main(String[] args) {
        try{
            int [] arry = null;
            System.out.println(arry.length);
        }catch(NullPointerException e){
            System.out.println("捕获到了一个异常");
        }
        System.out.println("我是其他代码逻辑");
    }
    }

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
异常可以捕捉多种类型,但是一次只能捕捉到一个异常
在这里插入图片描述
不建议将异常类型写在同一个catch里,不容易区分到底是捕捉到哪个异常.
在这里插入图片描述
不建议catch里写异常的父类,不容易区分到底捕捉到的是哪个具体的异常:
在这里插入图片描述
在捕捉多个异常时,也不能将父类的异常A(大范围异常A包小范围异常B)写在前面,子类异常B写在后面.
在这里插入图片描述
这样编译才能通过：子类在前,父类在后
在这里插入图片描述

注意事项：

  1. try块内抛出异常位置之后的代码将不会被执行

在这里插入图片描述

  1. 如果抛出异常类型与catch时异常类型不匹配，即异常不会被成功捕获，也就不会被处理，继续往外抛，直到JVM收到后中断程序----异常是按照类型来捕获的
    在这里插入图片描述

  2. try中可能会抛出多个不同的异常对象，则必须用多个catch来捕获----即多种异常，多次捕获。 如果多个异常的处理方式是完全相同, 也可以写成这样：

3.4. 可以通过一个catch捕获所有的异常，即多个异常，一次捕获(不推荐)

public static void main(String[] args) {
int[] arr = {1, 2, 3};
try {
System.out.println("before");
arr = null;
System.out.println(arr[100]);
System.out.println("after");
} catch (Exception e) {
e.printStackTrace();
} S
ystem.out.println("after try catch");
}

由于 Exception 类是所有异常类的父类. 因此可以用这个类型表示捕捉所有异常。

3 finally

在写程序时，有些特定的代码，不论程序是否发生异常，都需要执行，比如程序中打开的资源：网络连接、数据库连接、IO流等，在程序正常或者异常退出时，必须要对资源进进行回收。另外，因为异常会引发程序的跳转，可能导致有些语句执行不到，finally就是用来解决这个问题的。

语法格式：
try{
// 可能会发生异常的代码
}catch(异常类型 e){
// 对捕获到的异常进行处理
}finally{
// 此处的语句无论是否发生异常，都会被执行到
}
//其他代码逻辑
 // 如果没有抛出异常，或者异常被捕获处理了，这里的代码也会执行

示例:关闭Scanner资源
在这里插入图片描述
在这里插入图片描述
小技巧:
在这里插入图片描述

public static void main(String[] args) {
try{
int[] arr = {1,2,3};
arr[100] = 10;
arr[0] = 10;
}catch (ArrayIndexOutOfBoundsException e){
System.out.println(e);
}finally {
System.out.println("finally中的代码一定会执行");
} System.out.println("如果没有抛出异常，或者异常被处理了，try-catch后的代码也会执行");

问题：(在没有抛出异常或者异常被正确处理的情况下)既然 finally 和 try-catch-finally 后的代码都会执行，那为什么还要有finally呢？

需求：实现getData方法，内部输入一个整形数字，然后将该数字返回，并再main方法中打印。

public class TestFinally {
public static int getData(){
Scanner sc = null;
try{
sc = new Scanner(System.in);
int data = sc.nextInt();
return data;//在这里返回结束
}catch (InputMismatchException e){
e.printStackTrace();
}finally {
System.out.println("finally中代码");
} System.out.println("try-catch-finally之后代码");
if(null != sc){//如果正常输入这里的代码就没有执行，即输入流就没有被释放，造成资源泄漏。
sc.close();
}return 0;
}
public static void main(String[] args) {
int data = getData();
System.out.println(data);
}
}
// 正常输入时程序运行结果：
100
finally中代码
100

上述程序，如果正常输入，成功接收输入后程序就在try里return返回了，try-catch-finally之后的代码根本就没有执行，即输入流就没有被释放，造成资源泄漏。

注意：finally中的代码一定会执行的，一般在finally中进行一些资源清理的扫尾工作。
不管是什么情况finally里的代码是一定会被执行到的.
在这里插入图片描述

public class TestFinally {
public static int getData(){
Scanner sc = null;
try{
sc = new Scanner(System.in);
int data = sc.nextInt();
return data;
}catch (InputMismatchException e){
e.printStackTrace();
}finally {//finally一定会被执行
System.out.println("finally中代码");
sc.close();//释放输入流资源
}
return 0;
}
public static void main(String[] args) {
int data = getData();
System.out.println(data);
}
}
// 正常输入时程序运行结果：
100
finally中代码
100

// 下面程序输出什么？
public static void main(String[] args) {
System.out.println(func());
}
public static int func() {
try {
return 10;
} finally {
return 20;
}
} A: 10 B: 20 C: 30 D: 编译失败
答案：B
finally 执行的时机是在方法返回之前(try 或者 catch 中如果有 return 会在这个 return 之前执行 finally). 但是如果finally 中也存在 return 语句, 那么就会执行 finally 中的 return, 从而不会执行到 try 中原有的 return.
一般我们不建议在 finally 中写 return (被编译器当做一个警告)

【面试题】：

  1. throw 和 throws 的区别？

throw是抛出一个异常对象,在方法内部
throws是声明一个异常对象,在方法声明列表之后。

  1. finally中的语句一定会执行吗？

是

4 异常处理流程

关于 “调用栈”
方法之间是存在相互调用关系的, 这种调用关系我们可以用 “调用栈” 来描述. 在 JVM 中有一块内存空间称为"虚拟机栈" 专门存储方法之间的调用关系. 当代码中出现异常的时候, 我们就可以使用 e.printStackTrace(); 的方式查看出现异常代码的调用栈.
如果本方法中没有合适的处理异常的方式, 就会沿着调用栈向上传递：

public static void main(String[] args) {
try {
func();
} catch (ArrayIndexOutOfBoundsExcepti
e.printStackTrace();
} System.out.println("after try catch");
}
public static void func() {
int[] arr = {1, 2, 3};
System.out.println(arr[100]);
} 
// 直接结果
java.lang.ArrayIndexOutOfBoundsExceptio
at demo02.Test.func(Test.java:18)//一般把第一个异常解决后面的异常就都解决了
at demo02.Test.main(Test.java:9)
after try catch

在这里插入图片描述
如果向上一直传递都没有合适的方法处理异常, 最终就会交给 JVM 处理, 程序就会异常终止(和我们最开始未使用 trycatch 时是一样的).

public class Test {
    private static void func(){
        int[] arr = {1,2,3};
        System.out.println(arr[100]);
    }
    public static void main(String[] args) {
            func();
        System.out.println("after try-catch");
    }
    }

在这里插入图片描述
可以看到, 程序已经异常终止了, 没有执行到 System.out.println(“after try catch”); 这一行
【异常处理流程总结】
程序先执行 try 中的代码
如果 try 中的代码出现异常, 就会结束 try 中的代码, 看和 catch 中的异常类型是否匹配.如果找到匹配的异常类型, 就会执行 catch 中的代码
如果没有找到匹配的异常类型, 就会将异常向上传递到方法调用者.
无论是否找到匹配的异常类型, finally 中的代码都会被执行到(在该方法结束之前执行).
如果上层调用者也没有处理的了异常, 就继续向上传递.一直到 main 方法也没有合适的代码处理异常, 就会交给 JVM 来进行处理, 此时程序就会异常终止

5 自定义异常类

Java 中虽然已经内置了丰富的异常类, 但是并不能完全表示实际开发中所遇到的一些异常，此时就需要维护符合我们实际情况的异常结构.
下面自定义一个运行时异常：
先看ArithmeticException这个运行时异常：
在这里插入图片描述
我们模仿着定义一个：

public class MyException extends RuntimeException{
    public MyException() {
    }

    public MyException(String message) {
        super(message);
    }
}

自定义一个编译时异常：

public class MyException extends Exception{
    public MyException() {
    }

    public MyException(String message) {
        super(message);
    }
}

在这里插入图片描述
下面用自定义异常类来实现一个登陆功能：
1.自定义运行时异常：

/**
 * Created with IntelliJ IDEA.
 * Description: 自定义运行时异常
 * User: lenovo
 * Date: 2022-07-16
 * Time: 9:34
 */
class UserNameException extends RuntimeException{
    public UserNameException() {
    }

    public UserNameException(String message) {
        super(message);
    }
}
class PasswordException extends RuntimeException{
    public PasswordException() {
    }

    public PasswordException(String message) {
        super(message);
    }
}
public class Login {
    private String userName = "abc";
    private String password = "123";

    public  void loginIn(String usName,String uspassword){
        if(!userName.equals(usName)){
            throw new UserNameException("用户名错误");

        }
        if(!password.equals(uspassword)){
            throw new PasswordException("密码错误");
        }
        System.out.println("登陆成功");
    }

    public static void main(String[] args) {
       try{
           Login login = new Login();
           login.loginIn("ad","12");
       }catch (UserNameException userNameException){
           userNameException.printStackTrace();
       }catch (PasswordException passwordException){
           passwordException.printStackTrace();
       }finally {
           System.out.println("finally这里代码一定执行");
       }
        System.out.println("其他代码逻辑");
    }
}

2.自定义编译时异常：

/**
 * Created with IntelliJ IDEA.
 * Description: 自定义编译时异常 loginIn方法需要用throws声明异常，然后交给loginIn方法调用者main方法来try-catch处理这个异常
 * User: lenovo
 * Date: 2022-07-16
 * Time: 9:34
 */
class UserNameException extends Exception{
    public UserNameException() {
    }

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

    public PasswordException(String message) {
        super(message);
    }
}
public class Login {
    private String userName = "abc";
    private String password = "123";

    public  void loginIn(String usName,String uspassword) throws UserNameException, PasswordException {
        if(!userName.equals(usName)){
            throw new UserNameException("用户名错误");

        }
        if(!password.equals(uspassword)){
            throw new PasswordException("密码错误");
        }
        System.out.println("登陆成功");
    }

    public static void main(String[] args) {
       try{
           Login login = new Login();
           login.loginIn("ad","12");
       }catch (UserNameException userNameException){
           userNameException.printStackTrace();
       }catch (PasswordException passwordException){
           passwordException.printStackTrace();
       }finally {
           System.out.println("finally这里代码一定执行");
       }
        System.out.println("其他代码逻辑");
    }
}

注意事项：
自定义异常通常会继承自 Exception 或者 RuntimeException
继承自 Exception 的异常默认是受查异常
继承自 RuntimeException 的异常默认是非受查异常

🌏🌏🌏今天的你看懂这里又学到了很多东西吧🌏🌏🌏

在这里插入图片描述

🌔 🌔 🌔下次见喽🌔 🌔 🌔
在这里插入图片描述

马上回来了
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
javaSE代码实例
06-21
第2章　基本数据类型——构建Java 大厦的基础　12 2.1　源代码注释　12 2.1.1　单行注释　12 2.1.2　区域注释　12 2.1.3　文档注释　13 2.2　基本数据类型　14 2.2.1　整型　15 2.2.2　浮点型　17 2.2.3　char型　17...
Java基础知识——Java入门与加深
08-31
Java是一种广泛使用的面向...总结，Java的基础知识涵盖了从基本语法到面向对象编程，再到高级特性和框架。理解并熟练运用这些知识，是成为一名合格的Java开发者的关键。希望本文能为你的Java学习之路提供有力的支持。
JAVASE语法零基础——数组的定义与使用
m0_62160964的博客
05-07 500
Java系列文章目录 Write once,Runanywhere.🔥🔥🔥 这篇文章讲解数组，从这篇文章开始讲解的知识就跟C语言有所不同了。 💥 💥 💥如果你觉得我的文章有帮助到你，还请【关注➕点赞➕收藏】，得到你们支持就是我最大的动力!!! 💥 💥 💥 ⚡版权声明：本文由【马上回来了】原创、在CSDN首发、需要转载请联系博主。 版权声明：本文为CSDN博主「马上回来了」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 🚀🚀🚀 新的知识开始喽🚀🚀🚀 文章
JAVASE语法零基础——Clonable 接口和深浅拷贝
m0_62160964的博客
07-02 178
Clone接口的实现、深拷贝、浅拷贝详解！！！
JAVASE语法零基础——String3类常用的一些操作函数
m0_62160964的博客
07-14 161
String类型常用的操作函数：查找、转化、拆分、截取等等。
JAVASE语法零基础——运算符(只讲解与C语言细微区别)
m0_62160964的博客
04-24 2159
Java系列文章目录 Write once,Runanywhere. 前面几篇文章都是可以帮助C语言学习者快速熟悉Java的语法，如果你是没有学习过C语言而直接来观看的这个JavaSE语法系列的专栏，那你可以先去看看我C语言的相关专栏，便于你快速掌握JavaSE的语法。 这篇文章着重讲解Java运算符与C语言里运算符的细微区别，两者之间并没有太大的区别。 文章目录Java系列文章目录1.什么是运算符2.什么是表达式3.算术运算符3.1 基本四则运算符：加减乘除模(+ - * / %)3.1.1 除法 /3
JavaSE面试要点四——异常
qq_53999369的博客
05-27 285
异常异常异常的概念异常的分类异常的处理try、catch和finallythrows抛出方法重写中的异常处理（父类捕获子类异常）异常的刨根问底java异常的处理机制throw和throws的区别final、finally、finalize 的区别？Java中异常分为哪些种类？error和exception的区别？说出最常见的5个RuntimeException？java 中如何编写自定义异常？父线程可以捕获子线程的异常么?
JavaSE（九）——异常
xiaokuer_的博客
06-04 725
文章介绍了异常的概念、异常的体系以及异常的处理方式等知识，干货满满！
JavaSE基础——异常处理
冰羽
07-30 233
JavaSE基础——异常处理 文章目录JavaSE基础——异常处理一、什么是异常？二、Error与Exception1. Error2. Exception3. Error与Exception的区别三、异常的处理1. 异常处理的关键字2. 捕获异常3. 抛出异常4. 自定义异常四、通用异常五、总结 一、什么是异常？ 表示程序在运行过程中出现的非正常情况，编写代码的过程中尽可能少的减少异常出现的情况。 异常是程序中的一些错误，但并不是所有的错误都是异常，并且错误有时候是可以避免的。 产生异常的原因: 用户
JAVASE零基础入门——JAVA语言简介
weixin_45989875的博客
03-01 311
JAVASE零基础入门系列之JAVA语言简介，帮助初学者快速了解并且入门JAVA
javaSE第六章——异常
m0_53679492的博客
09-02 197
javaSE第六章——异常 文章目录javaSE第六章——异常java异常概念异常的体系异常处理trycatchfinallythrowsthrowthrows和throw自定义异常 java异常概念 在使用计算机语言进行项目开发的过程中，即使程序员把代码写得尽善 尽美，在系统的运行过程中仍然会遇到一些问题，因为很多问题不是靠 代码能够避免的，比如：客户输入数据的格式，读取文件是否存在，网 络是否始终保持通畅等等。 异常：在java语言中，将程序执行中发生的不正常情况称为“异常”。 java程序在执行过程中
传智播客毕向东JavaSE课件
07-23
2. **Java语法基础**：包括数据类型（基本类型和引用类型）、变量、运算符、流程控制（条件语句和循环结构）、数组等基础知识。学习者将学会编写简单的Java程序并理解程序运行机制。 3. **面向对象编程**：这是Java...
java 基础知识储备（csdn）————程序.pdf
12-01
- **JavaSE**（Standard Edition）：适用于桌面应用和控制台开发，是Java的基础和核心。 - **JavaME**（Micro Edition）：针对嵌入式设备，如手机和小家电，目前在移动领域已不再主流。 - **JavaEE**（Enterprise...
jvm监控工具一览
大东码字
08-22 217
用于生成堆转储（heap dump），以及显示内存使用情况，适用于内存问题的分析，比如内存泄漏或 GC 问题。：用于查看和设置运行中的 JVM 的配置信息，比如系统属性和 JVM 选项，适用于 JVM 参数调优和问题诊断。：无侵入式的动态监控工具，可以实时插入脚本进行方法追踪、字段访问等操作，适用于各种动态监控需求。：实时显示 JVM 性能统计信息，包括 GC、内存、类加载等信息，常用于性能监控和调优。：用于输出 JVM 当前所有线程的堆栈跟踪信息，帮助分析线程状态、死锁等问题。
【JVM】详解Java中的垃圾回收
最新发布
hcjdhsjs的博客
08-22 529
详解Java中的自动内存管理--垃圾回收。在传统的编程语言中，内存的管理通常需要由开发人员手动进行分配和释放。这种手动管理容易导致一系列问题，例如内存溢出（内存不足时继续申请内存）和内存泄漏（已不再使用的内存未被释放）。这些问题可能导致程序的不稳定，甚至崩溃。然而，Java通过引入垃圾回收（Garbage Collection，简称GC）机制，实现了自动内存管理。垃圾回收机制主要针对堆内存中的对象进行管理，其核心功能是自动分配和回收不再使用的对象的内存。
浅谈垃圾回收机制
suuijbd的博客
08-18 298
但过度频繁的垃圾回收可能会影响程序的性能，因此在实际开发中需要合理优化对象的创建和使用，以减少不必要的垃圾回收操作。2、复制算法：将内存分成两块，每次只使用其中一块，当一块内存使用完成后，将仍存活的对象复制到另一块内存，并把使用过的内存清理掉。例如，如果频繁使用该算法，可能导致内存空间被分割成许多不连续的小块，影响后续大对象的分配。4、分代收集算法：根据对象的生命周期将对象分为新生代和老生代，不同的代采用不同的算法。3、标记-压缩算法：在标记完成后，将存活的对象向一端移动，清理端边界以外的对象内存。
JVM 类加载机制
m0_51607909的博客
08-19 1323
分类说明启动类加载器负责加载目录中的核心类库，如等；负责加载被参数所指定的路径中的，并且是虚拟机识别的类库；这个加载器是C++编写的，随着JVM启动。扩展类加载器负责加载目录中的类库；也可以加载用系统变量来指定路径目录中的类库。系统类加载器负责加载用户类路径classpath上所有的jar包和.class文件。自定义类加载器可以支持一些个性化的扩展功能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

马上回来了

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值