java基础

基础

注释

  1. 单行注释：//
  2. 多行注释：/* */
  3. JavaDoc：文档注释：/**+回车

标识符

只能以大小写字母、下划线、美元符号开头（大小写敏感）

数据类型

Java强类型语言：所有变量必须先定义后使用

8种基本数据类型：

  1. 整型：byte、int、short、long
  2. 浮点型：double、float
  3. 字符型：char
  4. 布尔型：boolean
//整型
int num0=10;//最常用
byte num1=20;
short num2=30;
long num3=40L;//Long类型要在最后加个L
//浮点型
float num4=50.1F//float 类型要在数字后加个F
double num5=3.14159265358979;
//字符
char name0='我';//只能单个字符
String name1="我们"//字符串String不是关键字，是类
//布尔值：是非
boolean flag=true;
//boolean flag=flase;

引用类型：类，接口，数组（除了8基本数据类型其他都是引用类型）

最好完全避免使用浮点数（有限，离散，舍入误差，大约，接近但不等于）进行比较

强制类型转换（int/...），转义字符\n\t...

强制类型转换

  • 强制转换：（类型）变量名 高--低
  • 自动转换： 低--高（byte,short,char->int->long->flout->double）

注意点：

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

变量

变量：空间固定，内容不固定（就是个柜子，用来放东西）（本来存在，就是加了个标签，表示用来放特定的东西）

类变量：static，加这个的就是类变量，，从属于类

实例变量：类里面，方法外面，从属于对象（全局变量）

局部变量：必须声明和初始化值

常量

final ：修饰的，一般大写字母和下划线表示（修饰符不区分先后）

命名规范：

  1. 所有变量、方法、类名：见名知意
  2. 类成员变量：首字母小写和驼峰原则（除了第一个单词外，后面的单词首字母大写）
  3. 局部变量：首字母小写和驼峰原则
  4. 常量：大写字母和下划线
  5. 类名：首字母大写和驼峰原则
  6. 方法名：首字母小写和驼峰原则

运算符

operator优先级（）多用（）更清楚

instanceof：判断一个对象是否是一个类的实例

  • 算术运算符：+，-，*，/，%，++，--
  • 赋值运算符：=
  • 关系运算符：>, <, >=, <=, ==, !=, instanceof(实例)
  • 逻辑运算符：&&，||，！(与或非)（熔断原则&短路原则）
  • 位运算符：&，|，^, ~, >>, <<, >>>(了解)
  • 条件运算符:？：
  • 扩展运算符:+=.-=,*=,/=

包机制

包的本质就是文件夹，用来区别类名的命名空间

包语句的语法格式为：package pkg1【.pkg2【.pkg3...】】

为使用某一个包的成员，需要导入该包。用import可完成

import package1【.package2...】.（classname|*）；

.*是通类符导入该包所有东西

一般用公司域名倒置做包名

javaDoc

javaDoc命令是用来生成自己API文档的

参数信息：

  • @author 作者名
  • @version 版本号
  • @since 指明需要最早使用的jdk版本
  • @param 参数名
  • @return 返回值情况
  • @throws 异常抛出情况

利用命令行生成文档：

javadoc -encoding UTF-8 -charset UTF-8 类名.java

IDEA生成javaDoc文档

Scanner对象

工具类：java.util.Scanner

可以通过Scanner对象获取用户的输入

基本语法：Scanner s=new Scanner（System.in）；

通过Scanner类的next（）与nextLine（）方法获取输入的字符串，在读取之前一般需使用hasNext（）与hasNextLine（）判断是否还有输入的数据。

  • next（）：
  1. 一定要读到有效字符后才可以结束输入。
  2. 对输入有效字符之前遇到的空白，next（）方法会将其去掉
  3. 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
  4. next（）不能得到带有空格的字符串。
  • next Line（）
  1. 以Enter为结束符，也就是说next Line（）方法返回的是输入回车之前所有字符。
  2. 可以获得空白。

流程控制

  • 顺序结构
  • 选择结构
  • 循环结构

顺序结构

程序按着顺序依次执行（从上到下，从左到右）

选择结构

if单选择结构、if双选择结构、if多选择结构、嵌套的if结构、switch多选择结构（不加break会有case穿透现象）

if(布尔表达式){
    //如果布尔表达式的值为true
}else{
    //如果布尔表达式的值为false
}

if(布尔表达式1){
    //如果布尔表达式1的值为true执行代码
}else if(布尔表达式 2){
    //如果布尔表达式2的值为true执行代码
}else if(布尔表达式 3){
    //如果布尔表达式3的值为true执行代码
}else{
    ////如果以上布尔表达式都不为true执行代码
}

switch(expression){
    case value:
        //语句
        break;//可选
    case value:
        //语句
        break;//可选
     //任意数量的case语句
    default://可选
        //语句
}

循环结构

while循环

while(布尔表达式){
    //循环内容
}
  • 只要布尔表达式为true，循环就会一直下去
  • 我们大多数情况是会让循环停止下来的，我们需要一个让表达式失效的方式来结束循环。
  • 少部分情况需要循环一直执行，比如服务器的请求响应和监听等
  • 循环条件一直为true就会造成无限循环（死循环），我们正常业务编程应避免死循环。会影响程序性能或者造成程序卡死崩溃！

do...while循环

do{
    //代码语句
}while(布尔表达式);
  • while先判断后执行，dowhile是先执行后判断！
  • do...while总是保证循环体至少执行一次！

for循环

for循环执行的次数是在执行前就确定的

for循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构。

for(初始化;布尔表达式;更新){
    //代码语句
}
100.for+回车自动生成循环（idea）

增强for循环

主要用于数组或集合的增强型for循环

for(声明语句:表达式)
{
    //代码句子
}

声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。

表达式：表达式是要访问的数组名，或者是返回值为数组的方法。

public class D08 {
    public static void main(String[] args) {
        int[] number={10,20,30,40,50};
        for(int x:number){
            System.out.print(x+"\t");
        }
    }
    /*for(int i=5;i<5;i++){
          sout(number[i]);
    }*/
}

