Java小知识点_java中t1.a-CSDN博客

–Java EE — 企业版(Enterprise)。J2EE 包含J2SE 中的类，并且还包含用于开发企业级应用的类 ,如EJB、servlet、JSP、事务控制。为企业级应用提供了标准平台，简化复杂的企业级编程。–Java ME — 微缩版(Micro)。包含J2SE中一部分类，用于嵌入式系统开发。专门针对一些小型的消费电子产品，如：手机、PDA、机顶盒

2.Java语言的特点

2.1跨平台

Java编译器将Java源程序编译成一种与体系结构无关的中间文件格式。只要有Java运行系统的机器都能执行这种中间代码。从而使同一版本的应用程序可以运行在不同的平台上。

2.2半编译半解释

源程序先编译成字节码，Java解释器(运行系统)能直接对Java字节码进行解释执行。链接程序通常比编译程序所需资源少

2.3面向对象：万物皆对象

2.4健壮

–Java提供了自动垃圾收集机制来进行内存管理，并检测程序对内存的访问，确定合法并不会引起任何问题后，才允许访问。

–Java还提供了异常处理机制用来检查编译及运行时可能出现的问题，帮助程序员消除错误，防止系统崩溃

2.5分布式

Java包括一个支持HTTP和FTP等基于TCP/IP协议的子库。因此，Java应用程序可凭借URL打开并访问网络上的对象，就像访问本地文件一样简单方便。Java的分布性为实现在分布环境尤其是Internet下实现动态内容提供了技术途径。

2.6安全

Java语言执行前它经过代码校验，检查代码段的格式，检测指针等操作。另外，Java拥有多个层次的互锁保护措施，能有效地防止病毒的入侵和破坏行为的发生。

2.7多线程

即同时进行不同的操作或处理不同的事件，好处是具有更好的网上交互性能和实时控制性能，尤其是实现多媒体功能。

