JavaSE从基础到入门：异常的学习

已于 2023-01-05 15:56:22 修改
阅读量196 收藏
点赞数
分类专栏： 手把手学JavaSE 文章标签： 学习 jvm java
于 2023-01-04 16:57:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_66030479/article/details/128548944
版权

1. 异常的概念与体系结构

1.异常的概念

  • 异常（Exception）指不期而至的各种状况，异常发生的原因有很多，通常包含以下几大类：
    • 用户输入了非法数据。
    • 要打开的文件不存在。
    • 网络通信时连接中断，或者JVM内存溢出。
  • 异常是一个事件，它发生在程序运行期间，干扰了正常的指令流程。
  • Java语言在设计的当初就考虑到这些问题，提出异常处理的框架的方案，所有的异常都可以用一个异常类来表示，不同类型的异常对应不同的子类异常（目前我们所说的异常包括错误概念），定义异常处理的规范，在 JDK1.4 版本以后增加了异常链机制，从而便于跟踪异常。
  • Java异常是一个描述在代码段中发生异常的对象，当发生异常情况时，一个代表该异常的对象被创建并且在导致该异常的方法中被抛出，而该方法可以选择自己处理异常或者传递该异常。
  • Java异常处理本质：抛出异常和捕获异常。

分类：

  • **检查性异常：**最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。
  • 运行时异常： 运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。
  • 错误： 错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。

2.异常的体系结构

在这里插入图片描述

  1. Throwable：是异常体系的顶层类，其派生出两个重要的子类, Error 和 Exception。

  2. Error：指的是Java虚拟机无法解决的严重问题，比如：JVM的内部错误、资源耗尽等，典型代表：StackOverflowError和OutOfMemoryError，一旦发生回力乏术。

  3. Exception：异常产生后程序员可以通过代码进行处理，使程序继续执行。比如：感冒、发烧。我们平时所说的异常就是Exception。

3.异常的分类

编译时异常
在程序编译期间发生的异常，称为编译时异常，也称为受检查异常。
运行时异常
在程序执行期间发生的异常，称为运行时异常，也称为非受检查异常。

2.异常的处理

  1. LBYL:在操作之前就做充分的检查. 即：事前防御型
  2. EAFP:“事后获取原谅比事前获取许可更容易”. 也就是先操作, 遇到问题再处理. 即：事后认错型

LBYL

boolean ret = false;
ret = 登陆游戏();
if (!ret) {
	处理登陆游戏错误;
	return;
}
ret = 开始匹配();
if (!ret) {
	处理匹配错误;
	return;
}
ret = 游戏确认();
if (!ret) {
	处理游戏确认错误;
	return;
}
ret = 选择英雄();
if (!ret) {
	处理选择英雄错误;
	return;
}
ret = 载入游戏画面();
if (!ret) {
	处理载入游戏错误;
	return;
}

EAFP

try {
	登陆游戏();
	开始匹配();
	游戏确认();
	选择英雄();
	载入游戏画面();
...
} catch (登陆游戏异常) {
	处理登陆游戏异常;
} catch (开始匹配异常) {
	处理开始匹配异常;
} catch (游戏确认异常) {
	处理游戏确认异常;
} catch (选择英雄异常) {
	处理选择英雄异常;
} catch (载入游戏画面异常) {
	处理载入游戏画面异常;
}
......

java异常处理主要的5个关键字：throw、try、catch、final、throws。

1.异常的抛出

在编写程序时，如果程序中出现错误，此时就需要将错误的信息告知给调用者，比如：参数检测。
在Java中，可以借助throw关键字，抛出一个指定的异常对象，将错误信息告知给调用者。具体语法如下：

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

举例：
在某仓库管理系统中，要求管理员的用户名需要由 8 位以上的字母或者数字组成，不能含有其他的字符。当长度在 8 位以下时拋出异常，并显示异常信息；当字符含有非字母或者数字时，同样拋出异常，显示异常信息。代码如下：

