欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识！
您现在的位置是： 首页  >  IT编程

Java基础语法（泛型、反射、异常处理、线程）

程序员文章站 2022-06-28 17:20:04
文章目录泛型什么是泛型为什么使用泛型异常什么是异常异常类的构架Error类Exception类非检查异常检查异常异常处理机制抛出异常捕获异常反射什么是反射反射常用类线程创建线程线程的状态和生命周期泛型什么是泛型Java是一种强类型语言，允许程序员在强类型程序设计语言中编写代码时定义一些可变部分，那些部分在使用前必须作出指明。集合类是支持泛型的。List list = new ArrayList<>() 这里就是利用泛型进行了声明。为什么使用泛型缺点：如果...


文章目录


泛型

什么是泛型

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

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

为什么使用泛型

缺点：如果不使用泛型

  • 需要强制类型转换： 由于ArrayList内部就是一个Object[]数组，在get()元素的时候，返回的是Object类型，所以在ArrayList外获取该对象，需要强制类型转换。
  • 可向集合中添加任意类型的对象，存在类型不安全风险。

优点：

  • 可以减少类型转换的次数，代码更加简洁；
  • 程序更加健壮：只要编译期没有警告，运行期就不会抛出ClassCastException异常；
  • 提高了代码的可读性：编写集合的时候，就限定了集合中能存放的类型。

异常

什么是异常

程序的错误可以分为，编译期间的错误和运行期间的错误。

异常类的构架

Java基础语法（泛型、反射、异常处理、线程）

Error类

它可以指示合理的应用程序不应该尝试捕获的严重问题。这些错误在应用程序的控制和处理能力之外，编译器不会检查 Error，对于设计合理的应用程序来说，即使发生了错误，本质上也无法通过异常处理来解决其所引起的异常状况。

常见 Error：

  • AssertionError：断言错误；

  • VirtualMachineError：虚拟机错误；

  • UnsupportedClassVersionError：Java 类版本错误；

  • OutOfMemoryError ：内存溢出错误。

Exception类

它指示合理的应用程序可能希望捕获的条件。

Exception 又包括 Unchecked Exception（非检查异常）和Checked Exception（检查异常）两大类别。

非检查异常

编写代码时即使不去处理此类异常，程序还是会编译通过，包含RuntimeException 以及它的相关子类。

常见非检查异常：

  • NullPointerException：空指针异常；

  • ArithmeticException：算数异常；

  • ArrayIndexOutOfBoundsException：数组下标越界异常；

  • ClassCastException：类型转换异常。

检查异常

编译器要求必须处理的异常。除了 RuntimeException 以及它的子类，都是 Checked Exception 异常。

常见检查异常：

  • 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); } }

线程的状态和生命周期

六种不同的线程状态：

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

本文地址：https://blog.csdn.net/zcz5566719/article/details/107876806

相关标签： Java入门 多线程 java python jvm

上一篇： Mybatis基本环境搭建及CRUD基本方法使用

下一篇： 软件设计模式六大原则-接口隔离原则 Interface Segregation Principle

推荐阅读