异常、线程

异常

异常概念

异常 ：指的是程序在执行过程中，出现的非正常的情况，最终会导致JVM的非正常停止。
在Java等面向对象的编程语言中，异常本身是一个类，产生异常就是创建异常对象并抛出了一个异常对象。Java处
理异常的方式是中断处理。
异常指的并不是语法错误,语法错了,编译不通过,不会产生字节码文件,根本不能运行.

异常体系

异常机制其实是帮助我们找到程序中的问题，异常的根类是java.lang.Throwable ，其下有两个子类：
java.lang.Error 与java.lang.Exception ，平常所说的异常指java.lang.Exception 。

Throwable体系

Error:严重错误Error，无法通过处理的错误，只能事先避免，好比绝症。
**Exception:**表示异常，异常产生后程序员可以通过代码的方式纠正，使程序继续运行，是必须要处理的。好
比感冒、阑尾炎。

Throwable中的常用方法

• public void printStackTrace() :打印异常的详细信息。（JVM打印异常对象。默认此方法，打印异常信息是最全的）
  包含了异常的类型,异常的原因,还包括异常出现的位置,在开发和调试阶段,都得使用printStackTrace。
• public String getMessage() :获取发生异常的原因。（比较简短）
  提示给用户的时候,就提示错误原因。
  -public String toString() :获取异常的类型和异常描述信息(不用)。
  ps:出现异常,不要紧张,把异常的简单类名,拷贝到API中去查。
  

异常分类

我们平常说的异常就是指Exception，因为这类异常一旦出现，我们就要对代码进行更正，修复程序。
异常(Exception)的分类:根据在编译时期还是运行时期去检查异常
编译时期异常:checked异常。在编译时期,就会检查,如果没有处理异常,则编译失败。(如日期格式化异常)
运行时期异常:runtime异常。在运行时期,检查异常.在编译时期,运行异常不会编译器检测(不报错)。(如数学异
常)

异常的处理

Java异常处理的五个关键字：try、catch、finally、throw、throws

抛出异常throw

作用：可以使用throw关键字在指定方法中抛出指定异常
使用格式：

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

eg:

throw new NullPointerException("要访问的arr数组不存在");
throw new ArrayIndexOutOfBoundsException("该索引在数组中不存在，已超出范围");

注意：
1、throw关键字必须写在方法的内部
2、throw关键字后边new的对象必须是Exception或Exception的子类对象
3、throw关键字抛出指定异常，我们就必须处理这个异常
throw关键字后边创建的是RuntimeException或者是RuntimeException子类对象，我们可以不处理，默认交给JVM处理（打印异常对象，中断程序）
throw关键字后边创建的是编译异常（写代码时就报错），我们就必须处理这个异常，要么throws,要么try…catch

public class ThrowDemoTest {
    public static void main(String[] args) {
        int[] arr ={1,3,44,55};
        int index =4;
        getElement(arr,index);
        System.out.println(arr);
        System.out.println("over");
    }
    public static int getElement(int[] arr, int index){
        if(index<0||index>arr.length-1){
            throw new IndexOutOfBoundsException("哥们角标越界了");
        }
        int element =arr[index];
        return element;
    }


}

声明异常throws

throws关键字：异常处理的第一种方式，交给别人处理
作用：
当方法内部抛出异常对象的时候，那么我们就必须处理这个异常对象
可以使用throws关键字处理异常对象，会把异常对象声明抛出给方法的调用者处理（自己不处理，给别人处理）。最终交给JVM处理–>中断处理
使用格式：在方法声明时使用

修饰符 返回值类型 方法名（参数列表）throws AAAException.BBBException...{
    throw new AAAException("产生原因");
    throw new AAAException("产生原因");
}

注意：
1、throws关键字必须写在方法声明处
2、throws关键字后边声明的异常必须是Exception或者是Exception子类
3、方法内部如果抛出了多个异常对象，那么throw后边也必须声明多个异常
如果抛出的多个异常对象有子父类关系，那么直接声明父类异常即可
4、调用了一个声明抛出异常的方法，我们就必须处理声明的异常
要么继续使用throws声明抛出，交给方法的调用者处理，最终交给JVM
要么try…catch自己处理异常

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

public class ThrowsDemoTest {
    public static void main(String[] args) throws IOException {
        read("a.txt");

    }
    //如果定义功能时有问题发生需要报告给调用者。可以通过在方法上使用throws关键字进行声明
    private static void read(String path) throws IOException {
        if (!path.equals("a.txt")){
            throw new FileNotFoundException("文件不存在");
        }
        if (!path.equals("b.txt")){
            throw new IOException();/*read方法有多个异常，可以在throws关键字后面写多个异常类，
             并用逗号隔开，如果有子父类关系，直接声明父类异常即可*/
        }

        }

}

捕获异常try…catch

异常处理的第二种方式，自己处理异常
格式：

try{
//可能产生异常的代码
}catch（定义一个异常的变量，用来接收try中抛出的异常对象）{
处理异常的代码
//记录日志/打印异常信息/继续抛出异常
}
....
catch（异常类名 变量名）{

}