3.JRE (Java Runtime Environment）

运行JAVA程序所必须的环境的集合

JRE的内部有一个JAVA虚拟机（Java Virtual Machine，JVM）以及一些标准的类库（Class Library）

4.JDK(Java Development Kit)

java 开发工具包。即java语言编写的程序所需的开发工具包。JDK 包含了 JRE，同时还包括 java 源码的编译器 javac、监控工具 jconsole、分析工具 jvisualvm等。

5.JVM (Java Virtual Machine)

5.1特点

一个虚构出来的计算机

通过在实际的计算机上仿真模拟各种计算机功能来实现的。

Java虚拟机有自己完善的硬件架构,如处理器、堆栈、寄存器等,还具有相应的指令系统。

5.2生命周期

启动

当一个程序启动，jvm启动，当这个程序关闭退出，这个jvm实例就随之消亡。每个程序都有一个与之对应的jvm实例供其运行。任何一个拥有公开的（public）、静态的（static）、没有返回值（void）并且接受一个字符串数组参数（String[] args）的main()函数的class都可以作为JVM实例运行的起点

运行
main()作为该程序初始线程的起点，任何其他线程均由该线程启动。JVM内部有两种线程：守护线程和非守护线程，java程序的初始线程只就是运行main（）的线程，这个线程是非守护线程，只要还有任何非守护线程还在运行，那么jvm就存活着。

消亡

当程序中的所有非守护线程都终止时，JVM才退出。

6.数组

6.1基本

数组可以看成是多个相同类型数据的组合，实现对这些数据的统一管理。

数组中的元素可以是任何数据类型，包括基本数据类型和引用类型。

6.2特点

–数组是存储多个相同类型变量的对象。数组的所有元素保存在堆内存中。

–创建一个数组就是在堆中创建一个数组对象。

–数组创建后立即拥有默认值。(引用类null)

-属于连续分配

7. 8种基本数据类型的运算

byte,char,short<int<long<floar<double

另外还有个 boolean

当容量小（数的范围小）的数据类型的变量与容量打的数据类型的变量做运算时，结果自动提升为容量大的数据类型。

当byte,char,short 三种变量做运算时结果为int类型

        int a = 1;
//        short b = a+1;//报错不兼容的类型: 从int转换到short可能会有损失”
        short c = 1;
        c += 1; //正常运行
        System.out.println(c);

基本数据类型：数据直接存储在栈上
引用数据类型区别：数据存储在堆上，栈上只存储引用地址

8.Utf-8，Unicode和ASCII 编码

在计算机的世界里，信息的表示方式只有 0 和 1

编码：把图像，文字等以二进制的形式储存在计算机中

一个byte（字节）=8个二进制位

ASCII码：2的8次方前面第一位为0 所以有128

其他国家为自己的非英文数字字符赋值把前面的第一位也用了，所以有256

Unicode：为了统一所有国家的编码一致本身是16进制「字符集」

它是一种规定，Unicode本身只规定了每个字符的数字编号是多少，并没有规定这个编号如何存储

UTF-8只是Unicode一种实现方式，以 8 位为一个编码单位的可变长编码。「编码规则」

9.运算符

逻辑运算符

&：左边为false，继续执行右边的

        short a = 2;
        short b = 2;
         if (a==1 & (b++)>2){
             //并未输出
             System.out.println(a);
         }
         //3
        System.out.println(b);

三元表达式

     b= (a>b)? 3:4;

优先级

10.内部类

理解

一个事物的内部，还需要一个完整的结构进行描述，而这个结构只为这个类提供服务

分类

成员内部类

非静态成员内部类：
- 非静态成员内部类属于外部类的实例，只能通过外部类的实例来访问。
- 可以访问外部类的所有成员，包括私有成员。
- 不能定义静态成员（静态字段或方法），因为非静态成员内部类本身是与外部类的实例相关联的。
静态成员内部类：
- 静态成员内部类是一个静态类，不依赖于外部类的实例。
- 可以直接通过类名访问，无需外部类的实例。
- 可以包含静态成员和实例成员，但不能访问外部类的非静态成员。

局部内部类

方法内部类：
- 方法内部类定义在方法内部，只能在该方法内部访问。
- 可以访问方法内的局部变量，但必须声明为final或是事实上的final（Java 8之后）。
代码块内部类：
- 代码块内部类定义在一个代码块内部，比如一个方法的代码块或者一个普通代码块。
- 作用域仅限于该代码块内部。
构造器内部类：
- 构造器内部类定义在构造器内部，用于实现构造器的一些特殊需求。
- 构造器内部类可以访问外部类的成员，但不能定义静态成员。

public class OuterClass {
    private int outerField = 10;

    // 非静态成员内部类
    class InnerClass {
        public void display() {
            System.out.println("Outer field: " + outerField);
        }
    }

    // 静态成员内部类
    static class StaticInnerClass {
        public void display() {
            System.out.println("Static inner class");
        }
    }

    public void outerMethod() {
        int localVar = 20;

        // 方法内部类
        class MethodInnerClass {
            public void display() {
                System.out.println("Local variable: " + localVar);
            }
        }

        MethodInnerClass methodInner = new MethodInnerClass();
        methodInner.display();
    }

    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        InnerClass inner = outer.new InnerClass();
        inner.display();

        StaticInnerClass staticInner = new StaticInnerClass();
        staticInner.display();

        outer.outerMethod();
    }
}

11.抽象类和接口

抽象类（Abstract Class）

定义：
- 抽象类是一种类，可以包含抽象方法（没有实现的方法）和具体方法（有实现的方法）。
- 抽象类可以包含成员变量、构造方法、普通方法等。
- 使用关键字abstract来定义抽象类，无法实例化抽象类，只能被继承。
继承：
- 子类继承抽象类时，必须实现抽象类中的所有抽象方法，除非子类也声明为抽象类。
- 子类只能继承一个抽象类，Java不支持多重继承。
用途：
- 抽象类适合用于定义一些通用的行为和属性，具有某种共性的类可以使用抽象类来实现。

接口（Interface）

定义：
- 接口是一种完全抽象的类型，只包含常量和抽象方法的定义，没有成员变量和具体方法。
- 接口使用关键字interface来定义，类似于抽象类，但不包含任何实现。
实现：
- 类通过implements关键字来实现接口，一个类可以实现多个接口。
- 实现接口时，类必须实现接口中定义的所有方法。
用途：
- 接口用于定义类应该具有的行为，而不关心具体实现。它提供了一种规范，使得不同类可以实现相同的接口，从而实现多态性。

