大家好，我是讯享网，很高兴认识大家。



java零基础思路

Java零基础学习

说明

狂神说Java完整学习路线：Java学习完整路线，强烈建议收藏转发 - 哔哩哔哩 (bilibili.com)

Java零基础学习视频：【狂神说Java】Java零基础学习视频通俗易懂哔哩哔哩bilibili

复习直接看：小结视频：【狂神说Java】Java零基础学习视频通俗易懂哔哩哔哩bilibili

Java基础

注释

1. 单行注释

   //单行注释

   讯享网
2. 多行注释

   讯享网/*
   多行注释
   */

3. 文档注释 JavaDoc

   /
   文档注释
   */

标识符

1. 关键字

   

2. 标识符注意点
   • 标识符由数字（0~9）和字母（A~Z 和 a~z）、美元符号（$）、下划线（_）以及 Unicode 字符集中符号大于 0xC0 的所有符号组合构成（各符号之间没有空格）。
   • 标识符的第一个符号为字母、下划线和美元符号，后面可以是任何字母、数字、美元符号或下划线。
   • 不能使用关键字作为变量名或方法名
   • 标识符是大小写敏感的

   讯享网//合法标识符
   age、$salary、_value、__1_value
   //非法标识符
   123abc、-salary、#abc

数据类型

1. 强类型语言：要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用
2. Java数据类型

   

3. 数据类型扩展
   • 进制

     二进制 0b 、八进制 0 、十六进制 0x

   • 浮点数存在舍入误差，最好完全避免使用浮点数进行比较

     使用BigDecmal数学工具类

   • 所有字符本质还是数字（Unicode编码表）

     

   • 转义字符

     

   public class Demo01 {
    public static void main(String[] args) {
    //整数扩展
    int i = 10;
    int i2 = 010;
    int i3 = 0x10;
   ​
    System.out.println(i);
    System.out.println(i2); //八进制0
    System.out.println(i3); //十六进制0x
    System.out.println("=======================================");
   ​
    //浮点数扩展
    float f = 0.1f;
    double d = 1.0/10;
   ​
    System.out.println(f==d); //false
   ​
    float f1 = 4f;
    float f2 = f1 + 1;
   ​
    System.out.println(f1==f2); //true
    System.out.println("=======================================");
   ​
    //字符扩展
    char c1 = 'a';
    char c2 = '中';
   ​
    System.out.println(c1);
    System.out.println((int)c1);
    System.out.println(c2);
    System.out.println((int)c2);
   ​
    char c3 = 'a'; //a
   ​
    System.out.println(c3);
   ​
    //转义字符
    System.out.println("Hello World");
    System.out.println("=======================================");
   ​
    //布尔值扩展
    boolean flag = true;
    if (flag==true){}
    if (flag){}
    //Less is More! 代码要精简已读
   ​
    }
   }

4. 类型转换
   • 自动类型转换 低--->高
   • 强制类型转换 高--->低 (类型)变量名

   注意：

   1. 不能对布尔值进行转换
   2. 不能把对象类型转换为不相干的类型
   3. 在把高容量转换到低容量的时候要强制转换
   4. 转换的时候可能存在内存溢出或是精度问题

变量、常量、作用域

1. 变量

   public class Demo02 {
    //类变量 static
    static double salary = 2500;
   ​
    //实例变量：从属于对象,如果不初始化，默认输出这个类型的默认值
    //布尔值默认false
    //除了基本类型，其余的默认值都是null
    String name;
    int age;
   ​
    public static void main(String[] args) {
    //局部变量，使用前必须声明和初始化
    int i = 10;
    System.out.println(i);
   ​
    //实例变量
    Code02 code02 = new Code02();
    System.out.println(code02.age);
    System.out.println(code02.name);
   ​
    //类变量
    System.out.println(salary);
    }
   }

2. 常量
   • 初始化之后不能再改变值
   • 常量一般使用大写字符

   public class Demo03 {
    //修饰符，不存在先后顺序
    static final double PI = 3.14;
   ​
    public static void main(String[] args) {
    System.out.println(PI);
    }
   }

3. 命名规范
   • 所有变量名、方法、类名要见名知义
   • 类成员变量使用首字母小写和驼峰原则：monthSalary
   • 局部变量使用首字母小写和驼峰原则：monthSalary
   • 常量使用大写字母和下划线：MAX_VALUE
   • 类名使用首字母大写和驼峰原则：Man、GoodMan
   • 方法名使用首字母小写和驼峰原则：run()、runRun()

