Object 类详解--代码化--单例设计模式 -- 抽象类--接口 --内部类--枚举--注解--异常

Object 类详解

equals

1. == 是一个比较运算符既可以判断基本类型，又可以判断引用类型
2. ==·判断的是值是否相等。示例: int i=10; double d=10.0:如果判断基本类型，
3. ==·如果判断引用类型，判断的是地址是否相等，即判定是不是同一个对象
4. equals: 是Object类中的方法，只能判断引用类型
5. 默认判断的是地址是否相等，子类中往往重写该方法，用于判断内容是否相等。比如IntegerString

hashCode

1. 提高具有哈希结构的容器的效率！
2. 两个引用，如果指向的是同一个对象，则哈希值肯定是一样的！
3. 两个引用，如果指向的是不同对象，则哈希值是不一样的
4. 哈希值主要根据地址号来的！， 不能完全将哈希值等价于地址。
5. 后面在集合，中 hashCode 如果需要的话，也会重写

toString

1. 默认返回：全类名+@+哈希值的十六进制，【查看 Object 的 toString 方法】
2. 子类往往重写 toString 方法，用于返回对象的属性信息
3.  重写 toString 方法，打印对象或拼接对象时，都会自动调用该对象的 toString 形式.当直接输出一个对象时，toString 方法会被默认的调用, 比如 System.out.println(monster)； 就会默认调用 monster.toString()

finaliz

1. 当对象被回收时，系统自动调用该对象的 finalize 方法。子类可以重写该方法，做一些释放资源的操作
2. 什么时候被回收：当某个对象没有任何引用时，则 jvm 就认为这个对象是一个垃圾对象，就会使用垃圾回收机制来 销毁该对象，在销毁该对象前，会先调用 finalize 方法。
3. 垃圾回收机制的调用，是由系统来决定(即有自己的 GC 算法), 也可以通过 System.gc() 主动触发垃圾回收机制，但是我们在实际开发中，几乎不会运用 finaliz

类方法使用注意事项和细节讨论

什么时候需要用类变量

当我们需要让某个类的所有对象都共享一个变量时，就可以考虑使用类变量（静态变量）：

1. 类变量与实例变量（普通属性）区别类变量是该类的所有对象共享的，而实例变量是每个对象独享的。
2. 加上static称为类变量或静态变量，否则称为实例变量/普通变量/非静态变量
3. 类变量可以通过类名.类变量名或者对象名.类变量名来访问，

但java设计者推荐我们使用类名.类变量名方式访问。【前提是满足访问修饰符的访问权限和范围】

1. 实例变量不能通过类名.类变量名方式访问。
2. 类变量是在类加载时就初始化了，也就是说，即使你没有创建对象，只要类加载了就可以使用类变量了
3. 类变量的生命周期是随类的加载开始，随着类消亡而销毁。

main()方法

1. 在 main()方法中，我们可以直接调用 main 方法所在类的静态方法或静态属性。
2. 但是，不能直接访问该类中的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静 态成员

代码化

基本介绍

  代码化块又称为初始化块，属于类中的成员［即是类的一部分］，类似于方法，将逻辑语句封装在方法体中，通过｛｝包围起来。

但和方法不同，没有方法名，没有返回，没有参数，只有方法体，而且不用通过对象或类显式调用，而是加载类时，或创建对象时隐式调用。

［修饰符］｛
代码

｝;

说明注意：
1）修饰符可选，要写的话，也只能写static
2）代码块分为两类，使用static修饰的叫静态代码块，没有static修饰的，叫普通代码块/非静态代码块

3）逻辑语句可以为任何逻辑语句（输入输出、方法调用、循环、判断等）
4）；号可以写上，也可以省略。

自我理解：

1. 相当于另外一种形式的构造器（对构造器的补充机制），可以做初始化的操作
2. 如果多个构造器中都有重复的语句，可以抽取到初始化块中，提高代码的重用性

代码块使用注意事项和细节讨论

 
1）static代码块也叫静态代码块，作用就是对类进行初始化，而且它随着类的加载而执行，并且只会执行一次。如果是普通代码块，每创建一个对象，就执行。
2）类什么时候被加载［重要背！］
    2.1.创建对象实例时（new）
    2.2.创建子类对象实例，父类也会被加载
    2.3.使用类的静态成员时（静态属性，静态方法）
3）普通的代码块，在创建对象实例时，会被隐式的调用。被创建一次，就会调用一次。
如果只是使用类的静态成员时，普通代码块并不会执行。
小结：