区别总结

实现：
- 抽象类可以包含成员变量、构造方法和普通方法，而接口只能包含常量和抽象方法。
- 一个类只能继承一个抽象类，但可以实现多个接口。
用途：
- 抽象类用于表示一种"is-a"关系，即子类是父类的一种特殊类型。
- 接口用于表示一种"has-a"关系，即类具有某种行为。
设计：
- 使用抽象类时，要考虑类之间的继承关系，抽象类适合用于共享一些通用的行为。
- 使用接口时，要考虑类之间的功能关系，接口适合用于定义类应该具有的行为。

12.基础

12.1 基本

1.除了八大基本数据类型，剩下的全是引用数据类型 byte short int float long double char boolean

2.如果在创建类的时候没有声明要继承的类那么java就默认把它继承Object类

3.break 之后会跳出当前循环

4.String实现Comparable接口表示可以比较大小

实现Serialable接口表示支持序列化

5.finalize：Object 中的方法，在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。（java9已经过时）

6.并发是轮流处理多个任务，并行是同时处理多个任务

12.2命名规范（数字不可以开头）

包名：所有字母小写

类名：首字母大写

常量名：所有字母大写多单词组成用_连接

12.3变量

概念：内存的一个储存区域，该区域的数据在同一类型范围内不断变化，是程序的基本的储存单元，包含变量类型，变量名和储存的值。

作用:用于内存中保存数据

12.4 == 和 equals 的区别

==：运算符，用于比较基础类型变量和引用类型变量。
对于基础类型变量，比较的变量保存的值是否相同，类型不一定要相同。
对于引用类型变量，比较的是两个对象的地址是否相同。
equals：Object 类中定义的方法，通常用于比较两个对象的值是否相等。需要进行重写

12.5向上转型和向下转型

1.向上转型
Person p = new Student()
p中不能调用子类特有的方法
2.向下转型
即父类的对象强转成子类对象
只有当这个对象原本就是子类对象通过向上转型得到的时候才能够成功转型
Student stu = (Student )p
可以直接调用子类所特有的

12.6Java 静态变量和成员变量的区别。

1.成员变量存在于堆内存中。静态变量存在于方法区中。
2.成员变量与对象共存亡，随着对象创建而存在，随着对象被回收而释放。

静态变量与类共存亡，随着类的加载而存在，随着类的消失而消失。

3.成员变量所属于对象，所以也称为实例变量。

静态变量所属于类，所以也称为类变量。

4.成员变量只能被对象所调用。静态变量可以被对象调用，也可以被类名调用。

13.关键字

13.1this

可以理解为当前对象或者正在创建的对象

使用：

1.在类的方法和构造器中this.属性或this.方法指的是当前对象的属性和方法

2.在类的构造器中可以用this(形参列表)方式调用本类中指定的其他构造器（不能调用自己，必须声明在构造器的首行，构造器内部只能有一个this(形参列表)）

13.2super

使用

1.在子类的方法中 super.属性（方法）显式调用父类中的方法（属性）（通常省略，和子类同名时不可省略）

2.可以在子类构造器中使用super（形参列表）的方式调用父类的构造器（必须声明在构造器的首行，构造器内部只能有一个this(形参列表)或super（形参列表））如果没有显式声明，则默认调用的是父类中空参的构造器

13.3package

特点

1.更好的实现项目类的管理

2.每”.“一次代表一层目录

3.同一包下不能命名同名的接口或类（不同的包下可以）

13.4static

可以修饰方法，属性，代码块（只能修饰类成员，不能修饰局部变量）

静态变量：所有对象共享，在类加载时就被创建，可以直接用类.变量调用

public class T10010 {
	static int A =10;
	
		public static void main(String[] args) {
			T10010 t1 = new T10010();
			T10010 t2 = new T10010();
//			 也可同过类名直接访问 
			T10010.A = 10;
			t1.A = 12;
			System.out.println(t2.A);
//           12
			}
}

