学习java的第13天

异常

throwable类

String getMessage();//返回此throwable的简短描述
String toString();//返回throwable的消息字符串
void printStackTrace();//jvm打印异常对象，异常信息最全面

public class Demo2 {
    public static void main(String[] args) {
        try {
            equalss("a");
        }catch (Exception e){

            System.out.println(e.getMessage());
            System.out.println(e.toString());
            System.out.println(e);//默认调用e.toString()
            e.printStackTrace();
        }
    }
    public static void equalss(String str1) throws Exception {
        if (!str1.equals("c")) {
            throw new FileNotFoundException("文件不存在");
        }

        if (!str1.endsWith(".")) {
            throw new IOException("错误");
        }
    }
}

finally代码块

//格式
try{
    
}catch(异常变量 异常变量){
    
}
.....
catch(){
    
}finally{
    无论是否有异常都会执行
}


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

try {
            equalss("a");
        }catch (Exception e){

            System.out.println(e.getMessage());
            System.out.println(e.toString());
            System.out.println(e);//默认调用e.toString()
            e.printStackTrace();
        }finally {
            System.out.println("资源释放");
        }
    }

异常注意事项

1. 多个异常分别处理
2. 多个异常一次捕获，多次处理
   • 一个try多个catch
   • catch里定义的异常变量，如果有子父类关系，子类异常必须写在上边
3. 多个异常一次捕获一次处理

4. 运行时的异常被抛出可以不处理，即可以不捕获也可以不声明抛出，默认交给jvm处理

5. 如果finally有return语句，永远返回finally中的结果

public class Dome3 {
    public static void main(String[] args) {
        print();
    }
    public static int print(){
        int a =10;
        try {
            return a;
        }catch (Exception e){
            System.out.println("a");
        }finally {
            a=100;
            return a;
            //返回值一定为100
            //要避免在finally中写返回值
        }
    }
}

6. 子父类异常

public class Father {
    public void show1() throws NullPointerException,ClassCastException{}
    public void show2() throws IndexOutOfBoundsException{}
    public void show3() throws IndexOutOfBoundsException{}
    public void show4() {}
}
class zi extends Father{
    //子类重写父类方法，抛出和父类相同的异常
    public void show1() throws NullPointerException,ClassCastException{}
    //子类重写父类方法，抛出和父类异常的子类
    public void show2() throws ArrayIndexOutOfBoundsException{}
    //子类重写父类方法，不抛出异常
    public void show3(){}
    //父类异常没有抛出，子类异常也不能抛出，此时子类异常只能捕获处理，不能声明抛出
    public void show4() {
        try {
            throw new RuntimeException();
        }catch (Exception e){
            System.out.println(e);
        }
    }
}

自定义异常类

public class XXXException extends Exception{
    /*
    添加一个空参构造
    添加一个带异常信息的构造,调用父类带异常信息的构造，让父类来处理异常，
    */
    public XXXException(Sreing a){
        super(a);
    }
}

/*
可以继承Exception或继承RuntimeException
*/

多线程

并发与并行

线程与进程

• 进程：指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建运行到消亡的过程
• 线程：线程是进程中的一个执行单位，负责当前进程中程序的执行，一个进程中至少有一个线程，一个进程可以有多个线程

线程调度

• 分时调度：所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间
• 抢占式调度：优先让优先级较高的线程使用CPU，如果线程优先级相同，那么会随机选择一个

创建线程类

1. 主线程：执行主方法的线程
2. 单线程：java程序中只有一个线程，执行从main方法开始，从上到下执行

第一种方式

创建Thread类：

步骤：

1. 创建一个Thread的子类
2. 重写Thread类中的run方法，设置线程任务
3. 创建Thread类的子类对象
4. 调用Thread类之中的start方法，开启新线程的run方法

void start（）方法使线程开始执行，Java虚拟机调用run方法。结果两个线程并发的运行：当前线程（main线程）和令一个线程（创建的新线程）；多次启动一个线程违法，当线程运行完，不能在重新启动

public class Demo1 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("run:"+i);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Demo1 mythread = new Demo1();
        mythread.run();//单线程
        mythread.start();//多线程

        for (int i = 0; i < 20; i++) {
            System.out.println("main:"+i);
        }

    }
}

ead.start();//多线程

    for (int i = 0; i < 20; i++) {
        System.out.println("main:"+i);
    }

}

}
``