import java.util.Scanner;
public class Test {
    public boolean validateUserName(String username) {
        boolean con = false;
        if (username.length() > 8) {
            // 判断用户名长度是否大于8位
            for (int i = 0; i < username.length(); i++) {
                char ch = username.charAt(i); // 获取每一位字符
                if ((ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')) {
                    con = true;
                } else {
                    con = false;
                    throw new IllegalArgumentException("用户名只能由字母和数字组成！");
                }
            }
        } else {
            throw new IllegalArgumentException("用户名长度必须大于 8 位！");
        }
        return con;
    }
    public static void main(String[] args) {
        Test05 te = new Test();
        Scanner input = new Scanner(System.in);
        System.out.println("请输入用户名：");
        String username = input.next();
        try {
            boolean con = te.validateUserName(username);
            if (con) {
                System.out.println("用户名输入正确！");
            }
        } catch (IllegalArgumentException e) {
            System.out.println(e);
        }
    }
}

如上述代码，在 validateUserName() 方法中两处拋出了 IllegalArgumentException 异常，即当用户名字符含有非字母或者数字以及长度不够 8 位时。在 main() 方法中，调用了 validateUserName() 方法，并使用 catch 语句捕获该方法可能拋出的异常。

【注意事项】

  1. throw必须写在方法体内部。
  2. 抛出的对象必须是Exception 或者 Exception 的子类对象。
  3. 如果抛出的是 RunTimeException 或者 RunTimeException 的子类，则可以不用处理，直接交给JVM来处理。
  4. 如果抛出的是编译时异常，用户必须处理，否则无法通过编译。
  5. 异常一旦抛出，其后的代码就不会执行。

2.异常的捕获

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

1.异常声明throws

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

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

}

注意要加载指定的配置文件config.ini

public class Config {
	File file;
	/*
	FileNotFoundException : 编译时异常，表明文件不存在
	此处不处理，也没有能力处理，应该将错误信息报告给调用者，让调用者检查文件名字是否给错误了
	*/
	public void OpenConfig(String filename) throws FileNotFoundException{
		if(filename.equals("config.ini")){
			throw new FileNotFoundException("配置文件名字不对");
		}
	
	// 打开文件
	}
	public void readConfig(){
	
	}
}

【注意事项】

  1. throws必须跟在方法的参数列表之后。
  2. 声明的异常必须是 Exception 或者 Exception 的子类。
  3. 方法内部如果抛出了多个异常，throws之后必须跟多个异常类型，之间用逗号隔开，如果抛出多个异常类型具有父子关系，直接声明父类即可。
public class Config {
	File file;
	// public void OpenConfig(String filename) throwsIOException,FileNotFoundException{
	// FileNotFoundException 继承自 IOException
	public void OpenConfig(String filename) throws IOException{
		if(filename.endsWith(".ini")){
			throw new IOException("文件不是.ini文件");
		}
		if(filename.equals("config.ini")){
			throw new FileNotFoundException("配置文件名字不对");
		}
		// 打开文件
	}
	public void readConfig(){
	}
}
  1. 调用声明抛出异常的方法时，调用者必须对该异常进行处理，或者继续使用throws抛出。
public static void main(String[] args) throws IOException {
	Config config = new Config();
	config.openConfig("config.ini");
}

2.try-catch捕获并处理

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

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

需求：读取配置文件，如果配置文件名字不是指定名字，抛出异常，调用者进行异常处理。

public class Config {
	File file;
	public void openConfig(String filename) throws FileNotFoundException{
		if(!filename.equals("config.ini")){
			throw new FileNotFoundException("配置文件名字不对");
		}
	// 打开文件
	}
	public void readConfig(){
	}
	public static void main(String[] args) {
		Config config = new Config();
	try {
		config.openConfig("config.txt");
		System.out.println("文件打开成功");
	} catch (IOException e) {
		// 异常的处理方式
		//System.out.println(e.getMessage()); // 只打印异常信息
		//System.out.println(e); // 打印异常类型：异常信息
		e.printStackTrace(); // 打印信息最全面
	}
	// 一旦异常被捕获处理了，此处的代码会执行
	System.out.println("异常如果被处理了，这里的代码也可以执行");
	}
}

关于异常的处理方式
异常的种类有很多, 我们要根据不同的业务场景来决定。
对于比较严重的问题(例如和算钱相关的场景), 应该让程序直接崩溃, 防止造成更严重的后。
对于不太严重的问题(大多数场景), 可以记录错误日志, 并通过监控报警程序及时通知程序猿。
对于可能会恢复的问题(和网络相关的场景), 可以尝试进行重试。
在我们当前的代码中采取的是经过简化的第二种方式. 我们记录的错误日志是出现异常的方法调用信息, 能很快速的让我们找到出现异常的位置. 以后在实际工作中我们会采取更完备的方式来记录异常信息。