静态方法：

1.不需要实例化，可以直接访问

2.静态方法里只能直接访问静态成员，而不能直接访问类中的非静态成员

3.静态方法中不能使用this、super关键字

4.静态方法不能被非静态方法覆盖，

5.静态方法不能修饰构造器

静态代码块：

6.一个类中由static关键字修饰的，不包含在任何方法体中的代码块

7.当类被载入时，静态代码块被执行，且只被执行一次

8.静态块经常用来进行类属性的初始化

13.5final

1.修饰类：不能被继承

2.修饰变量(属性和局部变量)：不能被重新赋值

3.在声明时赋值，或在构造器中赋值用final之后系统不会对final属性默认的赋初始值

4.修饰方法：不能在子类中被覆盖，即不能修改。

5.常用来确定唯一变量的赋值（很少修改的变量如圆周率）

首先把它设置为静态static，多个实例共享该常量，没有必要每个对象保存一份；

其次，设置为final类型，赋值以后不能再改变；

最后注意遵守常量命名规范，所有字母大写、单词之间用下划线。

14.面向对象编程（Object Oriented Programming）

14.1 什么是对象？

是系统中用来描述客观事物的一个实体。把一个事物抽象出来，赋予它具体的值，比如学生这个对象，可以通过，学号，名字（属性）以及一些行为（方法）等抽象表示出来。

优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统更加灵活、更加易于维护.
缺点：性能比面向过程差

类：类是一组具有相同属性和行为的对象的抽象，类的作用是用来创建对象，对象是类的一个实例

14.2 类和对象的关系

•抽象和具体的关系。

• 每一个类在某一时刻都有零个或更多的实例，类是生成对象的模板

一个类定义了描述属性，每一个对象都有相应的属性值数据，一个类通过一系列方法来定义行为，这些方法能在每个对象中被使用

14.3 对象的创建

所有的对象都是通过构造器来创建的，也可以说任何对象都是通过内存分配操作符new 创建和开辟内存空间的。如果在开发时，没有明确的写出构造方法，在编译时编译器会发现该类没有构造器，这时编译器会自动的给这个类增加一个构造器，该构造器没有任何参数，我们称之为“默认的空构造器”。反之则无空参构造器（如过不手动写的话）。

14.4 栈和堆

栈stack：栈的存取速度比堆快，效率高。在栈内保存基本数据类型的局部变量和对象的引用，值先进后出。

•堆heap：堆可以保存那些对空间要求较大的变量。如对象的属性和数组的元素，先进先出。在堆内存中开辟空间，只能通过内存分配操作符号new，凡是出现关键字new的地方必定分配了一个堆内存。

栈是编译时分配空间，而堆是动态分配（运行时分配空间），所以栈的速度快

栈：当声明这些变量时，即入栈，开辟栈空间。当变量超出作用域时出栈，释放栈空间。出栈的变量自动失效，释放的空间可以。再分配给其他变量，不需要回收内存空间。栈要求保存在其内部的变量，在声明时必须有确定的大小和生存周期。

案例

    Teacher teacher1 = new Teacher(1,2);
    teacher1.setY(1);
    teacher1.setX(2);

在这段代码中，Teacher teacher1 = new Teacher(1, 2); 这个语句会在栈内存中创建一个指向堆内存中的Teacher对象的引用，同时会在堆内存中创建一个Teacher对象，并调用构造函数初始化其属性。

接着，teacher1.setY(1); 和 teacher1.setX(2); 这两个语句中，teacher1 是一个引用，它指向堆内存中的 Teacher 对象。当调用 setY(1) 和 setX(2) 方法时，这些方法会在堆内存中的 Teacher 对象上设置相应的属性值。

因此，Teacher对象本身以及其属性值都存储在堆内存中，而栈内存中只存储了对堆内存中对象的引用。

如果Teacher的setX x是一个引用数据类型呢?

如果Teacher类中的x是一个引用数据类型，那么情况会有所不同。当你调用teacher1.setX(2);时，如果x是一个引用数据类型，那么这个值 2 将是一个引用，指向另一个对象或数据结构。