运算符

• 条件运算符

public class Demo04 {
 //三元运算符
 public static void main(String[] args) {
 //x ? y : z
 //如果x==true，则结果为y，否则结果为z
​
 int score = 80;
 String type = score<60 ? "不及格" : "及格";
 //if
 System.out.println(type);
 }
}

• 扩展赋值运算符

public class Demo05 {
 public static void main(String[] args) {
 int a = 10;
 int b = 20;

 a += b; //a = a+b
 a -= b; //a = a-b

 System.out.println(a);

 //字符串连接符 +
 System.out.println(a+b);
 System.out.println(""+a+b);
 System.out.println(a+b+"");
 }
}

包机制

• 一般利用公司域名倒置作为包名（com.baidu.www）
• 导包

  import java.util.*;
  import java.util.Date;
  import com.baidu.www.Code01;

JavaDoc

package JavaDoc;

/
 * @author kuangshen
 * @version 1.0
 * @since 1.8
 */

public class Doc {
 String name;

 /
 *
 * @param name
 * @return
 * @throws Exception
 */
 public String test(String name) throws Exception{
 return name;
 }

 //通过命令行生成说明文档：javadoc [相关参数] java文件
 //javadoc -encoding UTF-8 -charset UTF-8 Doc.java

 //百度：使用IDEA生成文档

}

Java流程控制

用户交互Scanner

• next()
  1. 一定要读取到有效字符后才可以结束输入。
  2. 对输入有效字符之前遇到的空白,next()方法会自动将其去掉
  3. 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符
  4. next()不能得到带有空格的字符串

import java.util.Scanner;

public class Demo01 {
 public static void main(String[] args){

 //创建一个扫描器对象，用于接受键盘数据
 Scanner scanner = new Scanner(System.in);

 System.out.println("使用next方式接收：");

 //判断用户有没有输入字符串
 if (scanner.hasNext()){
 String str = scanner.next();
 System.out.println("输入的内容为："+str);
 }

 //凡是属于IO流的类如果不关闭会一直占用资源，要养成好习惯用完就关掉
 scanner.close();
 }
}

• nextLine()
  1. 以Enter为结束符,也就是说nextLine()方法返回的是输入回车之前的所有字符
  2. 可以获得空白

import java.util.Scanner;

public class Demo02 {
 public static void main(String[] args){

 //创建一个扫描器对象，用于接受键盘数据
 Scanner scanner = new Scanner(System.in);

 System.out.println("使用next方式接收：");

 //判断用户有没有输入字符串
 if (scanner.hasNextLine()){
 String str = scanner.nextLine();
 System.out.println("输入的内容为："+str);
 }

 //凡是属于IO流的类如果不关闭会一直占用资源，要养成好习惯用完就关掉
 scanner.close();
 }
}

• Scanner进阶使用

import java.util.Scanner;

public class Demo03 {
 public static void main(String[] args) {
 //我们可以输入多个数字，并求其中和和平均数，每输入一个数字用回车确认，通过输入非数字来结束并输出执行结果
 Scanner scanner = new Scanner(System.in);

 //和
 double sum = 0;
 //计算输入了多少个数字
 int m = 0;

 System.out.println("输入数字进行运算：");
 //通过循环来判断是否还有输入，并在里面对每一次进行求和和统计
 while (scanner.hasNextDouble()){
 double x = scanner.nextDouble();
 m = m + 1; //m++
 sum = sum + x;
 }

 System.out.println(m + "个数的和为" + sum);
 System.out.println(m + "个数的平均值为" + (sum / m));

 scanner.close();
 }
}

顺序结构

选择结构

