【Java基础】泛型、反射、异常处理、线程
文章目录
- 泛型
- 什么是泛型
- 为什么使用泛型
- 异常
- 什么是异常
- 异常类的构架
- Error类
- Exception类
- 非检查异常
- 检查异常
- 异常处理机制
- 抛出异常
- 捕获异常
- 反射
- 什么是反射
- 反射常用类
- 线程
- 创建线程
- 创建线程续
- 启动方法
- 线程的停止
- 线程的状态和生命周期
泛型
什么是泛型
Java是一种强类型语言，允许程序员在强类型程序设计语言中编写代码时定义一些可变部分，那些部分在使用前必须作出指明。集合类是支持泛型的。
List 这里就是利用泛型进行了声明。
为什么使用泛型
缺点：如果不使用泛型
- 需要强制类型转换： 由于
ArrayList内部就是一个Object[]数组，在get()元素的时候，返回的是Object类型，所以在ArrayList外获取该对象，需要强制类型转换。 - 可向集合中添加任意类型的对象，存在类型不安全风险。
优点：
- 可以减少类型转换的次数，代码更加简洁；
- 程序更加健壮：只要编译期没有警告，运行期就不会抛出
ClassCastException异常； - 提高了代码的可读性：编写集合的时候，就限定了集合中能存放的类型。
异常
什么是异常
程序的错误可以分为，编译期间的错误和运行期间的错误。
异常类的构架
Error类
它可以指示合理的应用程序不应该尝试捕获的严重问题。这些错误在应用程序的控制和处理能力之外，编译器不会检查 Error，对于设计合理的应用程序来说，即使发生了错误，本质上也无法通过异常处理来解决其所引起的异常状况。
常见 Error：
-
AssertionError：断言错误； -
VirtualMachineError：虚拟机错误； -
UnsupportedClassVersionError：Java 类版本错误； -
OutOfMemoryError：内存溢出错误。
Exception类
它指示合理的应用程序可能希望捕获的条件。
Exception 又包括 Unchecked Exception（非检查异常）和Checked Exception（检查异常）两大类别。
非检查异常
编写代码时即使不去处理此类异常，程序还是会编译通过，包含RuntimeException 以及它的相关子类。
常见非检查异常：
-
NullPointerException：空指针异常； -
ArithmeticException：算数异常； -
ArrayIndexOutOfBoundsException：数组下标越界异常； -
ClassCastException：类型转换异常。
检查异常
编译器要求必须处理的异常。除了 RuntimeException 以及它的子类，都是 Checked Exception 异常。这部分要求我们进行处理，进行try-catch处理，或者抛出。
常见检查异常：
-
IOException：IO 异常 -
SQLException：SQL 异常
异常处理机制
分为俩个部分，抛出异常，捕获异常。
抛出异常
throw抛出异常，得到异常对象。我们可以使用throw关键字抛出任何类型的Throwable对象，它会中断方法，throw语句之后的所有内容都不会执行。除非已经处理抛出的异常。异常对象不是从方法中返回的，而是从方法中抛出的。
//自定义一个异常，并且抛出
public class ExceptionDemo4 {
// 要是静态累，继承自RuntimeException
static class MyCustomException extends RuntimeException {
// 无参构造方法
public MyCustomException() {
super("我的自定义异常");
}
}
public static void main(String[] args) {
// 直接抛出异常
throw new MyCustomException();
}
}
-
throws有如下使用规则：- 如果方法中全部是非检查异常（即 Error、RuntimeException 以及的子类），那么可以不使用 throws 关键字来声明要抛出的异常，编译器能够通过编译，但在运行时会被系统抛出；
- 如果方法中可能出现检查异常，就必须使用 throws 声明将其抛出或使用 try catch 捕获异常，否则将导致编译错误；
- 当一个方法抛出了异常，那么该方法的调用者必须处理或者重新抛出该异常；
- 当子类重写父类抛出异常的方法时，声明的异常必须是父类所声明异常的同类或子类。
捕获异常
使用 try 和 catch 关键字可以捕获异常。
try用于检测异常，发生异常时，异常就会被抛出；
catch 语句块：catch 语句包含要捕获的异常类型的声明，当 try 语句块发生异常时，catch 语句块就会被检查。
finally 语句块：无论是否发生异常，都会执行 finally 语句块。一般会放在 finally 语句块中释放资源。
反射
什么是反射
Java 的反射（reflection）机制是指在程序的运行状态中，可以构造任意一个类的对象，可以了解任意一个对象所属的类，可以了解任意一个类的成员变量和方法，可以调用任意一个对象的属性和方法。
- 反射的使用场景：Java 的反射机制，主要用来编写一些通用性较高的代码或者编写框架的时候使用
反射常用类
Class：Class 类的实例表示正在运行的 Java 应用程序中的类和接口；Constructor：关于类的单个构造方法的信息以及对它的权限访问；Field：Field提供有关类或接口的单个字段的信息，以及对它的动态访问权限；Method：Method提供关于类或接口上单独某个方法的信息。
线程
线程是操作系统能够进行运算调度的最小单位。大部分情况下，它被包含在进程之中，是进程中的实际运作单位。也就是说一个进程可以包含多个线程， 因此线程也被称为轻量级进程。
创建线程
- 继承
Thread类创建线程。要重写子方法run()，创建线程对象，调用start方法启动线程。(一般会创建一个静态内部类实现继承Thread方法)
升级：可以继承多个接口，且开销小
- 实现
Runnable接口。首先子类继承接口并实现run()方法，然后分别创建Runnable子类实例（创建两个实现 Runnable 实现类的实例），以Runnable子类实例为对象，创建线程并启动。
/**
* @author colorful@TaleLin
*/
public class RunnableDemo1 implements Runnable {
private int i = 5;
@Override
public void run() {
while (i > 0) {
System.out.println(Thread.currentThread().getName() + " i = " + i);
i--;
}
}
public static void main(String[] args) {
// 创建两个实现 Runnable 实现类的实例
RunnableDemo1 runnableDemo1 = new RunnableDemo1();
RunnableDemo1 runnableDemo2 = new RunnableDemo1();
// 创建两个线程对象
Thread thread1 = new Thread(runnableDemo1, "线程1");
Thread thread2 = new Thread(runnableDemo2, "线程2");
// 启动线程
thread1.start();
thread2.start();
}
}
升级：继承 Thread 类和实现Runnable 接口这两种创建线程的方式都没有返回值。
- 实现
Callable接口。首先创建Callable的实现类（一般是静态内部类），实现call()方法，这个方法是有返回体的（注意泛型）。创建Callable的实例，并且用FutureTask类来包装。以FutureTask为对象创建线程并启动。调用FutureTask对象的get()方法获得线程结束以后的返回值。
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
* @author colorful@TaleLin
*/
public class CallableDemo1 {
static class MyThread implements Callable<String> {
@Override
public String call() { // 方法返回值类型是一个泛型，在上面 Callable 处定义
return "我是线程中返回的字符串";
}
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
// 常见实现类的实例
Callable<String> callable = new MyThread();
// 使用 FutureTask 类来包装 Callable 对象
FutureTask<String> futureTask = new FutureTask<>(callable);
// 创建 Thread 对象
Thread thread = new Thread(futureTask);
// 启动线程
thread.start();
// 调用 FutureTask 对象的 get() 方法来获得线程执行结束后的返回值
String s = futureTask.get();
System.out.println(s);
}
}
创建线程续
Orale文档实际上只给出了两种方法。一个是继承Thread类，重写run方法。另一个是实现Runnable接口的Run方法，并把Runnable实例传给Thread类。
采用实现Runnable 方法更具有优势，
- 从代码架构上可以解耦，一个是具体的任务也就是Run方法内部，另一个是与线程生命周期相关的内容等。
- Thread方法每次需要新建一个线程，新建线程会有损耗高，无法重复利用同一个线程。
- 可以实现多个接口。
启动方法
采用new Thread(runnable).star()，这个方法会调用star()方法，这个方法的核心是首先检查线程状态否则抛出异常，然后执行star0这个方法。这个方法会调用run方法执行。
错误的方法是直接调用run方法，这样只是在主线程里面执行了。无法经历线程的各个周期。
线程的停止
停止线程的方法：interrupt会中断，但是不会强制。但是线程本身是最高的权限，保证不会被打断引发安全问题。
注意在sleep中发生中断并且被catch之后会清除中断标记位。之后无法用Thread.curruntThread.isInterrupted()检测到中断的发生。修改建议是，在cath语句中再次设置中断，Thread.currentThread().interrupt();。
处理中断的方法：需要请求方（发出信号），被停止方（时时检查），子方法配合（抛出中断）
- 在子方法中抛出
throws中断，留给更高层次的函数去检查 - 子方法采用try-catch捕获了中断，重置中断，并且在高层次的函数中设计检查中断位，进行处理。
错误做法：子函数吞了中断请求，高层函数无法处理。
响应中断的方法：中断信号到了可以处理或者感知。
- Object.wait()
- Thread.sleep()
- Thread.join()
- java.util.concurrent.BlockingQueue.take()/put()
- java.util.concurrent.locks.Lock.lockInterruptibly()
- CountDownLatch.await()
- CyclicBarrier.await()
- Exchager.exchange()
- Io相关操作
错误的线程停止方法：
- 调用弃用Stop方法，会引起程序错乱。虽然stop方法会释放所有的监视器。
- 使用弃用的suspend ，这个方法会被挂起，但是不会释放锁。容易导致死锁。
- 采用置位volatile的方法。但是，这个方法在陷入阻塞时，无法中断线程。
辨析：
- static boolean interrupted() 这是一个静态方法，是当前执行类的。会获取中断标志位并且重置。
- boolean isInterrupted() 这个方法是需要被实例调用的，返回实例线程的中断标志。
线程的状态和生命周期
六种不同的线程状态：
NEW：新建状态，尚未启动的线程处于此状态；RUNNABLE：可运行状态，Java 虚拟机中执行的线程处于此状态；BLOCK：阻塞状态，等待监视器锁定而被阻塞的线程处于此状态；WAITING：等待状态，无限期等待另一线程执行特定操作的线程处于此状态；TIME_WAITING：定时等待状态，在指定等待时间内等待另一线程执行操作的线程处于此状态；TERMINATED：结束状态，已退出的线程处于此状态。