break continue goto

break:在任何循环语句的主体部分，break用于强行退出循环，不执行循环中剩余的语句。

continue：用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定

（不用看破环了局部性原则）goto：仍是Java的保留字，但不用有goto的影子（带标签的break和continue）

标签是指后面跟一个冒号的标识符，例如：label：

对Java来说唯一用到标签的地方是在循环语句之前。而在循环之前设置标签的唯一理由是：我们希望在其中嵌套另一个循环，由于break和continue关键字通常指中断当前循环，但若随通标签使用，他们就会中断到存在标签的地方。

方法

类.对象.方法（）

System.out.println（）

方法：是语句的集合，他们在一起执行一个功能。本意是功能块，就是实现某个功能的语句块的集合。我们设计方法的时候，最好保持方法的原子性，就是一个方法只完成一个功能，这样有利于后期的扩展。 方法包含一个方法头和一个方法体

修饰符 返回值类型 方法名（参数类型 参数名）{
    ...
        方法体
    ...
    return 返回值；//return 0；表示终止方法
}

方法调用：对象名.方法名（实参列表）

java支持两种调用方法的方式，根据方法是否返回值来选择。

当方法返回一个值的时候，方法调用通常被当作一个值。

int larger =max(30,40);

如果方法返回值是void，方法调用一定是一条语句

System.out.println("Hello hahaha");

java是值传递（值传递和引用传递的区别）

重载

方法的重载：重载就是在一个类中，有相同的函数名称，但形参不同的参数。

重载的规则：

  1. 方法名称必须相同
  2. 参数列表必须不同（个数不同、或类型不同、参数排列顺序不同等）
  3. 方法的返回类型可以相同也可以不相同
  4. 仅仅返回类型不同不足以成为方法重载

实现理论：方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错。

重写：（Override）返回值类型和参数不变（在继承关系里面）

重载：（Overload）方法名相同，参数列表不同，返回值类型可以相同也可以不同 外壳（方法名，参数）发生了改变（在本类）

可变参数

在方法声明中，在指定参数类型后加一个省略号（...）

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

public static void main(String []args){
    printMax(34,3,3,2,56.5);
    printMax(new double[]{1,2,3});
    public static void printMax(double... numbers){
        ...
            方法体
        ...
    }
}

递归

递归：自己调用自己

思想：利用递归可以用简单的程序来解决一些复杂的问题。它通常把一个大型的复杂问题层层转化为一个与原问题相似的规模较小的问题求解，递归策略只需少量的程序就可以描述出解题过程所需要的多次重复计算，大大减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。

递归结构包括两个部分：

  • 递归头：什么时候不调用自身的方法。如果没有头，将陷入死循环
  • 递归体：什么时候需要调用自身方法

数组

  • 数组是相同类型数据的有序集合
  • 数组描述的是相同类型的若干数据，按照一定的先后次序排列组合而成
  • 其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问他们（从0开始）

首先必须声明数组变量，才能在程序中使用数组。

dataType[] arrayRefVar;//首选方法
或
dataType arrayRefVar[];//效果相同，但不是首选方法

java语言使用new操作符来创建数组