注意：
1、try中可能或抛出多个异常对象，那么就可以使用多个catch来处理这些异常对象
2、如果try中产生了异常，那么就会执行catch中异常处理逻辑，执行完毕catch中的处理逻辑，继续执行try…catch之后的代码；如果try中没有产生异常，那么久不会执行catch中异常的处理逻辑，执行完try中的代码，继续执行try…catch之后的代码
3.try和catch都不能单独使用，必须连用

import java.io.FileNotFoundException;

public class TryCatchDemo {
    public static void main(String[] args) {
        try{
            read("b.txt");

        }catch (FileNotFoundException e){
            e.printStackTrace();//查看异常信息的方法
        }finally{
            System.out.println("无论怎么样，这里都会被执行");
        }
        System.out.println("over");
    }

    private static void read(String path) throws FileNotFoundException {
        if (!path.equals("a.txt")){
            throw new FileNotFoundException("文件不存在");
        }
    }
}

finally代码块

格式：

try{
//可能产生异常的代码
}catch（定义一个异常的变量，用来接收try中抛出的异常对象）{
处理异常的代码
//记录日志/打印异常信息/继续抛出异常
}
....
catch（异常类名 变量名）{

}finally{
无论是否出现异常都会执行
}

注意：
1、finally不能单独使用，必须和try一起使用
2、finally一般用于资源释放（资源回收），无论程序是否出现异常，最后都要资源释放

自定义异常

java中提供的异常类，不够我们使用，需要自己定义一些异常类
格式：

public class XXXException/RuntimeException{
添加一个空参的构造方法
添加一个异常信息的构造方法
}

注意：
1、自定义异常类一般都是以Exception结尾，说明该类是一个异常类
2、自定义异常类必须继承Exception或RuntimeException
继承Exception:那么自定义异常就是编译期异常，如果方法内部抛出了编译器异常，就必须处理这个异常，要么throws，要么try…catch
继承RuntimeException:那么自定义的异常类就是一个运行期异常，交给虚拟机处理（中断处理）

/*需求：我们模拟注册操作，如果用户名存在，则抛出异常并提示：亲，该用户名已经被注册*/
//1、首先定义一个登录异常类ThrowRegisterException：
public class ThrowRegisterException extends Exception {
    public ThrowRegisterException(){

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

}

public class ThrowRegisterExceptionDemo {
    private static String[] names={"Allen","Shelly","Ann"};
    public static void main(String[] args) throws ThrowRegisterException {
        String username="Allen";

        //try {
            checkUserName(username);
            System.out.println("注册成功");
        /*}catch (Exception e){
            e.getStackTrace();
        }*/
    }
    public  static boolean checkUserName(String username) throws ThrowRegisterException {
        for (String name:names){
            if (name.equals(username)){
                throw new ThrowRegisterException("亲，"+name+"该用户名已经被注册");
            }

        }
        return true;


    }

}

多线程

并发与并行

并发：指两个或多个事件在同一个时间段内发生。
并行：指两个或多个事件在同一时刻发生（同时发生）。

线程与进程

进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多
个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创
建、运行到消亡的过程。
线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程
中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程
线程调度：
分时调度
所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。
抢占式调度
优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为
抢占式调度。

创建线程类

Java使用java.lang.Thread 类代表线程，所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用是
完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。Java使用线程执行体来代表这段程序流。
创建多线程的第一种方式：创建thread子类
javalang.Thread类：是描述线程的类，我们想要实现多线程程序，就必须继承Thread类
实现步骤：
1、创建一个Thread类的子类
2、在Thread类的子类中重写Thread类中的run方法，设置线程任务（开启线程要做什么）
3、创建Thread类子类的对象
4、调用Thread类中的方法start方法，开启新的线程，执行run方法
void start（）使该线程开始执行；java虚拟机调用该线程的run方法
结果是两个线程并发地运行；当前线程（main线程）和另一个线程（创建的新线程，执行其run方法）
多次启动一个线程是非法的。特别是当线程已经结束执行后，不能再重新启动
java程序属于抢占式调度，那个线程的优先级高，那个线程优先执行；同一个优先级，随机选择一个执行

自定义线程类

package ThreadTestDemo;

public class MyThread extends Thread{
    //定义指定线程名称的构造方法
    public MyThread(String name){
        //调用父类的String参数构造方法，指定线程名称
        super(name);
    }
    //重写run方法，完成该线程执行逻辑
    @Override
    public void run() {
        for (int i = 0; i <10 ; i++) {
            System.out.println(getName()+":正在执行"+i);

        }
    }
}

package ThreadTestDemo;

public class MyThreadTest {
    public static void main(String[] args) {
        //创建自定义线程对象
        MyThread mt = new MyThread("新线程");
        //开启新xiancheng
        mt.start();
        for (int i = 0; i <10 ; i++) {
            System.out.println("main线程"+i);

        }
    }
}