在这种情况下，这个引用值 2 会存储在栈内存中，而指向的具体对象或数据结构则会存储在堆内存中。所以在堆内存中会有一个对象或数据结构，而栈内存中则存储了对这个对象或数据结构的引用。

栈（Stack）

特点：
- 栈是一种线性数据结构，遵循后进先出（LIFO）的原则。
- 栈中存储的数据是按照顺序排列的，每次只能访问栈顶的元素。
- 栈是一种轻量级的数据结构，用于存储方法调用、局部变量和方法参数等。
存储内容：
- 栈存储的是基本数据类型的变量值和对象的引用。
- 方法调用时，每个方法在栈中创建一个栈帧（Stack Frame），用于存储方法的参数、局部变量和返回地址。
生命周期：
- 栈中的数据的生命周期与其所在方法的生命周期相关。当方法执行结束时，栈帧被销毁，栈中的数据也随之消失。
内存管理：
- 栈的内存管理是自动的，由Java虚拟机（JVM）自动分配和释放栈帧的内存空间。

堆（Heap）

特点：
- 堆是一种用于动态分配内存的数据结构，存储的数据是无序的。
- 堆中存储的是对象的实例和数组对象。
存储内容：
- 堆中存储的是对象的实例和数组对象，对象的引用存储在栈中。
- 对象在堆中是通过new关键字动态分配的。
生命周期：
- 对象在堆中的生命周期与其引用的存在时间相关。当没有任何引用指向一个对象时，该对象会被Java垃圾回收器回收。
内存管理：
- 堆的内存管理是由Java垃圾回收器负责的，它会定期检查堆中的对象，回收不再被引用的对象所占用的内存空间。

总结

栈用于存储基本数据类型的变量值和对象的引用，而堆用于存储对象的实例和数组对象。
栈的内存管理是自动的，随着方法的调用和结束而动态分配和释放内存空间；堆的内存管理由垃圾回收器负责，回收不再被引用的对象。
栈的访问速度比堆快，因为栈是一种线性结构，而堆是一种动态分配的数据结构。

14.5 对象的使用

对象名分配在栈内存中即指向堆内存实例的地址值。

在其他类中或main方法中，若想访问对象的属性或是方法必须先实例化这个类，然后通过对象名（引用）和点操作符来完成：对象名. 属性名（）；对象名. 方法名（）；如果在类内的方法中，访问本类的属性和方法就可以直接访问了。

14.6 垃圾回收机制

–垃圾回收机制实际上是JVM内部运行的一个优先级比较低的后台线程，这种多线程的模式使得java 具有更好的性能。

–垃圾回收机制仅仅作用于堆内存，于栈内存无关。

回收的标志

//1.对象被赋值为null
Person p = new Person;
p = null;
//2.匿名对象使用过后
new Person().say();
//3.超出生命周期
for(int i=0;i<10;i++){
    Person p = new Person();
}
//这里，变量p 被实例化100次，每结束一次循环，变量p就超出生命周期，对象变为垃圾。

在 Java 8 中，默认使用的是 G1 (Garbage First) 垃圾回收器。G1 是一种面向服务端应用的垃圾回收器，它在整体上采用了标记-整理算法。下面是对 G1 垃圾回收器的详细解释：

G1 垃圾回收器

目标：
- G1 的主要目标是实现高吞吐量和低停顿时间，适用于大堆内存的应用程序。
工作原理：
- G1 将堆内存划分为多个大小相等的区域（Region），每个区域可以是 Eden 区、Survivor 区或 Old 区。
- G1 通过并发标记-整理的方式来进行垃圾回收，它会并发标记存活对象，然后选择性地清理未使用的区域。
特点：
- 区域化管理：G1 将堆内存划分为多个区域，可以更精确地控制垃圾回收的范围，避免全局性的停顿。
- 并发标记：G1 在标记阶段会与应用程序并发执行，减少停顿时间。
- 混合回收：G1 会根据当前堆内存的使用情况选择性地回收某些区域，而不是像传统的垃圾回收器那样只做全堆回收。
- 自适应调整：G1 会根据应用程序的运行情况动态调整参数，以达到更好的性能。
优势：
- 低停顿时间：G1 的并发标记和部分回收策略可以降低应用程序的停顿时间。
- 高吞吐量：G1 的区域化管理和混合回收策略可以提高整体的垃圾回收效率。

