异常，线程

编程语言 2018-08-17 17:43:53 阅读次数: 0

01.第一章：异常_概念及异常处理的作用：

1).什么是“异常”：是指代码在执行过程中，出现了一些JVM无法处理的数据，一旦出现这种情况，JVM将会终止程序的执行(程序卡死，程序闪退),这种情况就叫：异常。
public class Demo {
public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入一个数：");
    int a = sc.nextInt();
    System.out.println("请输入第二个数：");
    int b = sc.nextInt();

    System.out.println(a + " / " + b + " = " + (a / b));

}
}
2).如果程序一旦出现异常情况，我们程序员和用户都不希望程序被终止。这时Java提供了一种语法--异常处理机制，可以在“异常情况”出现时，使我们的程序可以继续健康的运行下去。
public class Demo {
public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入一个数：");
    int a = sc.nextInt();
    System.out.println("请输入第二个数：");
    int b = sc.nextInt();
    try {
        System.out.println(a + " / " + b + " = " + (a / b));
    } catch (ArithmeticException e) {
        System.out.println("运算时出现错误了，但程序没有死，我可以继续健康的运行下去！");
    }
    System.out.println("后续代码....");       
}
}

02.第一章：异常_异常产生的过程解析：

这里写图片描述

1).JVM执行到有异常的代码；
2).JVM识别出这个异常；
3).JVM到类库中找到描述这个异常情况的“异常类”，并创建对象；
4).判断我们的程序是否有catch语句来捕获这个异常：
    有：执行这个catch语句，之后，继续向下运行；
    无：将异常信息打印到控制台，将程序结束；(这是我们不希望看到的)

03.第一章：异常_Java异常体系结构及分类：

这里讲的“异常”全部是指：程序已通过编译，在运行时出现的异常。
Throwable(顶层的异常类):
    |--Error(错误):不希望我们程序捕获的一些重大异常。(不用掌握)
    |--Exception(异常):希望程序进行捕获的一些异常情况(必须掌握)
        |--RuntimeException(运行时异常):
        |--除RuntimeException外的其它异常(编译期异常):不是“编译时的语法错误”。指这种异常必须要“处理”，否则无法编译通过。(这跟写代码时的语法错误是不同的。)
    SimpleDateFormat sdf = new SimpleDateFormat(...);
    sdf.parse("2018-09-11");//这个方法会抛异常，我们必须处理这个异常，否则编译不能通过异常类的作用：
1).每个异常类，都描述了一种异常情况；
2).异常类的“类名”就指出了这个异常是什么情况；类内部还包含了一个String类型的变量，用于存储此种异常的“异常信息”，还有一些方法可以做一些其它操作。

04.第二章：异常的处理_基本方式try…catch语句及执行流程：

1).基本语句：
    try{
        //可能出现异常的代码：
    }catch(异常类名  变量名){
        //如果出现了跟“异常类名”匹配的异常，将会执行这个catch.
        //执行完毕，将会继续执行catch的后续语句，程序就起死回生了。
    }
2).示例代码：
    1).无异常情况的执行流程：

这里写图片描述

    2).有异常的执行流程：

这里写图片描述

3).说明：
        1).catch中的“异常类型”必须和try中产生异常的类型匹配，才能被执行，否则不能被执行；
public static void main(String[] args) {
try {
    System.out.println("a");
    System.out.println("b");
    int i = 10 / 0;
    System.out.println("c");
    System.out.println("d");
} catch (NullPointerException e) {//try中产生的是“算术运算异常”，catch的是“空指针”异常，不匹配，所以catch不会被执行；
    System.out.println("e");
}
System.out.println("f");
}

05.第二章：异常的处理_常见的几种异常：

1).空指针异常：
    try{
        int[] arr = null;
        System.out.println(arr.length);
    }catch(NullPointerException e){
        ...
    }
    当一个“引用类型”是“null”时，不能访问它的任何属性、方法，否则会抛出空指针异常：NullPointerException.
    Throwable:
        |--Exception:
            |--RuntimeException
                |--NullPointerException
2).数组下标越界异常：
    try{
        int[] arr = {1,2};
        System.out.println(arr[10]);
    }catch(ArrayIndexOutOfBoundsException e){
        ....
    }
    Throwable:
        |--Exception:
            |--RuntimeException:
                |--IndexOutOfBoundesException:
                    |--ArrayIndexOutOfBoundsException
3).数字转换异常：
try {
String strAge = "22a";
int age = Integer.parseInt(strAge);
System.out.println(age);
}catch(NumberFormatException e){
...
}
Throwable 
|--Exception 
    |--RuntimeException 
        |--IllegalArgumentException 
                |--NumberFormatException 

4).算术运算异常：
    try{
        int a = 10 / 0;
    }catch(ArithmeticException e){
        ...
    }
    Throwable:
        |--Exception:
            |--RuntimeException
                |--ArithmeticException