• If选择结构
  1. if单选择结构

     import java.util.Scanner;
     
     public class IfDemo01 {
      public static void main(String[] args) {
      Scanner scanner = new Scanner(System.in);
     
      System.out.println("请输入内容：");
      String s = scanner.nextLine();
     
      //equals:判断字符串是否相等
      if (s.equals("hello")){
      System.out.println(s);
      }
     
      System.out.println("End");
      scanner.close();
      }
     }

  2. if双选择结构

     import java.util.Scanner;
     
     public class IfDemo02 {
      public static void main(String[] args) {
      //考试分数大于60就是及格，小于60就不及格
      Scanner scanner = new Scanner(System.in);
     
      System.out.println("请输入成绩：");
      int score = scanner.nextInt();
     
      //equals:判断字符串是否相等
      if (score>60){
      System.out.println("及格");
      }else{
      System.out.println("不及格");
      }
     
      scanner.close();
      }
     }

  3. if多选择结构

     import java.util.Scanner;
     
     public class IfDemo03 {
      public static void main(String[] args) {
      //考试分数大于60就是及格，小于60就不及格
      Scanner scanner = new Scanner(System.in);
     
      System.out.println("请输入成绩：");
      int score = scanner.nextInt();
     
      //equals:判断字符串是否相等
      if (score==100){
      System.out.println("恭喜满分");
      }else if (score<100 && score>=90){
      System.out.println("A级");
      }else if (score<90 && score>=80){
      System.out.println("B级");
      }else if (score<80 && score>=70) {
      System.out.println("C级");
      }else if (score<70 && score>=60) {
      System.out.println("D级");
      }else if (score<60 && score>=0) {
      System.out.println("D级");
      }else{
      System.out.println("成绩不合法");
      }
     
      scanner.close();
      }
     }

  4. 嵌套的if结构
• Switch选择结构

  public class SwitchDemo {
   public static void main(String[] args) {
   char grade = 'B';
  
   switch (grade){
   case 'A':
   System.out.println("及格");
   break;
   case 'B':
   System.out.println("不及格");
   break;
   default:
   System.out.println("不清楚");
   }
   }
  }

循环结构

• while循环

  public class WhileDemo {
   public static void main(String[] args) {
   //计算1+2+3+...+100=?
  
   int i = 0;
   int sum = 0;
  
   while (i<=100){
   sum = sum + i;
   i++;
   }
  
   System.out.println(sum);
   }
  }

• do...while循环

  public class DoWhileDemo {
   public static void main(String[] args) {
   int i = 0;
   int sum = 0;
  
   do {
   sum = sum + i;
   i++;
   }while (i<=100);
  
   System.out.println(sum);
   }
  }

• for循环

  public class ForDemo01 {
   public static void main(String[] args) {
   int a = 1; //初始化条件
  
   while (a<=100){ //条件判断
   System.out.println(a); //循环体
   a += 2; //迭代
   }
  
   System.out.println("while循环结束");
  
   //初始化、条件判断、迭代
   for (int i=1; i<=100; i++){
   System.out.println(i);
   }
  
   System.out.println("for循环结束");
   }
  }

  打印九九乘法表

  public class ForDemo02 {
   public static void main(String[] args) {
   //1、先打印第一列
   //2、把固定的1再用一个循环包裹起来
   //3、去掉重复项，i <= j
   //4、调整样式
  
   for (int j = 1; j <= 9; j++){
   for (int i =1; i <= j; i++){
   System.out.print(i+"*"+j+"="+(i*j)+" ");
   }
   System.out.println();
   }
   }
  }

• 增强for循环

  public class ForDemo03 {
   public static void main(String[] args) {
   int[] numbers = {10, 20, 30, 40, 50};
  
   for (int i=0; i<5; i++){
   System.out.println(numbers[i]);
   }
   System.out.println("=================");
  
   //遍历数组
   for (int x: numbers){
   System.out.println(x);
   }
   }
  }

break与continue

• break在任何循环语句的主体部分，均可用break控制循环的流程。break用于强行退出循环，不执行循环中剩余的语句。(break语句也在switch语句中使用)
• continue语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定

练习题（打印三角形）

public class TestDemo {
 public static void main(String[] args) {
 //打印三角形 5行

 for (int i = 1; i <= 5; i++) {
 for (int j = 5; j >= i; j--) {
 System.out.print(" ");
 }
 for (int j = 1; j <= i; j++) {
 System.out.print("*");
 }
 for (int j = 1; j < i; j++) {
 System.out.print("*");
 }
 System.out.println();
 }
 }
}

Java方法

方法的定义和调用

• 方法的定义

  方法包含一个方法头和一个方法体。下面是一个方法的所有部分:

  • 返回值类型∶方法可能会返回值。returnValueType 是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，returnValueType是关键字void
  • 方法名:是方法的实际名称。方法名和参数表共同构成方法签名
  • 参数类型:参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数
  • 形式参数:在方法被调用时用于接收外界输入的数据
    • 形式参数:在方法被调用时用于接收外界输入的数据
    • 实参:调用方法时实际传给方法的数据
  • 方法体：方法包含的具体语句，定义该方法的功能