1. static代码块是类加载时，执行，只会执行一次

2. 普通代码块是在创建对象时调用的，创建一次，调用一次
3. 类加载的3种情况，

                3.1、命令行启动应用时候由JVM初始化加载

                3.2、通过Class.forName ()方法动态加载

                3.3、通过ClassLoader.loadClass ()方法动态加载

4）创建一个对象时，在一个类调用顺序是：（重点，难点）：

        4.1调用静态代码块和静态属性初始化（注意：静态代码块和静态属性初始化调用的优先级一样，如果有多个静态代码块和多个静态变量初始化，则按他们定义的顺序调用）

        4.2调用普通代码块和普通属性的初始化（注意：普通代码块和普通属性初始化调用的优先级一样，如s果有多个普通代码块和多个普通属性初始化，则按定义顺序调用）

        4.3调用构造方法

单例设计模式

所谓类的单例设计模式，   就是采取一定的方法保证在整个的软件系统中，对某个类只能存   在一个对象实例，并且该类只提供一个取得其对象实例的方法

单例模式有两种方式：

2.1饿汉式

2.2懒汉式
单例模式应用实例
演示饿汉式和懒汉式单例模式的实现：
     1）构造器私有化=》防止直接 new
     2）类的内部创建对象
     3）向外暴露一个静态的公共方法。Getinstance

饿汉式VS懒汉式

1.   二者最主要的区别在于创建对象的时机不同：饿汉式是在类加载就创建了对象实例而懒汉式是在使用时才创建
2 .饿汉式不存在线程安全问题，懒汉式存在线程安全问题。（后面学习线程后，会完善）
3.  饿汉式存在浪费资源的可能。因为如果程序员一个对象实例都没有使用，那么饿汉式创建的对象就浪费了，懒汉式是使用时才创建，就不存在这个问题
4、在我们javaSE标准类中，java.lang.Runtime就是经典的单例模式。

 final关键字

基本介绍
final中文意思：最后的，最终的.
final可以修饰类、属性、方法和局部变量.
在某些情况下，程序员可能有以下需求，就会使用到final:
      1）当不希望类被继承时，可以用final修饰.
  2）当不希望父类的某个方法被子类覆盖/重写（override）时，可以用final关键字
修饰。
      3）当不希望类的的某个属性的值被修改，可以用final修饰

4）当不希望某个局部变量被修改，可以使用final修饰

final使用注意事项和细节讨论

1）final修饰的属性又叫常量，一般用XX XX XX来命名
2）final修饰的属性在定义时，必须赋初值，并且以后不能再修改，赋值可以在如下位置之一【选择一个位置赋初值即可】：
      2.1定义时：如 public final double TAX RATE=0.08；
      2.1在构造器中
      2.1在代码块中。
3）如果final修饰的属性是静态的，则初始化的位置只能是
      3.1定义时

     3.2在静态代码块不能在构造器中赋值。
4）final类不能继承，但是可以实例化对象。
5）如果类不是final类，但是含有final方法，则该方法虽然不能重写，但是可以被继承。

6）一般来说，如果一个类已经是final类了，就没有必要再将方法修饰成final方法。

7）    final不能修饰构造方法（即构造器）

8 ） （Integer，Double，Float， Boolean等都是final），String也是final类
9 ）  final和 static往往搭配使用，效率更高，不会导致类加载.底层编译器做了优化处理

 class Demo｛
      public static final int i=16；//
      static｛
          System.out.println（＂132465“）
      ｝

抽象类

抽象类的介绍

抽象类使用的注意事项

1)   抽象类不能被实例化

2）抽象类不一定要包含abstract方法。也就是说，抽象类可以没有abstract方法

3）一旦类包含了abstract方法，则这个类必须声明为abstract
4） abstract 只能修饰类和方法，不能修饰属性和其它的
5）抽象类使用的注意事项和细节讨论       抽象类可以有任意成员【抽象类本质还是类】，比如：非抽象方法、构造器、静态属性等等
7）如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类。
6）抽象方法不能有主体，即不能实现.如图所示

抽象类--模板设计模式

基本介绍

抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为方式。

模板设计模式能解决的问题

1. 当功能内部一部分实现是确定，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现
2. 编写一个抽象父类，父类提供了多个子类的通用方法，并把一个或多个方法留给其子类实现，就是一种模板模式

接口