dataType[] arrayRefVar =new dataType[arraySize;]

数组的元素是通过索引访问的，数组索引从0开始

获取数组长度：

arrays.length

栈存放的地址指向堆存放的值

  • 静态初始化
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;
  • 数组的默认初始化

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

下标的合法区间：[0,length-1]

数组的四个基本特点：

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

小结：

  • 数组是相同的数据类型（数据类型可以为任意类型）的有序集合
  • 数组也是对象。数组元素相当于对象的成员变量
  • 数组长度确定的，不可变的。如果越界则报：ArrayIndexOutofBounds

多维数组

多维数组：可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。

数组元素以一个数组为单位

二维数组：

        int a[][]=new int [2][5];
    //可以看成一个二行五列的数组

public static void main(String[] args) {
int[][] arrays = {{1, 1}, {1, 5}, {5, 6}, {9, 9}};

for (int i = 0; i <= arrays.length - 1; i++) {
for (int j = 0; j <= arrays[i].length - 1; j++) {System.out.print(arrays[i][j] + "\t"); }}}

for (int[] array : arrays) {//打印输出二维数组
     for (int i : array) {
          System.out.print(i + "\t");
      }
}

稀疏数组

当一个数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数组来保存该数组

三元组：存储稀疏数组，行列值

Arrays类

数组工具类：Java.util.Arrays

数组对象本身没有什么方法可以供我们调用，但ＡＰＩ提供了一个工具类Ａｒｒａｙｓ供我们使用，从而可以对数据对象进行一些基本的操作

查看JDK帮助文档

Ａｒｒａｙｓ类中的方法都是ｓｔａｔｉｃ修饰的静态方法，在使用的时候可以直接使用类名进行调用，而不用使用对象来调用

（是“不用”而不是“不能”）

常用功能：

*　给数组赋值：通过ｆｉｌｌ方法
*　对数组排序：通过ｓｏｒｔ方法，按升序
*　比较数组：通过ｅｑｕａｌｓ方法比较数组中元素值是否相等
*　查找数组元素：通过ｂｉｎａｒｙＳｅａｒｃｈ方法能对排序好的数组进行二分查找法操作

面向对象

类：属性+方法

面向过程：

  • 步骤清晰简单，第一步做什么第二部做什么
  • 面向过程适合处理一些较为简单的问题

面向对象（思想）：oop

  • 物理类聚，分类的思维模式，思考问题首先会解决需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索
  • 面向对象适合处理复杂的问题，适合处理需要多人协作的问题

对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到围观操作，仍然需要面向过程的思路去处理。

本质：以类的方式组织代码，以对象的形式（封装）数据。

三大特性：封装、继承、多态

方法

  1. 方法的定义：
  • 修饰符
  • 返回类型
  • break：跳出switch，结束循环。return 结束，返回值
  • 方法名：注意规范（驼峰原则）、见名知意
  • 参数列表：（参数类型，参数名）（可变参数...）
  • 异常抛出
修饰符  返回值类型  方法名（...）{
    //方法体
    return 返回值；
}
  1. 方法的调用

  • 静态方法（static）通过类名.方法名调用

    （static创建的很早跟类一起创建的所以可以普通方法调用类方法，但是类方法不能调用普通方法）

  • 非静态方法（通过实例化对象调用）

    实例化：对象类型 对象名 =new 对象类型（）

    Student student =new Student();//实例化一个学生对象

  • 形参和实参（实参类型与形参类型要对应）

  • 值传递和引用传递

  • this关键字

类与对象关系

对象是具体的事物，类是抽象的。

类是对象的模板

使用new关键字创建对象

使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化，以及对类中构造器的调用

类中的构造器也称构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点：

  1. 必须和类名相同
  2. 必须没有返回类型，也不能写void
    作用：

  • 使用new关键字，本质是在调用构造器

  • 构造器用来初始化值

    注意：有参构造：一旦定义了有参构造，无参构造必须显式定义

Alt+insert（笔记本+Fn）：生成构造器

小结

  1. 类与对象：

    类是一个模板，抽象。对象是一个具体的实例。

  2. 方法：

    定义，调用

  3. 对象的引用：

    引用类型（除了基本类型都是引用类型），基本类型（8）

    对象是通过引用来操作的：栈-->堆

  4. 属性：字段Field 成员变量

    默认初始化： 数字：0 0.0

    ? char： u000

? boolean：false

? 引用：null

? 修饰符 属性类型 属性名 =属性值！

  1. 对象的创建和使用

    • 必须使用new 关键词创造对象，构造器

      Person fan=new Person（）；

    • 对象的属性 fan.name

    • 对象的方法 fan.sleep()

  2. 类：

    静态的属性 属性

    动态的行为 方法