5).转换异常：
    try{
        String strDate = "2018-01-01";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
        Date date = sdf.parse(sdf)://此方法会抛出ParseException
    }catch(ParseException e){
        ....
    }
    Throwable
        |--Exception
            |--ParseException

06.第二章：异常的处理_try…catch…catch…语句及执行流程：

try{
        //多行代码，可能会产生多种异常
    }catch(异常类型1 变量名){
    }catch(异常类型2 变量名){
    }catch(异常类型n 变量名){
    }
1).示例代码，及执行流程：
    1).无异常情况：

这里写图片描述

    2).有异常情况：

这里写图片描述

3).其它说明：
        1).多catch中的异常类型不能是相同的类型，否则编译错误；
        2).多catch中的异常类型“可以是子父关系”，但“父类的异常类型”必须写在多catch的末尾：
        try{
        }catch(ArithmeticException e){
        }catch(NullPointerException e){
        }catch(Exception e){
        }
        3).多catch中的异常类型如果是“平级”关系，没有顺序。

07.第二章：异常的处理_声明抛出异常throws【常用】：

这里写图片描述

1).注意：
    1).throws用于在“方法声明”处，声明抛出异常；
    2).throws后面可以写多个“异常类型”名，用,号隔开；
    3).如果方法内产生了声明的异常类型之一，JVM会立即终止方法的执行，并将异常对象返回给“方法调用处”。
    4).如果声明抛出的是“运行时异常(RuntimeException)”调用时，可以不处理；
    5).如果声明抛出的是“编译期异常(除RuntimeException外的异常)”，调用处必须将这个异常捕获(try...catch..)或者继续抛出（throws）

08.第二章：异常的处理_抛出异常throw：

这里写图片描述

1).注意：
    1).throw表示：抛出一个异常对象；后面必须new一个异常对象；
    2).throw表示结束方法的执行，立即返回一个异常，后续代码不会被执行；

08.2.第二章：异常的处理_throws和throw的区别：

这里写图片描述

09.第二章：异常的处理_Objects类的非空判断：

class Student{
    private String name;
    private int age;
    public Student(String name,int age){
        //自己验证
        /*
        if(name == null){
            throw new NullPointerException("名字不能为null");
        }
        this.name = name;
        */
        //使用Objects的requireNonNull()方法代替
        this.name = Objects.requireNonNull(name);
    }
    ...
}
main(){
    Student stu = new Student(null,18); 
}

10.第二章：异常的处理_try…catch…finally语句：

例如在一个方法中，某些情况下，try语句中就要return 值;
    例如：读取文件内容：
    public static String readFile(){
        try{
            打开文件流
            读取文件；//假如这里出现异常
            return 文件内容;
        }catch(异常类型 e){
            ....
        }finally{
            //无论是否出现异常都会被执行的代码
            关闭文件流           
        }
        return null;
    }
    示例代码：
public class Demo {
public static void main(String[] args) {
    p1();
}

private static int p1() {
    try {
        int a = 10 / 0;
        System.out.println("a");

        return 10;
    } catch (ArithmeticException e) {
        System.out.println("b");

        return 20;
    }finally {
        System.out.println("c");
    }
  }
}

11.第三章：自定义异常_概述：

1).有些时候我们的程序会根据需求，可能需要产生一些类库中没有的异常，例如：
    class Student{
        private int age;
        public void setAge(int age){
            if(age < 15 || age > 5){
                throw new 自定义异常对象();
            }
            this.age = age;
        }
    }
2).制作自定义异常类：
    1).自定义类继承自：Exception或者它的某个子类即可(注意区分运行时和非运行时)
    2).添加一个带String参数的构造方法，用于指定“异常信息”
    3).例如：定义自定义异常类：
        class AgeException extends Exception{
            public AgeException(String msg){
                super(msg);
            }
        }
    4).使用：
        class Student{
            private int age;
        public void setAge(int age){
            if(age < 15 || age > 5){
                throw new AgeException("年龄必须在15到50之间");
            }
            this.age = age;
        }
        }
    5).测试：
        main(){
            Student stu = new Student();
            try{
                stu.setAge(18);
            }catch(AgeException e){
                System.out.println(e.getMessage());
            }
        }

12.第三章：自定义异常_自定义异常练习：

见11

13.第四章：多线程_进程与线程：

1).什么是“进程”：它是“操作系统”的概念，指一个独立运行的程序；由自己独立的内存空间；
2).什么是“线程”：它是由“进程”创建的，可以使一个“进程”中的一些代码独立出来，与“主进程”同时执行，可以使程序的两部分代码“同时”执行，可以提高程序的执行效率。

14.第四章：多线程_并发与并行：