• 方法的调用

  调用方法：对象名.方法名(实参列表)

  课后拓展：值传递（Java）与引用传递

方法的重载

• 重载就是在一个类中，有相同的函数名称，但形参不同的函数
• 方法的重载的规则:
  • 方法名称必须相同
  • 参数列表必须不同（个数不同、或类型不同、参数排列顺序不同等)。方法的返回类型可以相同也可以不相同
  • 仅仅返回类型不同不足以成为方法的重载
• 实现理论：
  • 方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错

可变参数

• 一个方法只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明

public class Demo01 {
 public static void main(String[] args) {
 //调用可变参数的方法
 printMax(34, 6, 8, 1, 56, 5);
 printMax(new double[]{1, 2, 3});

 }

 public static void printMax(double... numbers){
 if (numbers.length == 0){
 System.out.println("No argument passed");
 return;
 }

 double result = numbers[0];

 //排序
 for (int i = 1; i < numbers.length; i++){
 if (numbers[i] > result){
 result = numbers[i];
 }
 }
 System.out.println("This max value is " + result);

 }

}

递归

• 递归就是:A方法调用A方法!就是自己调用自己
• 利用递归可以用简单的程序来解决一些复杂的问题。它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合
• 递归结构包括两个部分:
  • 递归头:什么时候不调用自身方法。如果没有头，将陷入死循环
  • 递归体:什么时候需要调用自身方法

public class Demo02 {
 public static void main(String[] args) {
 System.out.println(f(5));
 }

 public static int f(int n){
 if (n==1){
 return 1;
 }else{
 return n * f(n-1);
 }
 }
}

• 作业：写一个计算器实现加减乘除功能，并且能够循环接受新数据，通过用户交互实现
• 思路推荐：
  • 写四个方法：加减乘除
  • 利用循环+switch进行用户交互
  • 传递需要操作的两个数
  • 输出结果

    

数组

数组的声明和创建

数组的四个基本特点

• 其长度是确定的。数组一旦被创建，它的大小就是不可以改变的
• 其元素必须是相同类型,不允许出现混合类型
• 数组中的元素可以是任何数据类型，包括基本类型和引用类型
• 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的

三种初始化以及内存分析

• 静态初始化

  int[] a = {1, 2, 3}
  Man[] mans = {new Man(1,1), new Man(2,2)};

• 动态初始化

  int[] a = new int[2];
  a[0] = 1;
  a[1] = 2;

• 数组的默认初始化

  数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化

下标越界

ArrayIndexOutOfBoundsException:数组下标越界异常

二维数组

Arrays类讲解