总的来说，Java 8 中的 G1 垃圾回收器通过区域化管理、并发标记、混合回收等策略，实现了较低的停顿时间和较高的吞吐量，适用于大型服务端应用程序的内存管理。

（Garbage First）垃圾回收器在执行垃圾回收时主要使用了以下两种算法：

并发标记算法：
- G1 垃圾回收器使用并发标记算法来标记存活对象。这意味着在进行垃圾回收时，应用程序的某些部分可以继续运行，而不需要完全停止。
- 并发标记算法允许在标记阶段与应用程序并发执行，从而减少停顿时间，提高系统的响应性。
标记-整理算法：
- 在执行垃圾回收时，G1 垃圾回收器采用标记-整理算法。这种算法首先标记所有活跃对象，然后将存活对象从不同的区域整理到一起，从而使得内存中的空闲空间连续化，方便后续的内存分配。
- 标记-整理算法有助于减少内存碎片化，提高内存利用率，并且可以在整理过程中将存活对象向堆的一端移动，以减少垃圾回收后的碎片化。

通过并发标记和标记-整理算法的结合，G1 垃圾回收器能够在保持较低的停顿时间的同时，有效地管理内存中的对象，并提高垃圾回收的效率。这使得 G1 在处理大型堆内存和需要低延迟的应用程序时具有很好的性能表现。

14.7 构造器

具有与类相同的名称

不含返回值类型

不能在方法中用return语句返回一个值

一般访问权限为public

作用

完成对象的创建，即完成对象的实例化

一般使用构造器来完成对成员变量的初始化

14.8 Java启动参数

在Java中启动Spring Boot项目时，可以通过设置JVM参数来调整堆内存、栈内存等空间的大小。以下是一些常用的JVM参数，可以在启动Spring Boot项目时使用：

设置堆内存大小：
- -Xms<size>：设置JVM的初始堆大小。
- -Xmx<size>：设置JVM的最大堆大小。
例如，-Xms512m -Xmx1024m 表示将初始堆大小设置为512MB，最大堆大小设置为1GB。
设置栈内存大小：
- -Xss<size>：设置每个线程的栈大小。
例如，-Xss1m 表示将每个线程的栈大小设置为1MB。
设置永久代大小（仅适用于 JDK7 及以下版本）：
- -XX:PermSize=<size>：设置永久代的初始大小。
- -XX:MaxPermSize=<size>：设置永久代的最大大小。
设置元空间大小（适用于 JDK8 及以上版本）：
- -XX:MetaspaceSize=<size>：设置元空间的初始大小。
- -XX:MaxMetaspaceSize=<size>：设置元空间的最大大小。
其他常用参数：
- -XX:+UseG1GC：启用G1垃圾收集器。
- -XX:+UseConcMarkSweepGC：启用CMS垃圾收集器。
- -D<property>=<value>：设置系统属性。

这些参数可以在启动Spring Boot项目时通过命令行参数传递给JVM。例如：

java -Xms512m -Xmx1024m -jar your-application.jar

这会将初始堆大小设置为512MB，最大堆大小设置为1GB，并启动你的Spring Boot应用程序。请根据你的应用程序需求和系统资源进行适当的调整。

15.多态性

理解

一个事物的多种形态

对象的多态性：父类的引用指向子类的对象

Person p = new Student();
//调的是子类重写父类的方法即虚拟方法
p.eat();

Java引用变量有两个类型，编译时类型和运行时类型。

编译时类型：由声明该变量时使用的类型决定（只能调用父类声明的方法）

运行时类型：实际执行时重写父类的方法

重写：子类对父类中的同名同参数的方法进行覆盖。（权限修饰符不小于父类的，返回值类型相同或者是其子类，异常不大于父类的）

重载：存在多个方法名，形参不同，子类可以重载父类不同参数的方法，编译期已经确定，静态绑定。

多态

只有等到方法调用时才知道，动态绑定