基本介绍

注意事项和细节

1. 接口不能被实例化
2. 接口中所有的方法是public方法，接口中抽象方法，可以不用abstract修饰图示：

3）一个普通类实现接口，就必须将该接口的所有方法都实现。
4）抽象类实现接口，可以不用实现接口的方法。
5）一个类同时可以实现多个接口
6）接口中的属性，只能是final的，而且是 public static final 修饰符。比如：int a=1；实际上是 public static final int a=1；（必须初始化）
7）接口中属性的访问形式：接口名.属性名
8）接口不能继承其它的类，但是可以继承多个别的接口［举例］
      interface A extends B，C｛｝
9）接口的修饰符只能是public和默认，这点和类的修饰符是一样的。

实现接口 vs 继承类

        当子类继承了父类，就自动的拥有父类的功能 // 如果子类需要扩展功能，可以通过实现接口的方式扩展. // 可以理解 实现接口 是 对 java 单继承机制的一种补充

接口和继承解决的问题不同

1.继承的价值主要在于：解决代码的复用性和可维护性。
2.接口的价值主要在于：设计，设计好各种规范（方法），让其它类去实现这些方法。即更加的灵活
3.>接口比继承更加灵活
4.接口比继承更加灵活，继承是满足is-a的关系，而接口只需满足like-a的关系。接口在一定程度上实现代码解耦［即：接口规范性+动态绑定机制］

接口的多态特性

1. 多态参数
   在前面的Usb接口案例，UsbInterface usb，既可以接收手机对象，又可以接收相机对象，就体现了接口多态（接口引用可以指向实现了接口的类的对象）
2. 多态数组
   演示一个案例：给Usb数组中，存放Phone和相机对象，Phone类还有一个特有的方法call（），请遍历Usb数组，如果是Phone对象，除了调用Usb接口定义的方法外，还需要调用Phone特有方法call.
   
    
3. 接口存在多态传递现象.

内部类

如果定义类在局部位置(方法中/代码块) :    (1)局部内部类 (2) 匿名内部类

定义在成员位置 (1) 成员内部类 (2) 静态内部类

基本介绍

1. 一个类的内部又完整的嵌套了另一个类结构。被嵌套的类称为内部类（inner class），嵌套其他类的类称为外部类（outer class）。是我们类的第五大成员
2. 【思考：类的五大成员是哪些？［属性、方法、构造器、代码块、内部类］】，
3. 内部类最大的特点就是可以直接访问私有属性，并且可以体现类与类之间的包含关系，
4. 注意：内部类是学习的难点，同时也是重点，后面看底层源码时，有大量的内部类

基本语法

内部类的分类

定义在外部类局部位置上（比如方法内）
1）局部内部类（有类名）
2）匿名内部类（没有类名，重点！！！！）

>定义在外部类的成员位置上：

1）成员内部类（没用static修饰）
2）静态内部类（使用static修饰）
局部内部类的使用
说明：局部内部类是定义在外部类的局部位置，比如方法中，并且有类名

1. 可以直接访问外部类的所有成员，包含私有的
2. 不能添加访问修饰符，因为它的地位就是一个局部变量。局部变量是不能使用修饰符的。但是可以使用final修饰，因为局部变量也可以使用final
3. 作用域：仅仅在定义它的方法或代码块中。
4. 局部内部类－-访问－-->外部类的成员［访问方式：直接访问］
5. 外部类－-访问－-->局部内部类的成员

访问方式：创建对象，再访问（注意：必须在作用域内）
记住：（1）局部内部类定义在方法中/代码块
      （2）作用域在方法体或者代码块中
      （3）本质仍然是一个类

6.  外部其他类－-不能访问－--->局部内部类（因为局部内部类地位是一个局部变量）

7.  如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，则可以使用（外部类名.this.成员）去访问【演示】
                                       System.out.printIn（＂外部类的n2=＂ +外部类名.this.n2）；

匿名内部类的使用(重要!!!!!!!)

（1）本质是类

（2）内部类

（3）该类没有名字

（4）同时还是一个对象

说明：匿名内部类是定义在外部类的局部位置，比如方法中，并且没有类名
匿名内部类的基本语法