• 数组的工具类java.util.Arrays
• Arrays类中的方法都是static修饰的静态方法,在使用的时候可以直接使用类名进行调用,而"不用"使用对象来调用(注意:是"不用”而不是"不能")
• 具有以下常用功能:
  • 给数组赋值:通过fil方法
  • 对数组排序:通过sort方法,按升序
  • 比较数组:通过equals方法比较数组中元素值是否相等
  • 查找数组元素:通过binarySearch方法能对排序好的数组进行二分查找法操作

冒泡排序

import java.util.Arrays;

public class ArrayDemo01 {
 public static void main(String[] args) {
 int[] a = {1, 7, 5, 9, 6, 8, 2, 5};
 int[] sort = sort(a);
 System.out.println(Arrays.toString(sort));
 }

 public static int[] sort(int[] array){
 //临时变量
 int temp = 0;

 //外层循环，判断我们这个要走多少次
 for (int i = 0; i < array.length-1; i++){

 boolean flag = false; //通过flag标识位减少没有意义的比较

 //内层循环，比较判断两个数，如果第一个数比第二个数大，这交换位置
 for (int j = 0; j < array.length-1-i; j++){
 if (array[j+1] > array[j]){
 temp = array[j];
 array[j] = array[j+1];
 array[j+1] = temp;
 flag = true;
 }
 }

 if (flag==false){
 break;
 }

 }
 return array;
 }

}

稀疏数组

面向对象

面向过程 & 面向对象

• 面向过程思想
  • 步骤清晰简单，第一步做什么，第二步做什么.....
  • 面对过程适合处理一些较为简单的问题
• 面向对象思想
  • 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索
  • 面向对象适合处理复杂的问题，适合处理需要多人协作的问题
• 对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理

什么是面向对象

• 面向对象编程的本质就是:以类的方式组织代码，以对象的组织(封装)数据
• 三大特性：封装、继承、多态

类和对象的关系

• 类是一种抽象的数据类型,它是对某一类事物整体描述/定义,但是并不能代表某一个具体的事物
• 对象是抽象概念的具体实例

构造器

• 使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用
• 类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下俩个特点:
  1. 必须和类的名字相同
  2. 必须没有返回类型,也不能写void

封装

• 我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉;低耦合:仅暴露少量的方法给外部使用
• 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏
• 记住这句话就够了；属性私有，get/set

继承

• 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模
• JAVA中类只有单继承，没有多继承
• 继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等
• 继承关系的俩个类，一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示。子类和父类之间,从意义上讲应该具有"is a"的关系

super

super注意点：

1. super调用父类的构造方法，必须在构造方法的第一个
2. super必须只能出现在子类的方法或者构造方法中
3. super和 this 不能同时调用构造方法

方法重写

重写：需要有继承关系，子类重写父类的方法

1. 方法名必须相同
2. 参数列表列表必须相同
3. 修饰符的范围可以扩大但不能缩小：public>protected>default>private
4. 抛出的异常：方法的范围可以被缩小，但不能扩大：ClassNotFoundException --> Exception(大)

Application.java

package Demo01;

public class Application {
 //静态方法和非静态方法的重写区别很大
 //静态方法：方法的调用只和左边定义的

 //非静态重写
 public static void main(String[] args) {
 A a = new A();
 a.test(); //A

 //父类的引用指向子类
 B b = new A();
 b.test(); //B
 }
}

B.java

package 面向对象.Demo01;

//重写是方法的重写，与属性无关
public class B {
 public void test(){
 System.out.println("B=>test()");
 }
}

A.java

package 面向对象.Demo01;

//继承
public class A extends B{
 //Override 重写
 //@Override //注解：有功能的注解
 public void test(){
 System.out.println("A=>test()");
 }
}

多态

• 即同一方法可以根据发送对象的不同而采用多种不同的行为方式。一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
• 多态存在的条件
  • 有继承关系
  • 子类重写父类方法
  • 父类引用指向子类对象
• 注意：多态是方法的多态，属性没有多态

Application.java

package Demo02;

public class Application {
 public static void main(String[] args) {

 //一个对象的实际类型是确定的

 //可以指向的引用类型是不确定的：父类的引用指向子类
 //Student能调用的方法都是自己或是继承父类的
 Student s1 = new Student();
 Person s2 = new Student();
 Object s3 = new Student();

 s2.run(); //子类重写了父类的方法，执行子类的方法
 s1.run();

 //对象能执行哪些方法，主要看对象左边的类型，和右边的关系不大
 //s2.eat();
 s1.eat();

 }
}

Person.java

package Demo02;

public class Person {

 public void run(){
 System.out.println("run");
 }
}

Student.java

package Demo02;

public class Student extends Person{

 @Override
 public void run(){
 System.out.println("son");
 }

 public void eat(){
 System.out.println("eat");
 }
}

instanceof和类型转换

Application.java

package Demo02;

public class Application {
 public static void main(String[] args) {

 Object object = new Student();
 System.out.println(object instanceof Student); //true
 System.out.println(object instanceof Person); //true
 System.out.println(object instanceof Object); //true
 System.out.println(object instanceof String); //false

 System.out.println("===============================");

 Person person = new Student();
 System.out.println(person instanceof Student); //true
 System.out.println(person instanceof Person); //true
 System.out.println(person instanceof Object); //true
 //System.out.println(person instanceof String); //false

 }
}

static 关键字

Student.java

package Demo03;

public class Student {

 private static int age; //静态变量 多线程
 private double score; //非静态变量

 public void run(){
 }

 public static void go(){
 }

 public static void main(String[] args) {
 Student s1 = new Student();

 System.out.println(Student.age);
 System.out.println(s1.age);
 System.out.println(s1.score);

 //run(); //静态方法（main）在非静态方法（run）之前调用
 go();
 }

Person.java

package Demo03;

public class Person {
 //2、赋初值
 {
 System.out.println("匿名代码块");
 }

 //1、只执行一次
 static {
 System.out.println("静态代码块");
 }

 //3
 public Person(){
 System.out.println("构造方法");
 }

 public static void main(String[] args) {
 Person p1 = new Person();
 System.out.println("=================");
 Person p2 = new Person();
 }
}

抽象类

接口的定义与实现

内部类

1. 成员内部类
2. 静态内部类
3. 局部内部类
4. 匿名内部类

异常

Error 和 Exception

要理解Java异常处理是如何工作的，你需要掌握以下三种类型的异常：

• 检查性异常：最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略
• 运行时异常：运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略
• 错误：错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的

异常结构体系

• Java把异常当作对象来处理，并定义一个基类java.lang.Throwable作为所有异常的超类
• 在Java APl中已经定义了许多异常类，这些异常类分为两大类，错误Error和异常Exception

1. Error
   • Error类对象由Java虚拟机生成并抛出，大多数错误与代码编写者所执行的操作无关
   • Java虚拟机运行错误（Virtual MachineError)，当JVM不再有继续执行操作所需的内存资源时，将出现 OutOfMemoryError。这些异常发生时，Java虚拟机(JVM)一般会选择线程终止
   • 还有发生在虚拟机试图执行应用时，如类定义错误(NoClassDefFoundError)、链接错误(LinkageError)。这些错误是不可查的，因为它们在应用程序的控制和处理能力之外，而且绝大多数是程序运行时不允许出现的状况
2. Exception
   • 在Exception分支中有一个重要的子类RuntimeException(运行时异常)
     • ArraylndexOutOfBoundsException(数组下标越界)
     • NullPointerException(空指针异常)
     • ArithmeticException(算术异常)
     • MissingResourceException(丢失资源)
     • ClassNotFoundException(找不到类)等异常，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理
   • 这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生
   • Error和Exception的区别: Error通常是灾难性的致命的错误，是程序无法控制和处理的，当出现这些异常时，Java虚拟机(JVM)一般会选择终止线程;Exception通常情况下是可以被程序处理的，并目在程序中应该尽可能的去外理这些异常

捕抓与抛出异常

关键字：try catch finally throw throws

Test.java

package Demo01;

public class Test {
 public static void main(String[] args) {

 int a = 1;
 int b = 0;

 /*
 //假设要捕获多个异常：要从小到大
 try{ //try监控区域
 System.out.println(a/b);
 }catch (Error e){ //catch(想要捕获的异常类型) 捕获异常
 System.out.println("Error");
 }catch (Exception e){
 System.out.println("Exception");
 }catch (Throwable e){
 System.out.println("Throwable");
 }finally{ //处理善后工作
 System.out.println("finally");
 }
 */

 new Test().test(1, 0);

 }

 public void test(int a, int b){
 if (b==0){
 throw new ArithmeticException(); //主动抛出异常
 }
 System.out.println(a/b);
 }
}

自定义异常

• 使用Java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户还可以自定义异常。用户自定义异常类，只需继承Exception类即可
• 在程序中使用自定义异常类，大体可分为以下几个步骤
  1. 创建自定义异常类
  2. 在方法中通过throw关键字抛出异常对象
  3. 如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理;否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作
  4. 在出现异常方法的调用者中捕获并处理异常

MyException.java

package Demo02;

public class MyException extends Exception{

 //传递数字 >10
 private int detail;

 public MyException(int a){
 this.detail = a;
 }

 //toString:
 @Override
 public String toString(){
 return "MyException{" + detail + "}";
 }
}

Test.java

package Demo02;

public class Test {

 static void test(int a) throws MyException{

 System.out.println("传递的参数为" + a);

 if (a>10){
 throw new MyException(a); //抛出异常
 }

 System.out.println("OK");
 }

 public static void main(String[] args) {
 try{
 test(11);
 }catch (MyException e){
 System.out.println("MyException=>" + e);
 }
 }
}

应用经验总结

• 处理运行时异常时，采用逻辑去合理规避同时辅助try-catch处理
• 在多重catch块后面，可以加一个catch (Exception)来处理可能会被遗漏的异常对于不确定的代码，也可以加上 try-catch，处理潜在的异常
• 尽量去处理异常，切忌只是简单地调用printStackTrace()去打印输出具体如何处理异常，要根据不同的业务需求和异常类型去决定
• 尽量添加finally语句块去释放占用的资源

总结

复习直接看：小结视频：【狂神说Java】Java零基础学习视频通俗易懂哔哩哔哩bilibili