Javase学习16-异常

最新推荐文章于 2024-11-12 21:14:07 发布
最新推荐文章于 2024-11-12 21:14:07 发布
阅读量190 收藏 1
点赞数
分类专栏： Javase 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TSCCG/article/details/117871889
版权

文章目录

学习16-异常

1. 异常概述

1.1 什么是异常？有什么用？

当程序执行过程中出现了不正常的情况，这种不正常的情况就叫做***异常***

如果一门语言在程序出现了异常时，没有提示任何信息，那么这门语言就是失败的语言。

Java语言提供了异常处理机制，在程序出现异常时，jvm将该异常信息打印输出到控制台，供程序员参考。程序员根据异常信息修改程序，增加程序的健壮性。

/**
 * @Author TSCCG
 * @Date 2021/6/3 15:32
 */

public class ExceptionDemo01 {
    public static void main(String[] args) {
        int i = 20;
        int j = 0;
        int num = i / j;
        System.out.println(num);


    }
}

运行：

Exception in thread "main" java.lang.ArithmeticException: / by zero
	at ExceptionDemo01.main(ExceptionDemo01.java:10)

1.2 异常的存在形式

在Java中异常是以类和对象的形式存在的，任何一个异常类都可以创建异常对象

/**
 * @Author TSCCG
 * @Date 2021/6/3 15:32
 */

public class ExceptionDemo01 {
    public static void main(String[] args) {
        //创建异常对象
        ArithmeticException ex = new ArithmeticException("发生了异常！");
        System.out.println(ex);
    }
}

结果：

java.lang.ArithmeticException: 发生了异常！

当发生异常时，jvm就会自动创建一个异常对象，然后抛出

public class ExceptionDemo01 {
    public static void main(String[] args) {
        //JVM执行到此处时，检查到异常，创建异常对象： new ArithmeticException("/ by zero");
        //然后JVM将创建的对象抛出，打印输出信息到控制台。
        System.out.println(50/0);

    }
}

2. 异常的分类

  • Object(顶级父类)
    • Throwable(可抛出的)
      • Exception(可处理的)
        • Exception除RuntimeException及其所有子类外的其他所有子类都叫编译时异常。(编译时异常不是在编译阶段发生的异常，而是表示必须在编译程序的时候预先对这种异常进行处理，如果不处理，编译器就报错)
        • RuntimeException及其所有子类都叫运行时异常。(运行时异常在编写程序阶段可以选择处理，也可以选择不处理)
      • Error(不可处理，直接退出JVM)

所有的异常都发生在运行阶段，因为只有当程序运行时才能创建异常对象

异常继承UML图：

01异常继承图

UML图链接：https://www.processon.com/view/60bb6adc07912941e204c79d

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

脑图链接：https://www.processon.com/view/60bc1d811e08533a509c0b5f#map

2.1 编译时异常 (checkedException)

Exception除了RuntimeException及其所有子类外，其他所有子类都叫做编译时异常。编译时异常也叫受检异常(CheckedException)或受控异常。
编译时异常不是在编译阶段发生的异常，而是表示必须在编译程序的时候预先对这种异常进行处理，如果不处理，编译器就报错，无法运行。
编译时异常发生的概率较高，就好比出门时外面正在下暴雨。如果不打伞，那么生病的概率就很高，为了避免生病，就要提前准备一把雨伞。

常见的编译时异常：

异常类名释义
IOException输入输出流异常
FileNotFoundException文件找不到的异常
ClassNotFoundException类找不到异常
DataFormatException数据格式化异常
NoSuchFileldException没有匹配的属性异常
NoSuchMethodException没有匹配的方法异常
SQLException数据库操作异常
TimeoutException执行超时异常

2.2 运行时异常 (uncheckedException)

RuntimeException及其所有子类都是运行时异常。运行时异常也叫未受检异常(UnCheckedException)或非受控异常。
运行时异常在编写程序阶段可以选择处理，也可以选择不处理。
运行时异常发生的概率较低，就好比出门时阳光明媚，之后突然下起了暴雨，无法提前预知。你在出门前不知道天气如何，可以提前准备一把雨伞，也可以不准备。

常见的运行时异常：

异常类名释义
IndexOutOfBoundsException抛出以表示某种索引（例如数组，字符串或向量）的索引超出范围
ClassCastException类型转换异常
NullPointerException空指针异常
IllegalAccessException非法的参数异常
InputMismatchException输入不匹配异常
ArithmeticException抛出异常算术条件时抛出。 例如，“除以零”的整数会抛出此类的一个实例