1. 匿名内部类的语法比较奇特，请大家注意，因为匿名内部类既是一个类的定义同时它本身也是一个对象，因此从语法上看，它既有定义类的特征，也有创建对象的特证，对前面代码分析可以看出这个特点，因此可以调用匿名内部类方法。
2. 可以直接访问外部类的所有成员，包含私有的
3. 不能添加访问修饰符，因为它的地位就是一个局部变量
4. 作用域：仅仅在定义它的方法或代码块中。
5. 匿名内部类－-访问－->外部类成员［访问方式：直接访问］
6. 外部其他类－-不能访问－-->匿名内部类（因为匿名内部类地位是一个局部变量）
7. 如果外部类和匿名内部类的成员重名时，匿名内部类访问的话，默认遵循就近原则如果想访问外部类的成员，则可以使用（外部类名.this.成员）去访问

成员内部类的使用

说明：成员内部类是定义在外部类的成员位置，并且没有static修饰。

1.可以直接访问外部类的所有成员，包含私有的

2.可以添加任意访问修饰符（public、protected、默认、private）因为它的地位就是一个成员。
3.作用域和外部类的其他成员一样，为整个类体比如前面，在外部类的成员方法中创建成员内部类对象，再调用方法
4.成员内部类－-访问－->外部类成员（比如：属性）［访问方式：直接访问］
5.外部类－-访问－-->成员内部类（说明）访问方式：创建对象，再访问
6.外部其他类－-访问－->成员内部类
7.如果外部类和内部类的成员重名时，内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，则可以使用（外部类名.this.成员）去访问

静态内部类的使用

说明：静态内部类是定义在外部类的成员位置，并且有static修饰

1. 可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员
2. 可以添加任意访问修饰符（public、protected、默认、private）因为它的地位就是一个成员。
3. 作用域：同其他的成员，为整个类体
4. 静态内部类－访问－->外部类（比如：静态属性）［访问方式：直接访问所有静态成员
5. 外部类－-访问－->静态内部类访问方式：创建对象，再访问
6. 外部其他类－-访问－-->静态内部类
7. 如果外部类和静态内部类的成员重名时，静态内部类访问的时，默认遵循就近原则，如果想访问外部类的成员，则可以使用（外部类名.成员）去访问

枚举的二种实现方式

自定义类实现枚举

1. 不需要提供setXxx方法，因为枚举对象值通常为只读
2. 对枚举对象/属性使用 final + static共同修饰，实现底层优化
3. 枚举对象名通常使用全部大写，常量的命名规范
4. 枚举对象根据需要，也可以有多个属性

小结：进行自定义类实现枚举，有如下特点：

1. 构造器私有化
2. 对外暴露对象（通过为对象添加 public final static 修饰符）

4) 可以提供 get 方法，但是不要提供 set

使用 enum 关键字实现枚举注意事项

1)当我们使用enum关键字开发一个枚举类时 默认会继承 Enum 类, 而且是一个 final 类

2) 传统的 public static final Season2 SPRING = new Season2("春天", "温暖");

简化成 SPRING("春天", "温暖")， 这里必 须知道，它调用的是哪个构造器.

3) 如果使用无参构造器 创建 枚举对象，则实参列表和小括号都可以省略

4）当有多个枚举对象时，使用,间隔，最后有一个分号结尾

5) 枚举对象必须放在枚举类的行首.

enum 用方法说明

1) toString:Enum 类已经重写过了，返回的是当前对象名,子类可以重写该方法，用于返回对象的属性信息

2) name：返回当前对象名（常量名），子类中不能重写

3) ordinal：返回当前对象的位置号，默认从 0 开始

4) values：返回当前枚举类中所有的常量

5) valueOf：将字符串转换成枚举对象，要求字符串必须 为已有的常量名，否则报异常！

6) compareTo：比较两个枚举常量，比较的就是编号！

enum 实现接口

1. 使用 enum 关键字后，就不能再继承其它类了，因为 enum 会隐式继承 Enum，而 Java 是单继承机制。
2. 枚举类和普通类一样，可以实现接口，如下形式。 enum 类名implements 接口 1，接口 2{}

注解的理解

1. 注解(Annotation)也被称为元数据(Metadata)，用于修饰解释 包、类、方法、属性、构造器、局部变量等数据信息。
2. 和注释一样，注解不影响程序逻辑，但注解可以被编译或运行，相当于嵌入在代码中的补充信息。
3. 在 JavaSE 中，注解的使用目的比较简单，例如标记过时的功能，忽略警告等。在 JavaEE 中注解占据了更重要的角色，

例如用来配置应用程序的任何切面，代替 java EE 旧版中所遗留的繁冗代码和 XML 配置等

