Java学习笔记（七）
Debug追踪
- 可以让代码逐行执行，查看代码执行的过程，调试程序中出现的Bug
- 使用方式：
- 在行号的右边，鼠标左键点击，添加断点（哪里有Bug就添加到哪里）
- 选择Debug执行程序
- 程序就会停留到添加的第一个断点处
- 执行程序：
f8：逐行执行程序f7：进入到方法中shift+f8：跳出方法f9：跳到下一个断点，如果没有下一个断点，那么就结束程序ctrl+f2：退出Debug模式，停止程序Console：切换到控制台
异常
异常概念：
- 异常：指的是程序在执行过程中，出现的非正常的情况，最终会导致JVM的非正常停止
- 在Java等面向对象的编程语言中，异常本身是一个类，产生异常就是创建异常对象并抛出一个异常对象，Java处理异常的方式就是中断处理
异常指的并不是语法错误，语法错了，编译不通过，不会产生字节码文件，根本不能运行
异常体系
异常机制其实是帮助我们找到程序中的问题，异常的根类是java.lang.Throwable，其下有两个子类：java.lang.Error与java.lang.Exception，平时所说的异常指java.lang.Exception
Throwable体系：
- Error：严重错误Error，无法通过处理的错误，只能事先避免
- Exception：表示异常，异常产生后程序员可以通过代码的方式纠正，是程序继续运行，是必须处理好的
Throwable中的常用方法：
-
public void printStackTrace()：打印异常的详细信息包含了异常的类型，异常的原因，异常出现的位置，在开发和调试阶段，都使用printStackTrace
-
public String getMessage()：获取发生异常的原因 -
String toString()：返回Throwable的详细消息字符串
异常的分类
java.lang.Throwable类是Java语言中所有粗无或者异常的超类
Exception：
- 编译期异常，进行编译Java程序出现的问题
- RuntimeExceotion：运行时异常，Java程序运行时出现的问题
Error：错误
异常产生的过程分析
throw关键字
作用：可以使用throw关键字在指定的方法中抛出异常
使用格式：
-
throw new xxxException("异常产生的原因");
注意：
- throw关键字必须小写在方法的内部
- throw关键字后边new的对象必须时Exception或者Exception的子类
- throw关键字抛出指定的异常对象，我们就必须处理这个对象
- throw关键字后创建的时RuntimeException或者是RuntimeException的子类，我们可以不处理，默认交给JVM处理（打印异常对象，中断程序）
- throw关键字后边创建的是编译期异常，我们就必须处理这个异常，要么throws要么try…catch
public class Demo{
public static void main(String[] args){
//int[] arr = null;
int[] arr = new int[3];
int e = getElement(arr,3);
System.out.println(e);
}
/*
定义一个方法，获取数组指定索引的元素
参数：int[] arr int index
以后工作中我们首先必须对方法传递过来的参数进行合法性校验
如果参数不合法，那么我们必须使用抛出异常的方式，告知方法的调用者，传递的参数有问题
注意:
NullPointerException:是一个运行期异常，我们不用处理，默认交给JVM处理
*/
public static int getElement(int[] arr,int index){
/*
我们可以对传递过来的参数数组，进行合法性校验
如果数组arr的值是null
那么我们就抛出空指针异常告知方法的调用者“传递的数组值为null”
*/
if(arr == null){
throw new NullPointerException("传递的数组值为null");
}
/*
我们可以对传递过来的参数index进行合法性校验
如果index的范围不再数组的索引范围
那么我们就抛出数组索引越界异常，告知方法的调用者“传递的索引超出了数组的使用范围”
*/
if(index < 0 || index > arr.length-1){
throw new ArrayIndexOutOfBoundException("传递的索引超出了数组的使用范围");
}
int ele = arr[index];
return ele;
}
}
Objects非空判断
Objects类它是由一些静态方法组成的，这些方法是nul-save（空指针安全的）或者null-tolerant（容忍空指针的），那么在它的源码中，对对象为null的值进行了抛出异常操作
public static <T> T requireNonNull(T obj)：查看指定引用对象不是null
查看源码发现这里对为null的进行了抛出异常操作：
public static <T> T requireNonNull(T obj){
if(obj == null)
throw new NullPointerException();
return obj;
}
public class Demo{
public static void main(String[] args){
method(null);
}
public static void method(Object obj){
Objects.requireNonNull(obj);
//Objects.requireNonNull(obj,"传递的对象是null");
}
}
throws声明异常
-
throws关键字：异常处理的第一种方式，交给别人处理
-
作用：
- 当方法内部抛出异常对象的时候，那么我们就必须处理这个异常对象
- 可以使用throws关键字处理异常对象，会把异常对象声明抛出给方法的调用者处理者处理，最终交给JVM处理（中断处理）
-
使用格式：
//在方法声明时使用 修饰符 返回值类型 方法名(参数列表) throws xxxException,xxxException...{ throw new xxxException("产生原因"); throw new xxxException("产生原因"); ... } -
注意：
- throws关键字必须写在方法的声明处
- throws关键字后边声明的异常必须时Exception或者时Exception的子类
- 方法内部如果抛出多个异常对象，那么throws后i便必须也声明多个异常
- 如果抛出的多个异常对象有子父类关系，那么直接声明父类异常即可
- 调用了一个声明抛出异常的方法，我们就必须处理声明的异常
- 要么继续使用throws声明抛出，交给方法的调用者处理，最终交给JVM
- 要么try…catch自己处理异常
public class Demo{
/*
FileNotFoundException extends IOException
如果抛出的多个异常对象有子父类关系，那么直接声明父类异常即可
*/
//public static void main(String[] args) throws FileNotFoundException，IOException{
public static void main(String[] args) throws /*IOException*/ Exception{
readFile("c:\\a.txt");
}
/*
定义一个方法，对传递的文件路径进行合法性判断
如果路径不是c:\\a.txt，那么我们就抛出文件找不到异常，告知方法的调用者
注意:
FileNotFoundException时编译期异常，抛出了编译期异常，就必须处理这个异常
可以使用throws继续声明式抛出FileNotFoundException这个异常，让方法的调用者处理
*/
public static void readFile(String fileName) throws FileNotFoundException，IOException{
if(fileName.equals("c:\\a.txt")){
throw new FileNotFoundException("文件路径有误");
}
/*
如果传递的路径文件名后缀不是.txt,我们抛出IO异常告知方法的调用者，文件的后缀名不对
*/
if(!fileName.endWith(".txt")){
throw new IOException("文件的后缀名不对");
}
System.out.println("路径没有问题");
}
}
try…catch捕获异常
-
try…catch：异常处理的第二种方式，自己处理异常
-
格式：
try{ //可能产生异常的代码 }catch(定义一个异常变量，用来接收try中抛出的异常对象){ //异常的处理逻辑 //一般在工作中，会把异常信息记录在一个日志中 } ... catch(异常类名 变量名){ } -
注意：
- try中可能会抛出多个异常对象，那么就可以使用多个catch来处理这些异常对象
- 如果try中产生了异常，那么会执行catch中的异常处理逻辑，执行完毕catch中的处理逻辑，继续执行try…catch之后的代码
- 如果try中没有产生异常，那么就不会执行catch中的异常处理逻辑，执行完try中的代码，继续执行try…catch之后的代码
public class Demo{
public static void main(String[] args) {
try{
//可能产生异常的代码
readFile("c:\\a.txt");
}catch (IOException e){
//异常的处理逻辑
System.out.println("传递的文件后缀名不是.txt");
}
System.out.println("后续代码");
}
/*
如果传递的路径文件名后缀不是.txt,我们抛出IO异常告知方法的调用者，文件的后缀名不对
*/
public static void readFile(String fileName) IOException{
if(!fileName.endWith(".txt")){
throw new IOException("文件的后缀名不对");
}
System.out.println("路径没有问题");
}
}
finally代码块
-
格式：
try{ //可能产生异常的代码 }catch(定义一个异常变量，用来接收try中抛出的异常对象){ //异常的处理逻辑 //一般在工作中，会把异常信息记录在一个日志中 } ... catch(异常类名 变量名){ }finally{ //无论是否出现异常都会执行 } -
注意：
- finally不能单独使用，必须和try一起使用
- finally一般用于资源释放，无论程序是否出现异常，最后都要释放资源
public class Demo{
public static void main(String[] args) {
try{
//可能产生异常的代码
readFile("c:\\a.txt");
}catch (IOException e){
//异常的处理逻辑
e.printStackTrace();
}finally{
//无论是否出现异常都会执行
System.out.println("资源释放");
}
}
/*
如果传递的路径文件名后缀不是.txt,我们抛出IO异常告知方法的调用者，文件的后缀名不对
*/
public static void readFile(String fileName) IOException{
if(!fileName.endWith(".txt")){
throw new IOException("文件的后缀名不对");
}
System.out.println("路径没有问题");
}
}
异常的注意事项
多异常的捕获处理
- 多个异常分别处理
- 每个异常都有一个try…catch
- 多个异常一次捕获，多次处理
- 一个try多个catch
- catch里边定义的异常变量，如果有子父类关系，那么子类的异常变量必须写在上边，否则会报错
- 多个异常一次捕获一次处理
- 多个异常一个try…catch
- 运行时异常被抛出可以不处理，即不捕获也不声明抛出
finally中有return语句
如果finally中有return语句，永远返回finally中的结果，应该避免这种结果
public class Demo{
public static void main(String[] args){
int a = getA();
System.out.println(a);
}
public static int getA(){
int a = 10;
try{
return a;
}catch (Exception e){
System.out.println(a);
}finally{
a = 100;
return a;
}
}
}
//结果：100
子父类异常
- 如果父类抛出了多个异常，子类重写父类方法的时候，抛出和父类相同的异常或者是父类异常的子类或者不抛出异常
- 父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常，此时子类产生该异常，只能捕获处理，不能声明抛出
- 注意：父类异常是什么样，子类异常就什么样
自定义异常
-
自定义异常类：Java提供的异常类，不够我们使用，需要我们自己定义一些异常类
-
格式：
public class XxxException extends Exception/RuntimeException{ //添加一个空参数的构造方法 //添加一个带异常信息的构造方法 } -
注意:
- 自定义异常一般都是以Exception结尾，说明该类就是一个异常类
- 自定义异常类，必须继承Exception或者RuntimeException
- 继承Exception：那么自定义异常类就是一个编译期异常，如果方法的内部抛出了编译期异常，就必须处理这个异常，要么throws要么try…catch
- 继承RuntimeException：那么自定义异常类就是一个运行期异常，无需处理，交给JVM处理（中断处理）
public class RegisterException extends Exception {
//添加一个空参数的构造方法
public RegisterException(){
super();
}
//添加一个带异常信息的构造方法
public RegisterException(String message){
super(message);
}
}
多线程
并发和并行
- 并发：指两个或多个时间在同一时间段内发生
- 并行：指两个或多个时间刻发生（同时发生）
进程与线程
-
进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用可以同时多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程
-
线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程，一个进程中是可以有多个线程的，这个应用程序也被称之为多线程程序
-
简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程
线程的调度
- 分时调度：所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间
- 抢占式调度：优先让有限期高的线程使用CPU，如果线程的优先级形同，那么会随机选择一个（线程的随机性），Java使用的为抢占式调度
扫一扫
1178
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