【注意事项】

  1. try块内抛出异常位置之后的代码将不会被执行。
  2. 如果抛出异常类型与catch时异常类型不匹配，即异常不会被成功捕获，也就不会被处理，继续往外抛，直到JVM收到后中断程序----异常是按照类型来捕获的。
public static void main(String[] args) {
	try {
		int[] array = {1,2,3};
		System.out.println(array[3]); // 此处会抛出数组越界异常
	}catch (NullPointerException e){ // 捕获时候捕获的是空指针异常--真正的异常无法被捕获到
		e.printStackTrace();
	}
	System.out.println("后序代码");
}


Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3
at day20210917.ArrayOperator.main(ArrayOperator.java:24)
  1. try中可能会抛出多个不同的异常对象，则必须用多个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 (ArrayIndexOutOfBoundsException e) {
		System.out.println("这是个数组下标越界异常");
		e.printStackTrace();
	} catch (NullPointerException e) {
		System.out.println("这是个空指针异常");
		e.printStackTrace();
	}
	System.out.println("after try catch");
}

如果多个异常的处理方式是完全相同, 也可以写成这样：

catch (ArrayIndexOutOfBoundsException | NullPointerException e) {
	...
}

如果异常之间具有父子关系，一定是子类异常在前catch，父类异常在后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) { // Exception可以捕获到所有异常
		e.printStackTrace();
	}catch (NullPointerException e){ // 永远都捕获执行到
		e.printStackTrace();
	}
	System.out.println("after try catch");
}

Error:(33, 10) java: 已捕获到异常错误java.lang.NullPointerException
  1. 可以通过一个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();
	}
	System.out.println("after try catch");
}

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

备注: catch 进行类型匹配的时候, 不光会匹配相同类型的异常对象, 也会捕捉目标异常类型的子类对象. 如刚才的代码,
NullPointerException 和 ArrayIndexOutOfBoundsException 都是Exception的子类,因此都能被捕获到.

3. finally

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

语法格式：
try{
	// 可能会发生异常的代码
}catch(异常类型 e){
	// 对捕获到的异常进行处理
}finally{
	// 此处的语句无论是否发生异常，都会被执行到
}

// 如果没有抛出异常，或者异常被捕获处理了，这里的代码也会执行

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-catch-finally之后的代码根本就没有执行，即输入流就没有被释放，造成资源泄漏。

注意：finally中的代码一定会执行的，一般在finally中进行一些资源清理的扫尾工作。

finally 执行的时机是在方法返回之前(try 或者 catch 中如果有 return 会在这个 return 之前执行 finally). 但是如果finally 中也存在 return 语句, 那么就会执行 finally 中的 return, 从而不会执行到 try 中原有的 return.

一般我们不建议在 finally 中写 return (被编译器当做一个警告).

4.throw 和 throws 的区别？

共同点

两者在抛出异常时，抛出异常的方法并不负责处理，顾名思义，只管抛出，由调用者负责处理。

区别

  1. throws用于方法头，表示的只是异常的申明，而throw用于方法内部，抛出的是异常对象。
  2. throws可以一次性抛出多个异常，而throw只能一个。
  3. throws抛出异常时，它的上级（调用者）也要申明抛出异常或者捕获，不然编译报错。而throw的话，可以不申明或不捕获（这是非常不负责任的方式）但编译器不会报错。

3.异常的处理流程

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

如果本方法中没有合适的处理异常的方式, 就会沿着调用栈向上传递。

【异常处理流程总结】

  • 程序先执行 try 中的代码.
  • 如果 try 中的代码出现异常, 就会结束 try 中的代码, 看和 catch 中的异常类型是否匹配.
  • 如果找到匹配的异常类型, 就会执行 catch 中的代码.
  • 如果没有找到匹配的异常类型, 就会将异常向上传递到上层调用者.
  • 无论是否找到匹配的异常类型, finally 中的代码都会被执行到(在该方法结束之前执行). 如果上层调用者也没有处理的了异常,就继续向上传递.
  • 一直到 main 方法也没有合适的代码处理异常, 就会交给 JVM 来进行处理, 此时程序就会异常终止.

3.自定义异常

