【Java基础】泛型、反射、异常处理、线程

泛型

什么是泛型

Java是一种强类型语言，允许程序员在强类型程序设计语言中编写代码时定义一些可变部分，那些部分在使用前必须作出指明。集合类是支持泛型的。

List<Integer> list = new ArrayList<>() 这里就是利用泛型进行了声明。

为什么使用泛型

缺点：如果不使用泛型

• 需要强制类型转换： 由于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<String> 处定义
            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 方法更具有优势，

1. 从代码架构上可以解耦，一个是具体的任务也就是Run方法内部，另一个是与线程生命周期相关的内容等。
2. Thread方法每次需要新建一个线程，新建线程会有损耗高，无法重复利用同一个线程。
3. 可以实现多个接口。

启动方法

采用new Thread(runnable).star()，这个方法会调用star()方法，这个方法的核心是首先检查线程状态否则抛出异常，然后执行star0这个方法。这个方法会调用run方法执行。

错误的方法是直接调用run方法，这样只是在主线程里面执行了。无法经历线程的各个周期。

线程的停止

停止线程的方法：interrupt会中断，但是不会强制。但是线程本身是最高的权限，保证不会被打断引发安全问题。

注意在sleep中发生中断并且被catch之后会清除中断标记位。之后无法用Thread.curruntThread.isInterrupted()检测到中断的发生。修改建议是，在cath语句中再次设置中断，Thread.currentThread().interrupt();。

处理中断的方法：需要请求方（发出信号），被停止方（时时检查），子方法配合（抛出中断）

1. 在子方法中抛出throws中断，留给更高层次的函数去检查
2. 子方法采用try-catch捕获了中断，重置中断，并且在高层次的函数中设计检查中断位，进行处理。

错误做法：子函数吞了中断请求，高层函数无法处理。

响应中断的方法：中断信号到了可以处理或者感知。

1. Object.wait()
2. Thread.sleep()
3. Thread.join()
4. java.util.concurrent.BlockingQueue.take()/put()
5. java.util.concurrent.locks.Lock.lockInterruptibly()
6. CountDownLatch.await()
7. CyclicBarrier.await()
8. Exchager.exchange()
9. Io相关操作

错误的线程停止方法：

1. 调用弃用Stop方法，会引起程序错乱。虽然stop方法会释放所有的监视器。
2. 使用弃用的suspend ，这个方法会被挂起，但是不会释放锁。容易导致死锁。
3. 采用置位volatile的方法。但是，这个方法在陷入阻塞时，无法中断线程。

辨析：

• static boolean interrupted() 这是一个静态方法，是当前执行类的。会获取中断标志位并且重置。
• boolean isInterrupted() 这个方法是需要被实例调用的，返回实例线程的中断标志。

线程的状态和生命周期

六种不同的线程状态：

1. NEW：新建状态，尚未启动的线程处于此状态；
2. RUNNABLE：可运行状态，Java 虚拟机中执行的线程处于此状态；
3. BLOCK：阻塞状态，等待监视器锁定而被阻塞的线程处于此状态；
4. WAITING：等待状态，无限期等待另一线程执行特定操作的线程处于此状态；
5. TIME_WAITING：定时等待状态，在指定等待时间内等待另一线程执行操作的线程处于此状态；
6. TERMINATED：结束状态，已退出的线程处于此状态。