【无标题】

1.try-catch-finally的使用
try{
//可能出现异常的代码
}catch（异常类型1 变量名1）{
//处理异常的方式1
}catch（异常类型2 变量名2）{
//处理异常的方式2
}catch（异常类型3 变量名3）{
//处理异常的方式3
}
…
finally{
//一定会执行的代码
}

try{
int num=Integer.parseInt（str）；
System.out.println（”…”）；
}catch（NumberFormatException e）{
//String getmessage（）；
System.out.println（e. getmessage（））；
//e.printStackTrace（）；
}catch（…）{
…
}

说明：
1.finally是可选的
2.使用try将可能出现异常的代码包装起来，在执行过程中，一旦出现异常，就会出现一个异常类的对象，根据此对象的类型，去catch中匹配
3.一旦try中的异常对象匹配到某一个catch时，就进入catch中进行异常的处理。一旦处理完成，就跳出当前的try-catch结构（在没有写finally的结构），继续执行其后的代码。
4.catch中的异常类型如果没有子父类关系，则谁声明在上，谁声明在下都无所谓。
catch中的异常类型如果满足子父类关系，则要求子类一定声明在父类上面，否则报错。
5.常用的异常对象处理的方式：
String getMessage（）； / printStackTrace（）；
6.在try结构中声明的变量，出了try结构后，就不能再被调用

使用try-catch-finally处理编译时异常，使得程序在编译时就不再报错，但是在运行时仍可能报错。相当于我们使用try-catch-finally将一个编译时可能出现的异常，延迟到运行时出现。

finally中声明的是一定会被执行的代码，即使catch中又出现异常了，try中有return语句，catch中有return语句等情况。
像数据库链接、输入输出流、网络编程Scoket等资源，JVM是不能自动回收的，我们需要自己手动进行资源释放。此时的资源释放，就需要声明在finally中。

开发时，由于运行时异常比较常见，所以我们通常就不针对运行时异常编写try-catch-finally了，针对编译时异常，我们一定要考虑异常的处理

2.throws+异常类型，写在方法声明处。指明此方法执行时，可能抛出的异常类型。一旦当方法执行时，出现异常，仍会在异常代码处生成一个异常类的对象，此对象满足throws后异常类型时，就会被抛出。异常代码后续的代码，就不再执行。
try-catch-finally，真正将异常处理掉了。throws方式只是将异常抛给了方法的调用者，并没有真正将异常处理掉。

3.开发中如何选择使用try-catch-finally还是throws？
如果父类中被重写的方法没有throws方式处理异常，则子类重写的方法也不能使用throws，意味着如果子类重写的方法有异常，必须使用try-catch-finally方式处理。
执行的方法a中，先后又调用了另外的几个方法，这几个方法是递进关系执行的，我们建议这几个方法使用throws的方式进行处理，而执行的方法a可以使用try-catch-finally的方式处理。

4.多线程的创建：方式一：继承于Thread类
1.创建一个继承于Thread类的子类
2.重写Thread类的run（）； -->将此线程执行的操作声明在run（）中
3.创建Thread类的子类的对象
4.通过此对象调用start（）①启动当前线程（主线程帮忙启动的）②调用当前线程的run（）

我们不能通过调用run（）的方式启动线程。
再启动一个线程，不能让已经start（）的线程去执行，会报异常

创建两个线程，可以创建两个子类继承Thread，通过这两个子类new对象
或者创建匿名子类
new Thread（）{
public void run（）{
//重写run（）方法
}
}.start（）；

new Thread（）{
public void run（）{
//重写run（）方法
}
}.start（）；

5.测试Thread类中的常用方法：
1.start（）：启动当前线程；调用当前线程的run（）
2.run（）：通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
3.currentThread（）：静态方法，返回执行当前代码的线程
4.getName（）：获取当前线程的名字
5.setName（）：设置当前线程的名字
6.yield（）：释放当前cpu的执行权
7.join（）：在线程a中调用线程b的join（），此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态。
8.stop（）：已过时。当执行此方法时，强制结束当前线程。
9.sleep（long milltime）：让当前线程“睡眠”指定的milltime毫秒。在指定的milltime毫秒时间内，当前线程是阻塞状态。
10.isAlive（）：判断当前线程是否存活。

6.线程的优先级：
MAX_PRIORITY:10
MIN_PRIORITY:1
NORM_PRIORITY:5 默认优先级

如何获取和设置当前线程的优先级：
getPriority（）：获取线程的优先级
setPriority（int p）：设置线程的优先级
说明：高优先级的线程要抢占低优先级线程的cpu执行权，但是只是从概率上讲，高优先级的线程高概率的情况下被执行，并不意味着只有当高优先级的线程执行完以后，低优先级的线程才被执行

7.创建多线程的方式二：实现Runnable接口
1.创建一个实现了Runnable接口的类
2.实现类去实现Runnable接口中的抽象方法：run（）
3.创建实现类的对象
4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
5.通过Thread类的对象调用start（）

比较创建线程的两种方式：
开发中，优先选择实现Runnable接口的方式
原因：1.实现的方式没有类的单继承的局限性
2.实现的方式更适合来处理多个线程的共享数据的情况

8.问题：卖票过程中，出现了重票、错票：出现了线程安全问题
问题出现的原因：当某个线程在操作车票的过程中，尚未完成时，其他线程参与进来，也操作车票
如何解决：当一个线程a在操作ticket时，其他线程不能参与进来，直到线程a操作完ticket时，线程才可以开始操作ticket。这种情况即使线程a出现了阻塞，也不能被改变

在Java中，我们通过同步机制，来解决线程的安全问题

方式一：同步代码块
synchronized（同步监视器）{
//需要被同步的代码
}
说明：1.操作共享数据的代码，即为需要被同步的代码。不能包含代码多了，也不能少了
2.共享数据：多个线程共同操作的变量。比如ticket就是共享数据
3.同步监视器俗称锁，任何一个类的对象，都可以充当锁。
要求：多个线程必须共用同一把锁
在实现Runnable接口创建多线程的方法中，我们可以考虑使用this充当同步监视器
在继承Thread类创建多线程的方式中，慎用this充当同步监视器

方式二：同步方法
同步的方式，解决了线程的安全问题——>好处
操作同步代码时，只能有一个线程参与，其他线程等待，相当于是一个单线程的过程，效率低——>局限性

同步方法仍然涉及到同步监视器，只是不需要我们显式的声明
非静态的同步方法，同步监视器是this
静态的同步方法，同步监视器是当前类本身