基本的 Annotation 介绍

使用 Annotation 时要在其前面增加 @ 符号, 并把该 Annotation 当成一个修饰符使用。用于修饰它支持的程序元 素 三个基本的 Annotation:

1.  @Override: 限定某个方法，是重写父类方法, 该注解只能用于方法
2.  @Deprecated: 用于表示某个程序元素(类, 方法等)已过时
3.  @SuppressWarnings: 抑制编译器警告

@Override 注解

@Override 使用说明

1.＠Override表示指定重写父类的方法（从编译层面验证）如果父类没有fly方法，则会报错

2.如果不写＠Override注解，而父类仍有 public void fly（）｛｝，仍然构成重写

3.＠Override只能修饰方法，不能修饰其它类，包，属性等等

4.查看＠Override注解源码为＠Target（ElementType.METHOD），说明只能修饰方法

5.＠Targe是修饰注解的注解，称为元注解，

@Deprecated 注解

1. 用于表示某个程序元素（类，方法等）已过时
    
2. 可以修饰方法，类，字段，包，参数等等
    
3. @Target(value={CONSTRUCTOR, FIELD, LOCAL VARIABLE, METHOD,PACKAGE, PARAMETER, TYPE})
    
4. @Deprecated的作用可以做到新旧版本的兼容和过渡

@SuppressWarnings 注解

1. 当我们不希望看到这些警告的时候，可以使用 SuppressWarnings 注解来抑制警告信息
2. 在{""} 中，可以写入你希望抑制(不显示)警告信息
3. 可以指定的警告类型有

1. all，抑制所有警告
2. boxing，抑制与封装/拆装作业相关的警告
3. cast，抑制与强制转型作业相关的警告
4. dep-ann，抑制与淘汰注释相关的警告
5. deprecation，抑制与淘汰的相关警告
6. fallthrough，抑制与 switch 陈述式中遗漏 break 相关的警告
7. finally，抑制与未传回 finally 区块相关的警告
8. hiding，抑制与隐藏变数的区域变数相关的警告
9. incomplete-switch，抑制与 switch 陈述式(enum case)中遗漏项目相关的警告
10. javadoc，抑制与 javadoc 相关的警
11. nls，抑制与非 nls 字串文字相关的警告
12. null，抑制与空值分析相关的警告
13. rawtypes，抑制与使用 raw 类型相关的警告（传参时没有指定泛型错误警告）
14. resource，抑制与使用 Closeable 类型的资源相关的警告
15. restriction，抑制与使用不建议或禁止参照相关的警告
16. serial，抑制与可序列化的类别遗漏 serialVersionUID 栏位相关的警告
17. static-access，抑制与静态存取不正确相关的警告
18. static-method，抑制与可能宣告为 static 的方法相关的警告
19. super，抑制与置换方法相关但不含 super 呼叫的警告
20. synthetic-access，抑制与内部类别的存取未最佳化相关的警告
21. sync-override，抑制因为置换同步方法而遗漏同步化的警告
22. unchecked，抑制与未检查的作业相关的警告
23. unqualified-field-access，抑制与栏位存取不合格相关的警告
24. unused，抑制与未用的程式码及停用的程式码相关的警告

关于 SuppressWarnings 作用范围是和你放置的位置相关

比如 @SuppressWarnings 放置在 main 方法，那么抑制警告的范围就是 main 通常我们可以放置具体的语句, 方法, 类.

看看 @SuppressWarnings 源码 修饰的程序元素为，查看＠Target放置的位置就是

TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE

生成＠SupperssWarnings时，不用背，直接点击左侧的黄色提示，就可以选择（注意可以指定生成的位置）

元注解

JDK 的元 Annotation 用于修饰其他 Annotat

元注解的种类

1. Retention //指定注解的作用范围，三种 SOURCE,CLASS,RUNTIME
2. Target // 指定注解可以在哪些地方使用
3. Documented //指定该注解是否会在 javadoc 体现
4. Inherited //子类会继承父类注解

@Retention 注解

1)  RetentionPolicy.SOURCE: 编译器使用后，直接丢弃这种策略的注释

2)  RetentionPolicy.CLASS: 编译器将把注解记录在 class 文件中. 当运行 Java 程序时, JVM 不会保留注解。 这是默认 值

3)  RetentionPolicy.RUNTIME:编译器将把注解记录在 class 文件中. 当运行 Java 程序时, JVM 会保留注解. 程序可以 通过反射获取该注解