? 封装、继承、多态

封装

该露的露，该藏得藏

高内聚，低耦合

高内聚： 类的内部数据操作细节自己完成，不允许外部干涉

低耦合：仅暴露少量的方法给外部使用

封装：（数据的隐藏）通常，因禁止直接访问一个对象中数据的实际表示，而因通过接口来访问，这称为信息隐藏。

作用：

  1. 提高程序的安全性，保护数据
  2. 隐藏代码的实现细节
  3. 统一接口
  4. 系统的可维护性增加

属性私有（private），get/set（提供了操作被private属性的方法）快捷键：Alt+insert（笔记本+Fn）

继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模

extend的意思是“扩展”。子类是父类的扩展。

Java中只有单继承，没有多继承

  • 继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。

  • 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extend来表示。

  • 子类和父类之间，从意义上讲应该具有“is a”的关系。

在Java中所有类都默认继承object类

this 与super

this指向本类的属性；super指向父类的属性

私有可以被继承但只能被本类访问。（不能被直接访问，可以被间接访问）

super（）；调用父类的构造器，必须要在子类构造器的第一行。

一般super（）；是被隐藏的（所以先调用父类构造器（方法）再调用子类构造器（方法））

this（）；也只能在第一行，所以super和this不能同时调用构造方法。

super注意点：

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

VS this：

  • 代表的对象不同：

  • this：本身调用这个对象

  • super：代表父类对象的引用

    前提：

    • this：没有继承也能用
    • super：只能在继承条件下才可以使用

? 构造方法：

  • this（）；本类的构造
  • super（）；父类的构造！

重写

重写都是方法的重写与属性无关

非静态才能重写

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

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

重写：子类的方法和父类必须一致，方法体不同

子类重写父类方法后，父类调用方法时执行子类的方法

因为父类的功能，子类不一定需要，或者不一定满足！所以要重写

多态

多态：父类的引用可以指向子类的实现（对象）

注解：有功能的注释

  • 及同一方法可以根据发送对象的不同而采用多种不同的行为方式
  • 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多

多态存在的条件：

  1. 有继承关系
  2. 子类重写父类方法
  3. 父类引用指向子类对象

注意 ：多态是方法的多态，属性没有多态性

instanceof（类型转换） 引用类型

注意事项：

  1. 多态是方法的多态，属性没有多态
  2. 父类和子类，有联系 。易出现的异常（ClassCastException）
  3. 存在条件：继承关系，方法需要重写，父类引用指向子类对象！ Father f1=new Son（）；

3种方法不能被继承：

  1. static 方法，属于类，它不属于实例
  2. final 常量
  3. private 方法

instanceof与类型转换

a instanceof A:判断对象a是否是类A的实例

（就是a与A有没有父子关系，若有则编译通过，若a是A的实例（儿子）则为true，否则为false）

类型转换高转低需要强制类型转换

Person obj =new Student();//高<-->低
((Student)obj).go();//go方法是子类的，父类想用go方法必须强制转换为子类才能使用（子类使用父类的方法由于继承的原因直接用）
Student student=(Student)obj;
student.go();
Person person =student;//子类型转父类型直接能转换，是因为子类内容包括父类且有父类不具有的内容，所以子变父系统可以砍去部分内容，而父转子，系统无法自己补全，所以需要强制转换

类型转换注意点：

  1. 父类引用指向子类的对象
  2. 把子类转换为父类，向上转型（直接转）
  3. 把父类转换为子类，向下转型：强制转换
  4. 方便方法的调用；减少重复的代码

static和final

static全程就运行一次，类变量，类方法，静态代码块，静态导入包

static跟类一起加载的

类方法可以通过类名.方法名（）调用

类方法的方法体中可以调用普通方法，但是普通方法不能调用类方法（加载的时间先后不一样）

加载次序：静态代码块（只加载一次） > 匿名代码块 > 构造方法

匿名代码块和构造方法每次实例化对象的时候都会加载

final修饰（是个修饰符）的类，不能被继承（断子绝孙修饰符），一般用来定义常量

抽象类

  • abstract修饰符可以用来修饰方法也可以用来修饰类，如果修饰方法，那么该方法就是抽象方法，如果修饰类，那么该类就是抽象类

  • 抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类

  • 抽象类，不能使用new关键字来创建对象，他是用来让子类继承的。

  • 抽象方法，只有方法的声明，没有方法的实现，他是用来让子类实现的

  • 子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类

    抽象类存在构造器，用于子类super调用，new子类会自动执行父类的构造

