01.第一章:异常_概念:
1).什么是“异常”:指程序在运行过程中遇到了一些无法处理的情况,这时JVM会向控制台打印错误信息,并停止程序。
这不是我们想看到的结果。基于此,Java为我们提供了一种“异常处理机制”可以使我们程序在发生异常情况时,
可以跳过异常的代码,继续向下执行。
2).JVM处理异常的默认方式:
1).JVM执行到有异常的代码;
2).JVM会识别出这种异常;
3).JVM会到类库中找到描述这种异常的“异常类”–JVM为每种异常情况都定义了“异常类”。并创建异常对象;
4).JVM会到代码中查看我们的代码是否“捕获”这种异常:
否:JVM向控制台打印异常信息,并结束程序;【之前的情况】
是:JVM会执行“异常处理代码-catch”–【今天讲的】
02.第一章:异常_异常和错误的区别
Throwable(所有异常的根类)
|–Error(错误):我们不需要捕获,因为捕获也没有意义;
|–Exception(异常):我们程序需要捕获并处理的。
|–RuntimeException(运行时异常):
|–其它的异常(编译期异常):
03.第一章:异常_常见的运行时异常:
1).空指针异常–NullPointerException:
int[] arr1 = null;
System.out.println(arr1.length);//NullPointerExcepiton–空指针异常
2).数组索引越界异常–ArrayIndexOutOfBoundsException:
int[] arr2 = {1,2,3};
System.out.println(arr2[30]);//ArrayIndexOutOfBoundsException–数组索引越界异常
3).字符串索引越界异常–StringIndexOutOfBoundsException
String str = “Hello”;
System.out.println(str.charAt(30));//StringIndexOutOfBoundsException–字符串索引越界
4).数学运算异常–ArithmaticException
int a = 10 / 0;
System.out.println("a = " + a);//ArithmeticException–数学运算异常
04.第一章:异常_异常处理_throw(抛出):【了解】
示例代码:
public class Demo {
public static void main(String[] args) {
int[] arr = null;
if(arr == null){
//抛出异常--抛给此方法的调用者--JVM
throw new NullPointerException("空指针异常!");
}
System.out.println(arr.length);
}
}
05.第一章:异常_异常处理_Objects_requireNonNull方法:【了解】
有时我们定义的类中的属性是不希望被赋值为:null的:
class Student{
private String name;
private String address;
public Student(String name,String address){
/*
if(name == null){
//抛出异常--相当于return,立即结束方法,向调用者返回一个异常对象
throw new NullPointerException("名字不能为null");
}
if(address == null){
throw new NullPointerException("地址不能为null");
}
*/
//Objects的requeireNonNull()方法内部会判断参数是否为null,是:抛出异常
//这样就不需要我们自己判断,它会为我们判断。
this.name = Objects.requireNonNull(name);
this.address = Objects.requireNonNull(address);
}
}
main(){
Student stu = new Student(null,"北京");
}
05.第一章:异常_异常处理_throws(声明抛出):【掌握】
public static void main(String[] args) {
int[] arr = {432,43,24,32,432,43,24,3243};
int r = sum(null);
System.out.println("累加和是" + r);
}
throws的作用:告诉JVM,我这个方法中可能会抛出这个异常,如果真的发生这个异常
请将这个异常对象抛给"调用处"。
public static int sum(int[] arr) throws NullPointerException,
ArrayIndexOutOfBoundsException{
int sum = 0;
for (int i = 0; i < arr.length; i++) {
sum += arr[i];
}
return sum;
}
注意:
1.如果throws抛出的是“运行时异常”,调用处可以不处理,编译会通过,但如果真的出现异常,
仍然是终止程序。
2.如果throws抛出的是“编译期异常”,调用处必须处理(try…catch/抛出),否则编译错误。
06.第一章:异常_异常处理_try_catch语句:【掌握】
1).格式:
try{
//可能出现异常的代码
}catch(异常类型名 变量名){
//如果try中出现了与"异常类型名"一样的异常,就会执行这个
//catch语句。
}
2).示例代码:
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while(true) {
System.out.println("请输入年龄:");
try {
int age = sc.nextInt();
System.out.println("你的年龄是:" + age);
break;
} catch (InputMismatchException e) {
sc = new Scanner(System.in);
System.out.println("哥们,请输入数字!");
}
}
System.out.println("后续程序...");
}
07.第一章:异常_异常处理_异常对象的操作:
public static void main(String[] args) {
int[] arr = {1,2,3};
try {
System.out.println(arr[30]);
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("异常信息:" + e.getMessage());//异常信息
System.out.println("toString() : " + e.toString());//异常类名 + 异常信息
e.printStackTrace();//常用,调试的时候。上线后-写日志
}
}
08.第一章:异常_异常处理_多catch语句:
try{
//...
//...
//...
}catch(异常类名1 变量名){
}catch(异常类名2 变量名){
}catch(异常类名3 变量名){
}
示例代码:
public static void main(String[] args) {
try {
int[] arr = null;
System.out.println(arr.length);//这里出异常--这里后面的代码将不会被执行
int[] arr2 = {1, 2, 3};
System.out.println(arr2[4]);
int a = 10 / 0;
System.out.println(a);
//后续代码....
} catch (NullPointerException e) {
System.out.println("空指针异常");
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("数组索引越界异常!");
} catch (ArithmeticException e) {
System.out.println("数学运算异常!");
} catch (Exception e) {
System.out.println("其它的异常,由我来处理...");
System.out.println("我只能写在多个catch的最后");
}
注意:如果异常类型有“父类”类型,要将父类的异常类型写在多catch的末尾
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
try {
int[] arr = null;
System.out.println(arr.length);//出异常,后面的try..catch语句还会被执行
} catch (NullPointerException e) {
System.out.println("空指针异常!");
}
try {
int[] arr2 = {1, 2, 3};
System.out.println(arr2[4]);
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("空指针异常!");
}
}
以后写方法时的建议:
public void show(){
try{
...
try{
}catch(...){
}
...
...
try{
}catch(...){
}
}catch(Exception e){
}
}
09.第一章:异常_异常处理_try_catch_finally:
1).格式:
try{
...
}catch(...){
...
}finally{
//无论是否出现都会被执行的代码
//尤其在方法中,当try中有return时,需要关闭资源时尤其有用。
}
2).示例代码:
public class Demo {
public static void main(String[] args) {
file();
}
public static String file() {
try {
System.out.println("打开文件...");
System.out.println("读取文件...");
int a = 10 / 0;
return "文件内容";//在执行return的过程中,会去调用:finally
}catch (Exception e){
System.out.println("异常了...");
return null;//在执行return的过程中,会去调用:finally
}finally {
System.out.println("关闭文件...");
}
}
}
10.第一章:异常_自定义的异常:
1).在我们的程序中,根据某些业务,需要抛出某种异常,但类库中没有,这时我们就可以自定义异常。例如:
class Student{
private int age;
public void setAge(int age){
if(age < 15 || age > 50){
//必须要想办法通知调用处,这个参数不正确。
//抛出异常
throw new 自定义异常对象();
}
this.age = age;
}
}
2).自定义异常:
1).自定义类继承自Exception(编译期异常)或者RuntimeException(运行时异常)
public class AgeException extends RuntimeException {
public AgeException() {
}
public AgeException(String message) {
super(message);
}
}
2).使用自定义异常:
public class Student {
private int age;
public void setAge(int age) {
if (age < 15 || age > 50) {
throw new AgeException("哥们,年龄值必须在15到50之间!");
}
this.age = age;
}
}
3).测试类:
public class Demo {
public static void main(String[] args) {
Student stu = new Student();
try {
stu.setAge(10);
} catch (AgeException e) {
System.out.println("异常信息:" + e.getMessage());
}
}
}
11.第一章:异常_子类重写父类方法时的异常抛出
class Fu{
public void show1()(//不抛出任何异常
}
public void show2() throws NullPointerException{//抛出运行时异常
}
public void show3() throws IOException{//编译期异常
}
}
class Zi extends Fu{
//子类重写三个方法,可以:
1).不抛出任何异常
2).可以抛出任何的“运行时异常”;
3).不能抛出比父类更多的“编译器异常”
}
12.第二章:多线程_常见概念:
1).什么是“进程”:“进程”是操作系统中的概念,指一个“独立运行的程序”。
2).什么是“线程”:“线程”由“进程”创建的,指一个进程,可以将一部分代码以“独立的方式”运行,
并且与“主进程”--“同时执行”,这样也就意味着,我们的程序可以同时做多件事情。
3).什么是“并行”:并行:指两个或多个事件在同一时刻发生(同时发生)
4).什么是“并发”:并发:指两个或多个事件在同一个时间段内发生。
13.第二章:多线程_实现线程的方式:
1).自定义类,继承自Thread,并且重写run()方法;
2).创建线程对象;
3).调用对象的start()方法:
示例代码:
public class MyThread extends Thread {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("鼓掌....");
}
}
}
public class Demo {
public static void main(String[] args) {
//1.创建线程对象
MyThread t = new MyThread();
//2.启动线程
// t.run();//普通方法调用,不会启动线程
t.start();//启动线程
//3.主线程会继续向下
for (int i = 0; i < 100; i++) {
System.out.println("吹口哨...");
}
}
}
4).注意事项:
1).重写的是run(),但启动线程调用的是start();
2).对于一个“线程对象”,只能start()一次,然后立即成为垃圾。
3).对于同一个“线程类”,可以创建多个“线程对象”,每个线程对象都可以独立运行。
学习目标总结:
01.能够辨别程序中异常和错误的区别
1).错误:Error – XxxxxxError
2).异常:Exception – XxxxxxxException
02.说出异常的分类
Exception:
|–RuntimeException:(运行时异常)
|–其它异常(编译期异常)
03.说出虚拟机处理异常的方式
1).JVM执行到有异常的代码;
2).JVM会识别出这种异常;
3).JVM会到类库中找到描述这种异常的“异常类”--JVM为每种异常情况都定义了“异常类”。并创建异常对象;
4).JVM会到代码中查看我们的代码是否“捕获”这种异常:
否:JVM向控制台打印异常信息,并结束程序;【之前的情况】
是:JVM会执行“异常处理代码-catch”--【今天讲的】
04.列举出常见的三个运行期异常
1).NullPointerException
2).ArrayIndexOutOfBoundsException
3).ArithmaticException(数学异常)int a = 10 / 0;
05.能够使用try…catch关键字处理异常
try{
//可能出现异常的代码
}catch(异常类名 变量名){
//如果try中出现了“异常类名”的异常,会执行这里。
}
06.能够使用throws关键字处理异常
main(){
}
public static void show() throws NullPointerException{
}
07.能够自定义异常类
class AgeException extends RuntimeException{
public AgeException(){
}
public AgeException(String msg){
}
}
08.能够处理自定义异常类
class Student{
private int age;
public void setAge(int age){
if(age < 15 || age > 50){
throw new AgeException("年龄错误!");
}
this.age = age;
}
}
09.说出进程的概念
1).什么是进程:操作系统中一个独立运行的程序;
10.说出线程的概念
1).什么是线程:线程是由进程创建的,可以独立运行的代码,与主线程同时运行。
11.能够理解并发与并行的区别
1).并行:指两个或多个事件在同一时刻发生(同时发生)。 2).并发:指两个或多个事件在同一个时间段内发生。
12.能够开启新线程
1).制作线程:
class MyThread extends Thread{
public void run(){
....
}
}
2).启动线程:
MyThread t = new MyThread();
t.start();
//主线程会继续向下
....