3. 异常的处理

Java语言中对异常的处理有两种方式：

  1. 使用try…catch语句将异常捕捉。
  2. 在方法声明的位置上，使用throws关键字将异常抛给上一级。谁调用我，我就抛给谁。

举例说明：

我是某饭店的一名服务员，一个失误，导致将菜拍在了顾客的脸上。顾客不满，要求索赔。”顾客要求索赔“可以看作是一个异常发生了。此时，我有两种处理方式：

  1. 我自己掏腰包对顾客进行赔偿。(异常的捕捉)

  2. 将这件事告诉我的上级领导(经理)。(异常上抛）

    我 ----(上抛)----> 经理 ----(上抛)----> 老板

异常发生后，如果我选择将异常上抛给我的调用者(经理)，那么我的调用者需要对这个异常继续进行处理，同样有这两种处理方式。

注意：

Java中异常发生后如果一直进行上抛，最终抛给main方法，main方法继续上抛，抛给调用者JVM，JVM知道这个异常发生，只会发生一种结果，那就是终止Java程序的执行。

3.1 try…catch

当程序发生异常时，会立即停止运行，无法继续向下执行。为了保证程序能有效的执行，Java中提供了一种对异常进行处理的方式——异常捕获。

3.1.1 异常捕获try…catch语句基本语法格式
try {
    //可能发生异常的语句
} catch (需要进行捕获的异常类型创建的异常对象) {
    //对捕获的异常进行相应处理
}

例子：

public class ExceptionDemo01 {
    public static void main(String[] args) {
        System.out.println(50/0);
        System.out.println("后面的语句");
    }
}

运行结果：

Exception in thread "main" java.lang.ArithmeticException: / by zero
	at ExceptionDemo01.main(ExceptionDemo01.java:3)

System.out.println(“后面的语句”);这行代码没有运行

可见当发生异常后如果不去解决就会影响后续语句的执行

使用try…catch对以上代码进行处理：

public class ExceptionDemo01 {
    public static void main(String[] args) {
        /*
          程序先运行try中的语句，如果没有发生异常，程序正常执行，不会执行catch中语句，
          如果发生了异常，会与catch中创建的异常对象进行匹配
          如果匹配，执行catch及后续语句
          如果不匹配，程序终止，不会执行catch及后续语句
         */
        try {
            System.out.println(50/0);
        } catch (ArithmeticException a) {
            //打印异常信息
            a.printStackTrace();
        } 
        System.out.println("后面的语句");

    }
}

java.lang.ArithmeticException: / by zero
	at ExceptionDemo01.main(ExceptionDemo01.java:10)
后面的语句
3.1.2 catch中创建异常对象的类型

catch后面小括号中的类型可以是具体的异常类型，也可以是该异常类型的父类型

import java.io.FileInputStream;
import java.io.FileNotFoundException;

/**
 * @Author: TSCCG
 * @Date: 2021/06/13 17:45
 */
public class ExceptionDemo04 {
    public static void main(String[] args) {
        System.out.println("main start");
        try {
            //创建输入流
            FileInputStream file = new FileInputStream("D:\\study\\实验系统网址密码.TX");
        } catch (IOException e) {//FileNotFoundException的父类,也可以写所有异常的父类Exception
            System.out.println("找不到文件");
        }
        System.out.println("main end");
    }
}
3.1.3 catch可以写多个

catch可以写多个，建议捕获异常的时候，一个一个精确处理，这样有利于程序的调试

第一种方法：

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/**
 * @Author: TSCCG
 * @Date: 2021/06/13 17:45
 */
public class ExceptionDemo04 {
    public static void main(String[] args) {
        System.out.println("main start");
        try {
            //创建输入流
            FileInputStream file = new FileInputStream("D:\\study\\实验系统网址密码.TX");
            //读文件
            file.read();
        } catch (FileNotFoundException e) {
            System.out.println("找不到文件");
        } catch (IOException e) {
            System.out.println("读不到文件");
        }
        System.out.println("main end");
    }
}

第二种方法：

jdk8的新特性，可以在catch中以 "异常类型 | 异常类型| 异常类型 变量 "的形式来创建异常对象

import java.io.FileInputStream;
import java.io.FileNotFoundException;

/**
 * @Author: TSCCG
 * @Date: 2021/06/13 17:45
 */
public class ExceptionDemo04 {
    public static void main(String[] args) {
        System.out.println("main start");
        try {
            //创建输入流
            FileInputStream file = new FileInputStream("D:\\study\\实验系统网址密码.TX");
            System.out.println(50 / 0);
        } catch (FileNotFoundException | ArithmeticException | NullPointerException e) {
            System.out.println("找不到文件 or 数字异常 or 空指针异常");
        }
        System.out.println("main end");
    }
}
3.1.4 catch写多个的时候，必须遵守从小到大

catch写多个的时候，创建异常对象的级别，从上到下，必须遵守从小到大的原则

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/**
 * @Author: TSCCG
 * @Date: 2021/06/13 17:45
 */
public class ExceptionDemo04 {
    public static void main(String[] args) {
        System.out.println("main start");
        try {
            //创建输入流
            FileInputStream file = new FileInputStream("D:\\study\\实验系统网址密码.TX");
            //读文件
            file.read();
        } catch (IOException e) {
            System.out.println("读不到文件");
        } catch (FileNotFoundException e) { //报错
            System.out.println("找不到文件");
        }
        System.out.println("main end");
    }
}

IOException是FileNotFoundException的父类，当创建FileInputStream对象出现异常时，第一个catch中的IOException可以对其进行捕获。执行第二个catch时，由于异常已经被捕获，无法再次进行捕获，故编译器报错。

3.1.5 finally
3.1.5.1 语法格式

finally无法单独使用，必须跟在try…catch语句后面。

try {
    //可能发生异常的语句
} catch (IOException e) {
    e.printStackTrace();
} finally {
    
}
3.1.5.2 finally适用场景

通常在finally语句块中完成资源的释放/关闭，因为finally中的代码比较有保障。

例子：

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/**
 * @Author: TSCCG
 * @Date: 2021/06/13 21:18
 */
public class ExceptionDemo06 {
    public static void main(String[] args) {
        FileInputStream file = null;
        try {
            //创建输入流对象
            file = new FileInputStream("D:\\study\\实验系统网址密码.TXT");
            //开始读文件。。。
            
            String s = null;
            s.toString();//这里一定会报空指针异常

            //流使用完需要关闭，因为流是占用资源的。如果上面的代码出现异常，那么流就无法关闭，这是非常危险的
            file.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } 
    }
}

结果：

Exception in thread "main" java.lang.NullPointerException
	at ExceptionDemo06.main(ExceptionDemo06.java:17)

使用finally进行处理

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/**
 * @Author: TSCCG
 * @Date: 2021/06/13 21:18
 */
public class ExceptionDemo06 {
    public static void main(String[] args) {
        FileInputStream file = null;
        try {
            //创建输入流对象
            file = new FileInputStream("D:\\study\\实验系统网址密码.TXT");
            //开始读文件。。。

            String s = null;
            s.toString();//这里一定会报空指针异常

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } finally {
            //不管是否发生异常，finally里的语句都会执行。
            System.out.println("阿巴巴巴");
            try {
                //如果创建流对象失败，那么file在这里仍会是null，会报空指针异常。所以使用if判断避免
                if (file != null ) {
                    //close()方法有异常，采用捕捉的方式
                    file.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

结果：

阿巴巴巴
Exception in thread "main" java.lang.NullPointerException
	at ExceptionDemo06.main(ExceptionDemo06.java:18)
3.1.5.3 finally语句段在程序中的执行

finally语句一定会执行

try和finally，没有catch也可以执行

例子：

public static void main(String[] args) {
    try {
        System.out.println("---try---");
        //结束方法
        return;
    } finally {
        //finally语句即使在try中存在return语句也会执行
        System.out.println("---finally---");
    }
    //以下执行不到，因为在try中执行了return,方法结束
    System.out.println("Hello");
｝

结果：

---try---
---finally---

以上代码执行顺序：

先执行—try—

再执行—finally—

最后执行return(return只要执行，方法一定会结束)

3.1.5.4 finally面试题

以下代码输出什么数？

/**
 * @Author: TSCCG
 * @Date: 2021/06/14 09:36
 */
public class ExceptionDemo09 {
    public static void main(String[] args) {
        System.out.println(m1());
    }
    public static int m1() {
        int i = 100;
        try {
            return i;
        }finally {
            i++;
        }
    }
}

结果：

100

java中语法规则：

  • 方法体中的代码必须遵守自上而下的顺序依次逐行执行
  • return语句一旦执行，整个方法必须结束

return i; 语句出现在int i = 100后面，所以最终结果必须是返回100

return语句必须保证是最后执行的，一旦执行，整个方法结束。

反编译class文件：

public static int m1() {
    int i = 100;
    try {
        int n = i;
        return n;
    }
    finally {
        ++i;
    }
}

可见，在try语句中先将i赋给一个临时变量n，然后执行finally语句中的++i，最后将n返回

3.1.5.5 退出JVM finally语句不执行
public static void main(String[] args) {
    try {
        System.out.println("---try---");
        System.exit(0);
    } finally {
        System.out.println("---finally---");
    }
}

结果：

---try---

3.2 throws关键字

一般在程序开发中，开发者通常会意识到程序可能出现的问题，可以直接通过try…catch对异常进行捕获处理。但有些时候，方法中的代码是否会出现异常，开发者并不明确或不急于处理，为此，Java允许将这种异常从当前方法中抛出，然后让后续的调用者在使用时进行异常处理。

格式:

一般将throws关键字写在方法声明的后面，并需要在后面声明方法中发生的异常类型

例子：

main方法将异常继续上抛给JVM

/**
 * @Author: TSCCG
 * @Date: 2021/06/13 11:14
 * throws关键字
 * 用来在方法的声明上去声明抛出异常，多个异常类名中间用逗号分隔
 */
public class ExceptionDemo02 {
    public static void main(String[] args) throws Exception {
        division(50,0);
    }
    public static int division(int a, int b) throws Exception{
        return a / b;
    }

}

结果：

Exception in thread "main" java.lang.ArithmeticException: / by zero
	at ExceptionDemo02.division(ExceptionDemo02.java:10)
	at ExceptionDemo02.main(ExceptionDemo02.java:7)

main方法使用try…catch对异常进行处理

/**
 * @Author: TSCCG
 * @Date: 2021/06/13 11:14
 * throws关键字
 * 用来在方法的声明上去声明抛出异常，多个异常类名中间用逗号分隔
 */
public class ExceptionDemo02 {
    public static void main(String[] args){
        try {
            division(50,0);
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("后续语句");
    }
    public static int division(int a, int b) throws Exception{
        return a / b;
    }

}

结果：

java.lang.ArithmeticException: / by zero
	at ExceptionDemo02.division(ExceptionDemo02.java:15)
	at ExceptionDemo02.main(ExceptionDemo02.java:8)
后续语句

可见，throws就是将异常不断地上抛，在将异常上抛后，不会执行后面的语句

4. 异常对象的常用方法

异常对象有两个非常重要的方法：

方法名作用
getMessage()获取异常简单的描述信息
printStackTrace()打印异常追踪的堆栈信息(一般用这个)

实例演示：

import java.io.FileInputStream;
import java.io.FileNotFoundException;

/**
 * @Author: TSCCG
 * @Date: 2021/06/13 20:11
 */
public class ExceptionDemo05 {
    public static void main(String[] args) {
        try {
            m1();
        } catch (FileNotFoundException e) {
            //打印异常信息是必须的，不然很难知道出现的错误
            System.out.println("---------获取异常简单描述信息---------");
            System.out.println(e.getMessage());
            System.out.println("---------打印异常追踪的堆栈信息---------");
            e.printStackTrace();
        }
    }

    private static void m1() throws FileNotFoundException {
        m2();
    }

    private static void m2() throws FileNotFoundException {
        m3();
    }

    private static void m3() throws FileNotFoundException {
        new FileInputStream("D:\\study\\实验系统网址密码.TX");
    }
}

结果：

---------获取异常简单描述信息---------
D:\study\实验系统网址密码.TX (系统找不到指定的文件。)
---------打印异常追踪的堆栈信息---------
java.io.FileNotFoundException: D:\study\实验系统网址密码.TX (系统找不到指定的文件。)
	at java.io.FileInputStream.open0(Native Method)
	at java.io.FileInputStream.open(FileInputStream.java:195)
	at java.io.FileInputStream.<init>(FileInputStream.java:138)
	at java.io.FileInputStream.<init>(FileInputStream.java:93)
	at ExceptionDemo05.m3(ExceptionDemo05.java:29)
	at ExceptionDemo05.m2(ExceptionDemo05.java:25)
	at ExceptionDemo05.m1(ExceptionDemo05.java:21)
	at ExceptionDemo05.main(ExceptionDemo05.java:11)

如何查看异常信息？

在打印出的异常追踪堆栈信息中，我们只需要看我们自己写的部分即可

如上面打印的结果中，从at ExceptionDemo05.m3(ExceptionDemo05.java:29)这行开始出现我们自己写的东西，那么就从这行开始，从上往下看。

第29行的代码出现异常，导致第25行也出现异常

第25行出现异常，导致21行也异常

第21行异常，导致11行异常

从而可得知，第29行代码是异常的根源，只需要修改第29行代码即可解决异常

5. 自定义异常

SUN公司提供的JDK内置异常是不够用的。在实际开发中，有很多业务，出现异常后，很多JDK中是没有的。这时，我们可以自定义异常类。

5.1 如何自定义异常类

查看异常类源码得知，异常类的结构都是继承一个异常父类，由一个无参构造方法和一个带有String参数的构造方法组成的。

故我们自定义异常的步骤有两步：

  1. 编写一个类继承Exception或RuntimeException
  2. 提供来年规格构造方法，一个无参数，一个带有String参数
public class MyException extends Exception{
    public MyException() {
    }
    public MyException(String s) {
        super(s);
    }
}

调用自定义异常类：

public class ExceptionDemo10 {
    public static void main(String[] args) {
        MyException e = new MyException("异常信息");
        System.out.println(e.getMessage());
        e.printStackTrace();
    }
}

结果：

异常信息
MyException: 异常信息
	at ExceptionDemo10.main(ExceptionDemo10.java:8)
vue2文件流下载成功后文件格式错误、打不开、内容缺失
Salt_NaCl的博客
02-14 6139
文档流问题
JavaSe笔记2021-8-2
08-02
【JavaSe笔记2021-8-2】是一份关于Java Standard Edition（JavaSE）的详细学习记录，涵盖了2021年8月2日的学习重点。在Java编程领域，JavaSE是基础，它是Java平台的核心部分，用于开发桌面应用、服务器端应用以及...
java常见错误以及可能原因总结
meifage的专栏
11-14 4421
0 、 需要标识符 a) 不在函数内 1、 非法表达式开始 b) 可能:丢失括号 . 2. no data found a) 可能:setInt(1,100)中,没有100这个值 3. 找不到符号 a) 可能:没导入包 4. 指定了无效URL a) 可能:数据库名或IP错误,即连接出错 5. 类路径没有找到 a) 可能: ClassN
Java学习---JavaSE----异常处理
m0_47274301的博客
09-24 215
异常机制 Java把异常当作对象来处理，并定义一个基类java.lang.Throwable作为所有异常的超类。 在Java API中已经定义了许多异常类，这些异常类分为两大类，错误Error和异常Exception. Error Error类对象由Java虚拟机生成并抛出，大多数错误与代码编写者所执行的操作无关。 Java虚拟机运行错误(Virtual MachineError)，当JVM不再有继续执行操作所需的内存资源时，将出现OutOfMemoryError。这些异常发生时，Java虚拟
JAVASE学习---第六天
2401_88290955的博客
10-28 66
JAVA三大特性之一，封装为了保护数据安全以及复用性。封装属性，对面提供访问方法。例如：getter、setter方法。代表当前对象的内存地址，this被存储在实例方法局部变量表的0号槽位,也指向堆内存中的对象内存地址;发生在引用指向null，程序访问对象属性或者调用对象方法发生空指针异常;通过ORACEL官网---查看JVM规范---学习更多知识。学习内容：空指针异常、方法传递参数问题、this关键字、封装。只记住一句话即传递的是变量存储的值;
Javase学习16.1-异常练习_用户注册
TSCCG的博客
06-16 131
Javase学习16.1-异常练习_用户注册 1. 需求描述 程序开始执行时，提示用户输入用户名、密码信息 输入信息后，后台模拟用户注册 注册时要求用户名和密码都在[6～14]之间，且不能为null，不然都需要抛出异常 完成注册的方法放到一个单独的类里 使用自定义异常类 class UserService { public void register(String username, String password) { //用户注册 } } 编写main方法，在main方法
JavaSE-进阶-学习笔记-JUC
qq_52668773的博客
04-03 2142
​ 管程 (英语：Monitors，也称为监视器) 是一种程序结构，结构内的多个子程序（对象或模块）形成的多个工作线程互斥访问共享资源。​ 这些共享资源一般是硬件设备或一群变量。对共享变量能够进行的所有操作集中在一个模块中。（把信号量及其操作原语“封装”在一个对象内部）管程实现了在一个时间点，最多只有一个线程在执行管程的某个子程序。管程提供了一种机制，管程可以看做一个软件模块，它是将共享的变量和对于这些共享变量的操作封装起来，形成一个具有一定接口的功能模块，进程可以调用管程来实现进程级别的并发控制。
《JavaSE》---18.＜异常处理＞
m0_73456341的博客
07-20 1192
本篇博客主要讲解Java基础语法中的 一、异常的基础知识 异常的概念、异常的体系结构、异常的分类 二、异常的处理 防御式编程、异常处理主要的5个关键字：、异常的抛出、异常的捕获（重点）、异常声明throws　、快捷键（alt + Insert）、try-catch捕获并处理、finally关键字 【面试题】： 1. throw 和 throws 的区别、2. finally中的语句一定会执行吗？ 异常的处理流程、自定义异常类
JavaSE-异常
2301_79272029的博客
05-22 645
异常就是代表程序出现的问题学习异常是为了在面对程序出现异常时，能够处理异常编译时期异常在编译时，有一些方法会有红色下波浪线，我们需要手动把异常抛出才可以继续编译和运行这就是编译时异常，特点是需要手动处理，否则代码报错编译时异常是用来提醒程序员在编写代码时要注意检查本地信息运行时期异常在编译时没什么事，但是当运行时代码会报错，这就是运行时异常（如数组访问越界）运行时异常在编译阶段是不需要做任何处理的，是运行时出现的异常运行时异常是代码出错而导致出现的问题。
JavaSE面试题-含答案.pdf
01-29
面试中，JavaSE的相关知识通常包括语言基础、内存管理、集合框架、多线程、异常处理、I/O流等核心概念。以下是对这些知识点的详细说明： ### 第一章 初识Java 1. **Java跨平台原理**：Java的跨平台特性基于&ldquo;一次...
JavaSE小项目---客户管理系统
03-21
在本JavaSE小项目——...总的来说，这个JavaSE小项目是学习和实践面向对象编程、控制台交互、数据管理等基础技能的一个良好平台。通过这个项目，开发者可以加深对Java语言的理解，并掌握如何构建一个简单的业务应用。
java源码剖析-javase-base-resource:从源码角度剖析不一样的JavaSE，对应博文请访问
05-19
在JavaSE的学习过程中，以下几个关键知识点值得深入探讨： 1. **对象与类**：Java是一种面向对象的语言，理解类的定义、对象的创建、继承、封装和多态性至关重要。源码分析将帮助你理解这些概念的实际运用。 2. **...
JavaSE_JavaSE学习资料_
10-02
总的来说，这个JavaSE学习资料包将引导开发者全面地学习Java语言的核心特性，掌握基本编程技巧，理解并运用集合框架、IO流等关键概念，从而具备开发高效、稳定的Java应用程序的能力。随着对JavaSE的深入学习，开发者...
JavaSE学习----（五）面向对象三大特征：封装、继承、多态 深度解析
qq_61899969的博客
08-29 648
深度解读了面向对象的三大特征：封装、继承、多态。也讲解了方法重写的内容。
JavaSE学习笔记之-----异常处理
彦帅的博客
07-23 580
JavaSE学习笔记之异常处理
日常bug记录，easyexcel导入报错convert data ... to class java.math.BigDecimal error
mm
11-11 205
排查发现实体类中有BigDecimal属性，然而数据中这个属性为null，进行转换时报错。在实体类上加上自定义转换器。解决方法：自定义转换器类。
1112--接口
最新发布
kequanrrr的博客
11-12 145
interface + 接口名{ }。。。。implements 接口名{ }接口：接口中的抽象方法可以省略 abstract 关键字使用：要实现接口中的所有 抽象方法隐含三个修饰符：public+static+final2.单继承 多接口。
JavaSE编程基础与集合框架学习资料
以上知识点是JavaSE学习的核心内容，适合初学者系统地进行学习，并为后续深入JavaEE、Spring框架等高级技术的学习打下坚实的基础。学习JavaSE的过程不仅是掌握一种编程语言的过程，更是培养良好的编程习惯和解决问题...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

TSCCG

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

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

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

打赏作者

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

抵扣说明：

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

余额充值