@Target  注解

用于修饰 Annotation 定义，用于指定被修饰的 Annotation能用于修饰哪些程序元素.＠Target也包含一个名为 value的成员变量。

@Documented注解

基本说明

＠Documented:用于指定被该元 Annotation修饰的 Annotation类将被javadoc 工具提取成文档，即在生成文档时，可以看到该注解。

说明：定义为Documented的注解必须设置Retention值为RUNTIME

@Inherited 注解

被它修饰的Annotation 将具有继承性.如果某个类使用了被＠Inherited修饰的Annotation，则其子类将自动具有该注解

说明：实际应用中，使用较少，了解即可

元注解：本身作用不大，看源码时，可以知道他是干什么

异常-Exception

基本概念

Java语言中，将程序执行中发生的不正常情况称为“异常”。（开发过程中的语法错误和逻辑错误不是异常）
执行过程中所发生的异常事件可分为两大类

1）Error（错误）：Java虚拟机无法解决的严重问题。如：JVM系统内部错误、资源耗尽等严重情况。比如：StackOverflowError［栈溢出］和OOM（out ofmemory），Error是严重错误，程序会崩溃。

2）Exception:其它因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理。例如空指针访问，试图读取不存在的文件，网络连接中断等等，Exception分为两大类：运行时异常［程序运行时，发生的异常］和编译时异常［编程时，编译器检查出的异常］。

异常体系图

异常体系图的小结

1.异常分为两大类，运行时异常和编译时异常.

2.运行时异常，编译器检查不出来。一般是指编程时的逻辑错误，是程序员应该避免其出现的异常。java.lang.RuntimeException类及它的子类都是运行时异常

3.对于运行时异常，可以不作处理，因为这类异常很普遍，若全处理可能会对程序的可读性和运行效率产生影响

4.编译时异常，是编译器要求必须处置的异常。

常见的运行时异常包括

1)  NullPointerException 空指针异常

2)  ArithmeticException 数学运算异常

3)  ArrayIndexOutOfBoundsException 数组下标越界异常

4 )  ClassCastException 类型转换异常

5)  NumberFormatException 数字格式不正确异常[]

编译异常

介绍

编译异常是指在编译期间，就必须处理的异常，否则代码不能通过编译

常见的编译异常

√  SQLException//操作数据库时，查询表可能发生异常

√  IOException/操作文件时，发生的异常

√  FileNotFoundException/当操作一个不存在的文件时，发生异常

√  ClassNotFoundException/加载类，而该类不存在时，异常

√  EOFException/操作文件，到文件末尾，发生异常
√  IllegalArguementException/参数异常

异常处理

异常处理就是当异常发生时，对异常处理的方式。

异常处理的方式

        try-catch-finally

程序员在代码中捕获发生的异常，自行处理

        throws

将发生的异常抛出，交给调用者（方法）来处理，最顶级的处理者就是JVM

示意图

try-catch 方式处理异常说明

1）Java提供try和catch块来处理异常。try块用于包含可能出错的代码。catch块用于处理try块中发生的异常。可以根据需要在程序中有多个try.catch块。

try-catch 方式处理异常-注意事项

1）如果异常发生了，则异常发生后面的代码不会执行，直接进入到catch块

2）如果异常没有发生，则顺序执行try的代码块，不会进入到catch.

3）如果希望不管是否发生异常，都执行某段代码（比如关闭连接，释放资源等）则使用如下代码－finally｛｝

4）可以有多个catch语句，捕获不同的异常（进行不同的业务处理），要求父类异常在后，子类异常在前，比如（Exception在后，NullPointerException在前），如果发生异常，只会匹配一个catch，

5）可以进行try-finally配合使用，这种用法相当于没有捕获异常，因此程序会直接崩掉/退出。应用场景，就是执行一段代码，不管是否发生异常，都必须执行某个业务逻辑

小结

1）如果没有出现异常，则执行try块中所有语句，不执行catch块中语句，如果有finally，最后还需要执行finally里面的语句

2）如果出现异常，则try块中异常发生后，try块剩下的语句不再执行。将执行catch块中的语句，如果有finally，最后还需要执行finally里面的语句！

---

本章笔记是观看韩顺平的JAVA的视频和在网上找的资料 以及自己的理解总结出来的笔记希望可以帮助大家，感谢大家的耐心观看 如有错误请即使联系我 我会及时修正

---