注：多态性不适用于属性，多态属于运行时行为

16.继承性

好处

提高代码复用，减少冗余，便于功能的拓展，为多态提供了前提

体现

一旦子类继承父类，子类就获取了父类中声明所有的属性和方法，父类中声明的private的属性和方法，仍是获取了的，只是因为封装性的影响，使的子类不能直接调用父类的结构而已，证明如下

    //子类对象依然可以输出see方法
public void say(){
        System.out.println("hello10086");
        see();
    }
    
private void see(){
        System.out.println("look private");
    }

注一个子类只能有一个父类，而一个父类可以派生出多个子类

17.封装性

理解

把该隐藏的隐藏

作用

实现高内聚（类内部数据操作细节自己完成不允许外部干涉），低耦合（仅对外暴露少量的方法用于使用）

体现

单例模式（

一是这个类只能有一个实例；（构造器private ）

二是它必须自行创建这个实例；（自己在方法中创建自己对象的实例）

三是它必须自行向整个系统提供这个实例。（所以提供自己对象的方法是public）

）等

四种权限修饰符

18. 异常

1.编译时异常

不能运行，是RuntimeException以外的异常
IOException、SQLException等以及用户自定义的Exception 影响正常编译的

2.运行时异常

都是RuntimeException类及其子类异常

3.Error

是程序无法处理的错误，表示运行应用程序中较严重问题，如，Java虚拟机运行错误（Virtual MachineError）

18.1 继承关系

18.2 异常的处理过程

在Java程序执行过程中如果出现异常事件，系统会发出异常报告，这时系统将生成一个异常类对象，异常类对象封装了异常事件的信息并将其提交给Java运行时系统。

自行处理：可能引发异常的语句封入在 try 块内，而处理异常的相应语句则封入在 catch 块内。

回避异常：在方法声明中包含 throws 子句，通知潜在调用者，如果发生了异常，必须由调用者处理。

catch块，是用来捕获并处理try块抛出的异常的代码块。没有try块，catch块不能单独存在。

可以有多个catch块，以捕获不同类型的异常如果程序抛出多个不同类型的异常。

try{…}和catch( ){…}之间不可以添加任何代码

//多个catch时从上到下抛出的异常依次为从小到大
catch (ArrayIndexOutOfBoundsException e) {
   System.out.println(“Out of Bounds!”); }
catch (RuntimeException e) {
   System.out.println(“Runtime Exception!”);}
catch (Exception e) {
   System.out.println(“Exception!”); }

18.3 finally语句

语句中的代码块不管异常是否被捕获总是要执行

即使try代码块和catch代码块中使用了return语句退出当前方法或般若break跳出某个循环，相关的finally代码块都有执行。

当try或catch代码块中执行了System.exit(0)时，finally代码块中的内容不被执行


public static int test1() {
        try {
            return 2;
        } finally {
            return 3;
        }
   }

//返回的return 3
//如果 finally里面是 sout 3 则输出的是32
    public static int test1() {
        int i = 0;
        try {
            i = 2;
            return i;
        } finally {
            i = 3;
        }
// 2
//return之前执行finnally
//在执行 finally 之前，JVM 会先将 i 的结果暂存起来，然后 finally 执行完毕后，
//会返回之前暂存的结果，而不是返回 i，所以即使这边 i 已经被修改为 3，
//最终返回的还是之前暂存起来的结果 2。

18.4 throws

throws关键字后面，可以跟多个异常，中间用逗号分割

throws关键字抛出的异常，由调用该函数的函数处理。

throw 和 throws

			public void name()throws Exception {
//throw语句用在方法体内,表示抛出异常,由方法体内的语句处理。不能单独使用，
//要么和try.. catch…一起使用，要么和throws一起使用。
//				throws:表示抛出异常，由该方法的调用者来处理	 
//				 throw:表示抛出异常，由该方法体内的语句来处理
				throw new IndexOutOfBoundsException();
			}

注：异常如果一直被throws抛出的话就会被jvm异常处理器处理了，这时jvm会跳出正常运行状态。

注：所有异常必须最终在某个地方catch住，以便不让他被jvm异常处理器处理