如果 Java 提供的内置异常类型不能满足程序设计的需求，这时我们可以自己设计 Java 类库或框架，其中包括异常类型。实现自定义异常类需要继承 Exception 类或其子类，如果自定义运行时异常类需继承 RuntimeException 类或其子类。

自定义异常的语法形式为：

<class><自定义异常名><extends><Exception>

在编码规范上，一般将自定义异常类的类名命名为 XXXException，其中 XXX 用来代表该异常的作用。

自定义异常类一般包含两个构造方法：一个是无参的默认构造方法，另一个构造方法以字符串的形式接收一个定制的异常消息，并将该消息传递给超类的构造方法。

具体方式：

  1. 自定义异常类，然后继承自Exception 或者 RunTimeException。
  2. 实现一个带有String类型参数的构造方法，参数含义：出现异常的原因。

以登录界面举例：

public class Test {

    public String name = "wjh";
    public String passworld = "123456";

    public void login(String name,String passworld) throws UserNameException {
        if(!this.name.equals(name)) {
            System.out.println("用户名错误！");
            throw new UserNameException();
        }
        if(!this.passworld.equals(passworld)) {
            System.out.println("用户密码错误！");
            throw new PassWorldException();
        }
    }
}

此时我们在处理用户名密码错误的时候可能就需要抛出两种异常. 我们可以基于已有的异常类进行扩展(继承), 创建和我们业务相关的异常类.

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

public class PassWorldException extends RuntimeException {
    public PassWorldException() {
        super();
    }
    public PassWorldException(String s) {
        super(s);
    }

此时我们的 代码可以改成

public class Test {

    public String name = "wjh";
    public String passworld = "123456";

    public void login(String name,String passworld) throws UserNameException {
        if(!this.name.equals(name)) {
            System.out.println("用户名错误！");
            throw new UserNameException("兄弟，你的用户名错了！");
        }
        if(!this.passworld.equals(passworld)) {
            System.out.println("用户密码错误！");
            throw new PassWorldException("兄弟，你的用户密码 错了！");
        }
    }


    public static void main(String[] args) {
        Test test1 = new Test();
        try {
            test1.login("wjhw","123456");
        } catch (UserNameException e) {
            e.printStackTrace();
            System.out.println("用户名异常!");
        }catch (PassWorldException passWorldException) {
            passWorldException.printStackTrace();
            System.out.println("用户密码异常！");
        }finally {
        }
    }
}

注意事项