1).什么是“并发”：早期针对“CPU”来说，单颗CPU处理多个进程同时访问时，
               这时CPU就收到了“并发”性访问。
2).什么是“并行”：例如：两颗CPU同时处理两个进程，这种情况叫：并行；

15.第四章：多线程创建线程类继承Thread及匿名对象的方式：

1).我们之前的程序都是“单线程”程序；以后制作的WEB程序就都是多线程的了。
2).多线程程序好处：可以“同时”做多件事情。可以提高程序的运行效率，也可以提高用户的体验度；
3).怎么制作多线程程序：
    1).自定义线程类，继承自：Thread
    2).重写run()方法：在线程中做的事情写在这里；
    3).启动线程：
        1).创建一个自定义线程类对象；
        2).调用线程对象的start()方法启动线程；
   注意：启动线程是start()，线程启动后执行的是run()；
4).示例代码：
public class MyThread extends Thread {
@Override
public void run() {
    for (int i = 0; i < 100; i++) {
        System.out.println("i = " + i);

    }
}
}
  public class Demo {
public static void main(String[] args) {
    MyThread t1 = new MyThread();

    t1.start();

    for (int k = 0; k < 100; k++) {
        System.out.println("k = " + k);

    }
}
}
5).匿名子类的方式：
//匿名子类对象
Thread t1 = new Thread(){
@Override
public void run() {
    for (int i = 0; i < 100; i++) {
        System.out.println("i = " + i);
    }
}
};
t1.start();

for (int k = 0; k < 100; k++) {
System.out.println("k = " + k);

}

16.第四章：多线程创建线程类关于线程的几个说明：

1).启动线程是start()，启动后，线程执行的是run()方法；
2).一个线程对象，不能多次的start()，只能启动一次；

总结：
01.能够辨别程序中异常和错误的区别
1).错误：程序无法处理的异常情况–堆栈溢出；
2).异常：程序可以处理的一些异常情况；
02.说出异常的分类
Throwable
|–Error
|–Exception(异常)
|–RuntimeException(运行时异常)
|–除RuntimeException外的其它异常：编译期异常；
03.说出虚拟机处理异常的方式
1).执行异常的代码；
2).识别出异常；
3).到类库中找到这个异常类，并创建对象；
4).判断代码中是否catch这个异常：
是：执行catch语句；
否：打印到控制台，结束程序；
04.列举出常见的三个运行期异常
1).数组下标越界：ArrayIndexOutOfBoundesExceptio
2).空指针：NullPointerException
3).算术运算错误：ArithmeticException

05.能够使用try…catch关键字处理异常
int[] arr = {1,2};
try{
System.out.println(arr[3]);
}catch(ArrayIndexOutOfBoundsException e){
System.out.println(“异常了”);
}
06.能够使用throws关键字处理异常
public void show() throws NullPointerException{
}
07.能够自定义异常类
class AgeException extends Exception{
public AgeException(){
}
public AgeException(String msg){
super(msg);
}
}
08.能够处理自定义异常类
1).使用自定义异常
class Student{
…
public void setAge(int age) throws AgeException{
if(age < 15 || age > 50){
throw new AgeException(“年龄错误！”);
}
}
}
2).处理自定义异常：
main(){
Student stu = new Student();
try{
stu.setAge(10);
}catch(AgeException e){
}
}
09.说出进程的概念
是指一个内存中运行的应用程序，

10.说出线程的概念
进程内部的一个独立执行单元； 一个进程可以同时并发的运行多个线程

11.能够理解并发与并行的区别
并发： 指两个或多个事件在同一个时间段内抢占一个共同的资源。
并行： 指两个或多个事件在同一时刻发生（同时发生） ，占用各自的资源；

12.能够开启新线程
1).制作新线程：
class MyThread extends Thread{
public void run(){
for(int i = 0;i <100 ; i++){
System.out.println(“i = ” + i);
}
}
}
2).启动线程：
main(){
MyThread t1 = new MyThread();
t1.start();

        MyThread t2 = new MyThread();
        t2.start();
    }

猜你喜欢

转载自blog.csdn.net/zzz323666/article/details/81780874
今日推荐
周排行
Leetcode简单题61~80
解决zookeeper磁盘IO高的问题
多线程相关方法详解
Maven-setting.xml文件详解
Maven 项目的 classpath 理解
渊亭科技大数据笔试题
配置JVM内存分配
计算机网络个人学习笔记 （三）网络层 ：第三部分 连载
js中两个等号(==)和三个等号(===)的区别
用C程序自动打开电脑上的程序
每日归档
更多
2024-09-18(0)
2024-09-17(0)
2024-09-16(0)
2024-09-15(0)
2024-09-14(0)
2024-09-13(0)
2024-09-12(0)
2024-09-11(0)
2024-09-10(0)
2024-09-09(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022