抽象类是为了不让你去直接new它的实例，比如animal类，犬科动物类，是没有具体实物的就是一个抽象。

接口

interface

  • 普通类：只有具体实现
  • 抽象类：集体实现和规范（抽象方法）都有！
  • 接口：只有规范！

接口就是规范，定义的是一组规则，体现了现实世界中“如果你是...则必须能...”的思想。如果你是天使，则必须能飞。如果你是汽车，则必须能跑。

接口的本质是契约，就像我们人间的法律一样，制定好后大家都遵守。

oop的精髓，是对对象的抽象，最能体现这一点的就是接口。

为什么我们讨论设计模式都只针对具备了抽象能力的语言（比如C++、java、C#等），就是因为设计模式所研究的，实际上就是如何合理的去抽象。

声明类的关键字是class，声明接口的关键字是interface

public interface UserServise{//接口的定义
    void add(String name);
    void delete(String name);
}

implements实现接口的关键字，接口可以实现伪多继承

public class UserServiceImpl implements UserService{//类可以实现接口 ，实现了接口的类，需要重写接口中的方法
    @Override
    public void add(String name){
        
    }
    @Override
    public void delete(String name){
        
    }
}

作用：

  1. 约束

  2. 定义一些方法，让不同的人实现

  3. public abstract 方法前面默认的修饰符

    void add (String name);//方法前面默认public abstract，可以带参数，也可以不带参数

  4. public static final 常量前面默认的修饰符

    int num=99;//前面默认public static final

  5. 接口不能被实例化，接口中没有构造方法

  6. implements 可以实现多个接口

  7. 必须要重写接口中的方法

实现接口的类后面一般都是以Impl结尾

内部类

类里面还可以在定义一个类，通过外部类来实例化内部类

Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
//实例内部类，必须通过外部类来实例

内部类可以获取外部类的私有属性，私有方法

静态内部类，内部类加一个static修饰符（跟类创建时一起创建）

一个Java类可以有多个class类，但是只能有一个public class

局部内部类，在方法里面创建的类

匿名内部类，没有名字初始化类，不用将实例保存到变量中

new Apple().eat();//Apple是一个类，直接new一个匿名内部类调用类里面的方法

异常/错误

  • 异常指程序运行中出现的不期而至的各种情况，如：文件找不到、网络连接失败、非法参数等。
  • 异常发生在程序运行期间，他影响了正常的程序执行流程

最高的异常throwable，其次Error与Exception并列

软件程序在运行过程中，非常可能遇到刚刚提到的这些异常问题，我们叫做异常，英文是：Exception，意思是例外。这些，例外情况，或者叫异常，怎么让我们写的程序作出合理的处理。而不至于程序崩溃。

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

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

Error和Exception的区别：Error通常是灾难性的致命的错误，是程序无法控制和处理的，当出现这些异常时，Java虚拟机（JVM）一般会选择终止线程；Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常

Array Index Out OfBounds Exception（数组下标越界）

Null Pointer Exception（空指针异常）

Arithmetic Exception（算术溢出）

MissingResourceException（丢失资源）

ClassNotFoundException（找不到类）等异常

这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理

这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生；

异常处理机制

  • 抛出异常
  • 捕获异常
  • 异常处理的五个关键字：try、catch 、finally、 throw、 throws

fianlly：

  • 非正常退出程序，断电等不会执行finally
  • 在执行finally中的代码前，程序已经退出了JVM。

这两种情况不执行finally，否则一般是正常执行的

try {//try监控区域
     System.out.println(a/b);
     } catch (Exception e) {//catch捕获异常
            System.out.println("异常！除数为0！");
        } finally {//finally处理善后工作
        }//可以不要finally，一般用于关闭流
//假如要捕获多个异常（多个catch）：异常范围要从小到大
//快捷键：Ctrl+Alt+t

throw：主动抛出异常，一般用于方法中

throws：假设方法中处理不了这个异常，方法上抛出异常

public void chufa(int a,int b)throws ArithmeticException {
        if(b==0){
            System.out.println(a/b);
 /* throw new ArithmeticException();*///throw,方法中使用
        }
    }

自定义异常

使用java内置的异常类可以描述在编程时出现的大部分异常。除此之外，用户还可以自定义异常。用户自定义异常，只需继承Exception类即可。

在程序中使用自定义异常类，大体可分为以下几个步骤：

  1. 创建自定义异常类
  2. 在方法中通过throw关键字抛出异常对象
  3. 如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作
  4. 在出现异常方法的调用者中捕获并处理异常

小结：

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

相关

日常学习（1）

日常学习（4）

标签