  • 自定义异常通常会继承自 Exception 或者 RuntimeException。
  • 继承自 Exception 的异常默认是受查异常。
  • 继承自 RuntimeException 的异常默认是非受查异常。
Monody·
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java零基础从入门到精通（全）
码农研究僧的博客
07-18 3万+
目录前言1. 入门知识1.1 java体系1.2 JDK/JRE/JVM区别1.3 编译与运行理解1.4 类体函数细节2. 标识符 前言 java优势 健壮性（JVM（C++语言写的一个虚拟的计算机）、GC（垃圾回收机制）） 多线程并发 可移植性/跨平台 1. 入门知识 1.1 java体系 JavaSE：标准版 JavaEE：企业版 JavaME：微型版 1.2 JDK/JRE/JVM区别 JVM是不能独立安装的。 JRE和JDK都是可以独立安装的 层层嵌套，jvm包括jdk，jdk包括jre
JavaSE从基础到入门：继承和多态
m0_66030479的博客
11-23 94
继承与多态的学习
JavaSE从基础到入门:数组的定义和使用
m0_66030479的博客
10-22 132
JavaSE从基础到入门:数组的定义和使用
JavaSE入门：基础语法
雙馬程序猿
07-30 337
javaSE入门：基础语法：1.注释、2.标识符和关键字、3.数据类型讲解、4.类型转换、5.变量常量作用域、6.运算符、7.包机制、8.JavaDOC帮助文档
视频教程-JavaSE基础视频精讲⑬：异常处理和枚举-Java
weixin_32712789的博客
05-28 114
JavaSE基础视频精讲⑬：异常处理和枚举 7年编程开发经验，精通Java、...
JavaSE 零基础入门
Hello_super的博客
10-08 471
JVM内存结构 | 面向对象 | static | this | 继承 | 方法重载 | 方法重写 | 多态 | super
JavaSE入门学习33：Java集合框架概述
life is wonderful
04-28 5322
一集合框架         (1)集合的概念         现实生活中的集合：很多的事物凑在一起。         数学中的集合：具有共同属性的事物的总体。         Java中的集合类：是一种工具类，就像是容器，储存任意数量的具有共同属性的对象。         (2)集合框架的概念         有了集合的概念，什么是集合框架呢？集合框架是为表示和操作集合而规定的一种统一
Java SE学习指南：从入门到精通
m0_47946173的博客
03-01 503
Java SE（Java Standard Edition）是Java平台的标准版本，它包含了Java编程语言、Java虚拟机（JVM）以及Java标准库等组件。Java SE提供了一套丰富的API和开发工具，使得开发人员能够快速高效地构建各种类型的应用程序，从简单的命令行工具到复杂的桌面应用和网络应用。
java 从入门到单身狗_JavaSE：练习——单身狗租赁系统(数组版)
weixin_34012355的博客
02-24 189
原标题：JavaSE：练习——单身狗租赁系统(数组版)因为现在只是基本语法，所以在综合练习之前，先补充关于方法概念。方法的作用：把一系列的代码放在一起，然后再取个别名。之后通过这个别名的调用，就相当于执行了这一系列的代码。方法的语法：([]中的内容表示是可选的)1234public 返回值类型 方法名(参数类型 参数名[,参数类型 参数 2 ...]){//代码块//[return 数据];}方法...
JavaSE从零基础入门文档代码
02-04
这个“JavaSE从零基础入门文档代码”压缩包，包含了学习JavaSE所需的基本概念、语法和实践代码，是初学者踏入Java世界的一份宝贵资料。 文档部分可能涵盖以下知识点： 1. **Java简介**：介绍Java的历史、特点和...
javase全套学习笔记，从入门到进阶详细笔记
12-19
本学习笔记旨在为初学者提供从入门到进阶的全面指导，覆盖了Java技术的基础和核心概念。 1. Java技术基础 - **编程语言**：编程语言是人与计算机交流的工具，Java作为高级语言，具有简洁、面向对象、可移植性好等...
JavaSE基础语法的学习代码，JavaSE入门练习代码
06-16
这个压缩包"JavaSE基础语法的学习代码，JavaSE入门练习代码"显然包含了用于学习JavaSE基本语法和概念的一些示例代码。对于初学者来说，通过实际编写和运行这些代码，可以加深对Java的理解。 首先，让我们深入探讨...
javaSE自学入门基础
10-11
【JavaSE自学入门基础】是针对想要学习Java编程语言的初学者所设计的一套全面教程。这个教程涵盖了从基础知识到进阶概念的多个方面，旨在帮助0基础的学习者建立起坚实的Java编程基础。 首先，让我们从Java开发环境...
JavaSE基础入门视频教程33天之（24）
09-09
JavaSE基础入门视频教程第24天主要涵盖了IO流对象的相关知识，这是Java编程中非常核心的一个部分。IO流在Java中用于处理数据的输入和输出，是程序与外部世界交换信息的重要工具。本教程通过一系列视频讲解了不同类型...
使用EntityFramework8的学习和开发过程中一些经验
最新发布
morsth的博客
08-03 316
本篇文章主要记录自己在EF8的学习和使用过程中的碰到一些坑和自己琢磨的一些解决问题的方法以及过程。
学习硬件测试04：触摸按键+PWM 驱动蜂鸣器+数码管（P62~P67、P71、P72）
Xuexi_touteng的博客
07-31 360
Qutput compare preload 输出比较预加载：使能（可以改变占空比，而不是固定占空比）极速模式：关闭CH 极性：高（小于 CCR 的状态）状态：重置。
明确工作目标学习稿：计算技术体系的发展方向
weixin_45770491的博客
08-03 476
C体系”狭义上指我国构建处理器生态的第三条道路及其技术体系。
(学习总结10)C++类和对象1
瞌睡不来的博客
08-02 706
C++类和对象总结1
JavaSE入门详解：从基础到高级特性
"JavaSE学习笔记整理，涵盖了Java基础、数据类型、数组、类和对象、访问权限、面向对象特性、系统类、异常处理、集合框架等核心概念。此外，还涉及了Java命令行工具的使用，如javac、java、javadoc、javap以及环境...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值