推荐文章：Java 教程https://www.runoob.com/java/java-tutorial.html
java体系：
1、javaSE，标准版，各应用平台的基础，桌面开发和低端商务应用的解决方案。
2、javaEE，企业版，以企业为环境而开发应用程序的解决方案。
3、javaME，微型版，致力于消费产品和嵌入式设备的最佳方案。
java可以做什么
1、开发桌面应用程序。
2、开发面向Internet的web应用程序。
3、提供各行业的解决方案。
4、开发android手机应用程序。
java的特性
1、一种面向对象的编程语言。
2、一种与平台无关的语言（根据JVM实现，跨平台）。
3、一种健壮性语言。
4、具有较高的安全性。
java应用程序的运行机制
先编译（.class），在解释运行。
JDK和JRE
JDK：java开发工具包
先编译（编译器javac），后运行（解释器java）
JRE：java运行环境
加载代码（加载器），校验代码（校验器），执行代码（解释器）
java虚拟机（JVM）
java虚拟机实际上只是一层接口，一层Java程序和操作系统通讯的接口。java文件编译生成class文件，
而java虚拟机就是这些class文件能够在上面运行的一个平台，你把class文件看成一个软件，java虚拟机就是这个软件可以运行 的操作系统。
二进制
1、计算机中的数据都以二进制数据保存。
2、计算机信息的存储单位：
位（bit）：是计算机存储处理信息的最基本的单位
字节（byte）：一个字节有8个位组成。
java开发要点
1、一个源文件中只能有一个public修饰的类，其他类个数不限。
2、一个源文件有n个类时，编译结果的class文件就有n个。
3、源文件的名字必须和public修饰的类名相同
4、java语言中单词拼写大小写严格区分。
5、main方法入口
6、每一句以分号 ; 结束
注释
标识符命名规则
1、命名规则：
由字母、下划线、数字和美元符号组成，不能以数字开头，区分大小写，不能是关键字和保留字（goto、const），长度一般 不超过15个字符。
2、驼峰式命名：
类名：单个单词，首字母大写，多个单词，首字母都大写。
方法名、参数名、变量名：单个单词，首字母小写，多个单词，第一单词首字母小写，其他单词首字母大写。
包名：全部小写。
java基础知识
一、数据类型
1、基本数据类型：
数值型：byte 1字节 8位 -128~127
short 2字节 16位 -32768~32767
int 4字节 32位 -2^31~2^31-1
long 8字节 64位 2^63~2^63-1
浮点类型：
float 4字节 32位
double 8字节 64位
字符型： char 2字节 16位
布尔型： boolean(true或false)
2、引用类型：
字符串 String、类class 、枚举enum、接口interface
二、转义字符
换行：\n 回车：\r 水平制表： \t 单引号：' 双引号：" 斜杠：\
三、基本数据类型之间的转换
1、自动类型转换：范围小→范围大
byte→short→int→long→float→double；
char→int→long→float→double
2、强制类型转换：范围大→范围小
需要加强制转换符
四、变量
1、数据类型划分：
基本类型变量：数据的值
引用类型变量：数据的地址
2、声明的位置划分：
局部变量
全局变量
区别：
1、默认值
局部变量没有默认值，使用前必须初始化。
全局变量有默认值，默认为0，不必须初始化。
2、声明位置
局部变量在方法内。
全局变量在方法外类内。
3、作用范围
局部只能在自己声明的方法里。
全局在整个类中
五、运算符
算术运算符：+ 、 - 、 * 、 / 、 % 、 ++ 、 --
赋值运算符：= 、 += 、 -= 、 *= 、 /= 、 %=
关系运算符：> 、 < 、 >= 、 <= 、 == 、 !=
逻辑运算符：
! 、 & （只要有一个false 最终结果就是false） 、
| （但凡有一个true 最终结果就是true） 、
^ （如果两边一样 最终结果为false 如果两边不同 最终结果为true）、
&&（如果第一个是false 那第二个不执行 最终结果是false）、
||（如果第一个表达式的结果是true 那第二个表达式 就不去计算了 ,最终结果是true）
位运算符： ~ 、 >> 、 << 、 >>>
字符串连接运算符：+
三目运算符：X?Y:Z (相当于 if(X=true){Y}else{Z})
X为boolean类型表达式，先计算x的值，若为true，整个三目运算的结果为表达式Y的值，否则整个运算结果为表达式Z的值。
六、if语句和switch语句
**if语句**：
1、if () {}
2、if () {}else{}
3、if () {}else if(){}
4、if () {if(){}else()}
5、if () 执行语句 esle 执行语句 注意：执行语句只有一条语句的时候.可以将if esle 的大括号省略
注意：()内是boolean类型表达式，{}是语句块。
比较字符串用equals，比较内容。比较数值用==，比较地址。
基本数据类型：变量名、变量值在栈中。
引用数据类型：变量名在栈中，变量值在常量池中。
**switch语句**
switch(表达式expr){
case const1:
statement1;
break;
…
case constN:
statementN;
break;
[default:
statement_dafault;
break;]
}
将【表达式expr】分别和case中的值【const1...constN】作比较,如果相等，则执行对应case中的语句。
注意：
1、switch后面括号内的“表达式”必须是整数类型（int、byte、char、short、enmu、String类型）。
2、constN必须是常量或者finall变量，不能是范围。
3、所有的case语句的值不能相同，否则编译会报错。
4、default可要可不要。
5、default并不是一定要有，如果前面遇到break，default就不执行。如果没有遇到break，就一定会执行。
**if和switch的区别：**
1、if可以判断范围，也可以判断一个值，switch只能判断指定的值。
2、若只判断指定的值，则使用switch语句，效率快,if判断范围，对数据判断灵活，自身的格式也比较灵活。
七、for循环
for ( [循环变量初始值设定(表达式1)] ; [循环条件判断(表达式2)] ; [改变循环变量的值(表达式3)] ){
循环体
}
注意：
1、表达式2一般不可以省略，否则死循环
2、表达式3可以省略，但是在循环体中必须有语句修改变量，以使表达式2在某一时刻为false结束循环。
3、若同时省略表达式1，表表达式3，则相当于while（表达式2）语句
4、三个表达式均省略 即for(;;)语句，此时相当于while(true)语句
5、表达式1、表达式3可以是逗号表达式,以使循环变量值在修改时可以对其它变量赋值
八、while语句
while(条件表达式语句)｛
循环体语句;
}
[初始条件]
do｛
循环体;
[迭代]
｝while( 循环条件判断);
注意：
1、当第一次执行时，若表达式=false时，则while语句不执行，而do/while语句执行一次后面的语句
2、一定要切记在switch循环中，如果没有break跳出语句，每一个case都要执行一遍，在计算最终结果。
九、break和continue
break跳出某个循环
continue跳过某个循环
注意：if外有循环可以用break、continue，单纯if不可以用。
十、类和对象
1、 对象：看得见摸得着的具体事物。
类：抽象化的概念
2、 类和对象的关系：
类是对象的模板/抽象化的概念，对象是类的实例。
3、创建类和对象
类：
特征：全局变量/属性/成员变量
动作：方法
对象：
类名 对象名=new 类名（）
注意：一个类可以创建多个对象，，每个对象之间没有关系。
一个类可以包含以下类型变量：
局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变 量就会自动销毁。
成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
类变量：类变量也声明在类中，方法体之外，但必须声明为static类型。
一个类可以拥有多个方法。
十一、return
十二、重载overload
十三、递归
面向对象编程
一、面向对象和面向过程
1、面向对象：是以具体的事物为单位，考虑的是它的特征（属性）和行为（方法）。
2、面向过程：是以具体的流程为单位，考虑功能的实现。
二、内存图
1、栈：先进后出，存放基本数据类型变量名和变量值，引用数据类型的变量名，方法执行的时候进入栈中。
2、堆：先进先出，new出来的对象的实例，包括类的属性个方法。
三、构造方法
构造方法(构造函数)
1.构造器名称和类名一致。
2.没有返回值类型(8种基本类型,String,引用类型,void)。
3.一个类中可以有多个构造器,多个构造器靠参数列表(个数,顺序,类型)来区分（重载）。
4.构造器的调用:当类被实例化时调用(new)--通过（名+参数列表）调用。
5.如果你不给这个类提供构造器，JVM会给该类提供一个默认的无参的构造器。
如果你给这个类提供构造器，JVM不会给该类提供一个默认的无参的构造器。
作用:
为了初始化对象方便,更合理的初始化。
四、关键字
**1. this**
this代表对象的引用(谁调用就代表谁)， 必须放在非静态方法里面，this是自身的一个对象，代表对象本身， 指向对象本身的 一个指针。
**2. super**
super主要有两种用法：
1）super.成员变量/super.成员方法;
2）super(parameter1,parameter2…)
第一种用法主要用来在子类中调用父类的同名成员变量或者方法；第二种主要用在子类的构造器中显示地调用父类的构造器，要注意的是，如果是用在子类构造器中，则必须是子类构造器的第一个语句。
super是一个关键字，代表父类的存储空间标识。(父亲的引用)
**3.static**
static关键字的中文意思是静态的， 可以修饰字段、方法、内部类。使用该关键字修饰的内容，在面向对象中static修饰的内容是隶属于类，而不是直接隶属于对象的，故而生命周期与类相同，即在整个程序执行周期有效。所以static修饰的成员变量一般称作类成员变量，而static修饰的方法一般称作静态方法，普通变量和方法属于对象。
主要有四种用法：
（1）用来修饰成员变量，将其变为类的成员，从而实现所有对象对于该成员的共享；
（2）用来修饰成员方法，将其变为类方法，可以直接使用“类名.方法名”的方式调用，常用于工具类；
（3）静态块用法，将多个类成员放在一起初始化，使得程序更加规整，其中理解对象的初始化过程非常关键；
（4）静态导包用法，将类的方法直接导入到当前类中，从而直接使用“方法名”即可调用类方法，更加方便。
**4.final**
final是一个关键字，用于修饰类，成员变量，成员方法。
特点：它修饰的类不能被继承。它修饰的成员变量是一个常量。它修饰的成员方法是不能被子类重写的。
final修饰的常量定义一般都有书写规范,被final修饰的常量名称,所有字母都大写。
final修饰成员变量,必须初始化,初始化有两种，显示初始化；构造方法初始化,不能两个一起初始化
-final关键字 主要用法有以下四种：
（1）用来修饰数据，包括成员变量和局部变量，该变量只能被赋值一次且它的值无法被改变。对于成员变量来讲，我们必须在声明时或者构造方法中对它赋值；
（2）用来修饰方法参数，表示在变量的生存期中它的值不能被改变；
（3）修饰方法，表示该方法无法被重写；
（4）修饰类，表示该类无法被继承。
final和private的区别：
1.final修饰的类可以访问；
private不可以修饰外部类，但可以修饰内部类（其实把外部类私有化是没有意义的）。
2.final修饰的方法不可以被子类重写；private修饰的方法表面上看是可以被子类重写的，其实不可以，子类是看不到父类的私有方法的。
3.final修饰的变量只能在显示初始化或者构造函数初始化的时候赋值一次，以后不允许更改；private修饰的变量，也不允许直接被子类或一个包中的其它类访问或修改，但是他可以通过set和get 方法对其改值和取值。
This指向本类，super指向父类
（1） super（参数）：调用基类中的某一个构造函数（应该为构造函数中的第一条语句）
this（参数）：调用本类中另一种形成的构造函数（应该为构造函数中的第一条语句）
（2）super: 它引用当前对象的直接父类中的成员（用来访问直接父类中被隐藏的父类中成员数据或 函数，基类与派生类中有相同成员定义时如：super.变量名 super.成员函数据名（实参）
this：它代表当前对象名（在程序中易产生二义性之处，应使用this来指明当前对象；如果函数的形参与类中的成员数据同名，这时需用this来指明成员变量名）
（3）调用super()必须写在子类构造方法的第一行，否则编译不通过。每个子类构造方法的第一条语句，都是隐含地调用 super()，如果父类没有这种形式的构造函数，那么在编译的时候就会报错。
super()和this()类似,区别是，super()从子类中调用父类的构造方法，this()在同一类内调用其它方法。super()和this()均需放在构造方法内第一行。尽管可以用this调用一个构造器，但却不能调用两个。
this和super不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造函数必然也会有super语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也不会通过。
this()和super()都指的是对象，所以，均不可以在static环境中使用。包括：static变量,static方法，static语句块。
从本质上讲，this是一个指向本对象的指针, 然而super是一个Java关键字。
五、面向对象的三大特征
封装：把描述一个对象的属性和行为封装成一个类，把具体的业务逻辑功能实现封装成一个方法，其次封装的意义还有效的保护属性通过访问修饰符私有化属性(成员变量),公有化方法。
继承：实现代码的复用，所有的子类所共有的行为和属性抽取为一个父类，所有的子类继承该类可具备父类的属性和行为，继承具有单一性和传递性。
多态：多态就是一个行为具有多个不同表现形式或形态的能力就是同一个接口使用不同的实例而执行的不同的操作。
六、抽象abstract
被abstract修饰的类为抽象类。
被abstract修饰的方法(抽象方法没有方法体)为抽象方法。
特点：
抽象方法一定要在抽象类中，但是抽象类中可以没有抽象方法。
抽象类中可以存在普通方法。
抽象类不能实例化。
抽象类必须被重写才能使用，但是方法可以被多次重写。
abstract不能和final、static、private、nation一起使用。
七、接口interface
接口是一种特殊的抽象类，这种抽象类中只包含常量和抽象方法的定义，而没有变量和方法的实现。
接口的特点:
1.接口使用interface修饰
2.接口是常量和抽象方法的集合
常量: 默认使用 public static final
方法: 默认使用 public abstract修饰
3.在JDK1.8以后不仅仅只有常量和抽象方法,还有默认方法和静态方法
默认方法用来直接给子类使用,如果子类想重写也可以自行根据需求重写,不会强制重写
静态方法用来直接通过接口名访问
4.接口不能够实例化
5.接口如果想要实例化–利用多态
6.接口的实现类特点:
a.如果一个类想要实现一个接口就必须实现接口中定义的所有抽象方法
b.如果一个类不想实现接口中的抽象方法,那么实现类也升级为接口
7.接口是一种规范
8.接口可以用来扩展功能
9.接口是灵活的
10.接口是由继承者来实现
11.接口/类之间的关系
类和类 单继承 不可以实现
类和接口 不可以继承 多实现
接口和接口 多继承 不可以实现
12.接口和继承的区别?
什么时候使用接口? 什么时候使用继承?
大部分情况下使用接口,因为接口灵活,主要是降低了耦合性,并且接口是一种规范
继承主要体现在代码的抽取以及多态的必要条件
八、抽象类和接口的区别
1）一个类只能继承一个抽象类，而一个类却可以实现多个接口；
2）抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是public static final类型的；
3）接口中不能含有静态代码块以及静态方法，而抽象类可以有静态代码块和静态方法；
4）抽象类可以提供成员方法的实现细节，而接口中只能存在public abstract 方法；
5）抽象类的抽象方法可以是public，protected，default类型，而接口的方法只能是public。
九、方法重载overload与重写override（多态）
重载：JAVA中一个类可以有多个同名方法，参数类型或个数等可以不同。（没有继承关系）
重写（覆盖）：在子类中定义某方法与其父类有相同的名称，返回类型和参数（有继承关系，父类与子类之间的多态性）
十、重写和重载的区别：
重载与重写是 Java 多态性的不同表现。
重写是父类与子类之间多态性的表现，在运行时起作用（动态多态性，譬如实现动态绑定）
而重载是一个类中多态性的表现，在编译时起作用（静态多态性，譬如实现静态绑定）。
重写方法的规则：
1）、参数列表必须完全与被重写的方法相同，否则不能称其为重写而是重载。
2）、返回的类型必须一直与被重写的方法的返回类型相同，否则不能称其为重写而是重载。
3）、访问修饰符的限制一定要大于被重写方法的访问修饰符（public>protected>default>private）
4）、重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异常。例如：
父类的一个方法申明了一个检查异常IOException，在重写这个方法是就不能抛出Exception,只能抛出IOException的子类异常，可以抛出非检查异常。
重载的规则：
1）、必须具有不同的参数列表；
2）、可以有不同的返回类型，只要参数列表不同就可以了；
3）、可以有不同的访问修饰符；
4）、可以抛出不同的异常；
十一、访问权限修饰符
1 private
访问限制的最窄的修饰符，一般称之为“私有的”。被其修饰的类、属性以及方法只能被该类的对象访问，其子类不能访问，更不能允许跨包访问。
2 Default
“默认访问模式“，即不加任何访问修饰，只允许在同包中进行访问。
3 Protected
“保护形”，被其修饰的类、属性及方法只能被类本身的方法及子类访问，即使子类在不同的包中也可以访问。
4 Public
供所有的类访问。
十二、equals
object中的equals比较的是地址，底层封装的是==
==比较的是基本数据类型，比较的是内容
引用数据类型比较的是地址
String中也有equals，String中的equals被重写过了，比较的是内容。
十三、空指针异常
1、声明了对象名，但没有给对象初始化，然后使用这个对象
2、遇到了类类型作为属性的时候，就必须初始化，否则就会报错
十四、内部类
内部类（inner class）是定义在另一个类中的类
内部类的好处：
1.隐藏机制:内部类封装性更好，隐藏在一个类之中，同一包中的其他类也不能访问
2.内部类可以访问外围类的私有数据
1.成员内部类
可以访问外部类的所有成员变量和方法（无论静态、非静态)
自身没有静态成员
外部类里面创建成员内部类的实例：this.new Innerclass();
在外部类之外创建内部类的实例：new Outerclass().new Innerclass();
在内部类里访问外部类的成员：Outerclass.this.member
2.静态内部类
static inner class (nested class)
使用内部类只是为了把一个类隐藏在另外一个类的内部，并不需要内部类引用外围对象，可以将内部类声明为static。
成员内部类没有静态成员；
静态内部类只能访问外围类的静态成员
3.局部内部类
local inner class
在方法中定义、使用
不能被public, protected, private和static修饰(像局部变量一样)
只能访问方法中定义的final类型的局部变量(初始化之后便不能更改)
4.匿名内部类
anonymous inner class
没有名字的局部内部类。
用于只创建这个类的一个对象的场合（不必命名），通常是作为方法的参数
隐式地继承了一个父类或者实现了一个接口
限制：由于构造方法的名字与类名相同，而匿名类没有类名，所以，匿名类不能有构造方法。
十五、模式
1、单例模式
分类：懒汉式、饿汉式
1、构造方法私有化
2、在本类中创建本类对象
3、保证对象的唯一性final
4、给外界提供得到对象的方法 static
5、在多线程中，饿汉式安全，懒汉式不安全
2、简单工厂模式
批量创建对象
1 创建工厂类 : 创建对象的方法
2 果汁类 是所有种类果汁的父类
3 在工厂类的方法中返回果汁类
4 根据测试类中传递的字符串判断到底返回哪种果汁
5 测试类通过工厂类返回果汁对象
3、建造者模式
内部类使用场景
目的：静态内部类创建外部类对象
1、 创建外部类，在其中创建一个静态内部类
2、静态内部类中写属性，构造方法和set get方法
3、静态内部类中写一个方法，必须返回外部类对象
4、 给外部类创建对象，传递参数。
4、装饰者模式
1、在处理流中使用
2、子类重写父类的方法,提高父类方法的功能及效率
3、为了尽可能减少重复代码,在重写的方法中用父类的对象调用父类原来的方法
4、得到父类对象可以通过将父类对象作为子类属性,通过子类构造方法传递父类对象
十六、数组及常用算法
1 数组也是一种类型
Java中要求所有的数组元素具有相同的数据类型。因此在一个数组中，数组元素的类型是唯一的，不能存储多种类型的数据。
一旦数组的初始化完成，数组在内存中所占的空间将被固定下来，因此数组的长度不可以被改变。即使某个数组元素的数据 被清空，他占的空间依然被保留，依然属于该数组，数组的长度依然不变。
Java的数组既可以存储基本类型的数据，也可以存储引用类型的数据，只要所有的数组元素具备相同的类型即可。
数组也是一种数据类型，是引用类型。所以可以把数组作为数组的元素，也就构成了二维数组。
2 定义一个数组
数组的定义可以采用两种方法，推荐采用第一种，这样变量的类型是数组这一概念更加直接。
(1) type[] arrayName;
(2) type arrayName[];
3 初始化数组
注意，不要在进行初始化时，既指定数组的长度也为每个数组元素分配初始值。 一般采用下列方法中的一种。
3.1 静态初始化
初始化时由程序员显示指定每个数组元素的初始值，由系统决定数组长度。
arrayName = new type[] {element1 , element2 , element3 , element4...};
此处的type必须与定义数组变量时所用的type相同，也可以是定义时的type的子类
执行静态初始化时，显示指定的数组元素值的类型必须与new关键字后面的type类型相同，或者时其子类的实例。
3.2 动态初始化
初始化时程序员只指定数组长度，由系统为数组元素分配初始值。
arrayName = new type[length];
3.3 更简洁的方法
如果我们在定义的时候就对数组进行静态初始化，可以用一种更简洁的方法。
type[] arrayName = {element1 , element2 , ...};
4 遍历数组
Java为数组提供了一个更简单的循环，foreach循环。这种循环会自动遍历数组和集合，更加简洁。使用foreach时无需获得 数组和集合的长度，无需根据指引访问数组元素和集合元素。语法：
for(type variableName : array |collection){
//variableName 自动迭代访问每个元素
}
ariableName 是一个形参名，foreach 会自动将数组元素依次赋给该变量。冒号后面写数组名或集合名
foreach 方法不能修改原数组的值，只能读取，因为我们在语句里面直接访问的是形参，而不是数组本身，foreach 会自动将数组的值赋给形参供我们提取。
5 数组常用方法
插入算法
public class AddNumToArray{
public static void main(String[] args){
// 一个有序的数组,向该数组中添加一个元素，数组依然有序。
int[] arr = {1,3,7,9,12,20,0};
int t = 0;
// 【1】找位置
int loc = -1; // 表示t应该添加到的位置
for(int i = 0;i<arr.length-1;i++){
if(arr[i] >= t){
loc = i;
break;
}
}
System.out.println("loc = "+loc);
if(loc < 0){ // 没找到合适的位置
arr[arr.length-1] = t;
}else{
// 【2】依次后移
for(int j=arr.length-1;j>loc;j--){
arr[j] = arr[j-1];
}
// 【3】添加插入的值
arr[loc] = t;
}
// 验证
for(int i = 0;i<arr.length;i++){
System.out.print(arr[i]+"\t");
}
}
}
删除算法
public class DeleteNumFromArray{
public static void main(String[] args){
// 删除算法
int[] arr = {1,3,7,9,12,20};
int t = 1;
// 【1】找位置
int loc = -1;
for(int i=0;i<arr.length;i++){
if(t == arr[i]){
loc = i;
break;
}
}
// 【2】移动元素
if(loc < 0){
System.out.println(t+"在数组中不存在");
}else{
for(int j = loc;j<arr.length-1;j++){
arr[j] = arr[j+1];
}
// 【3】最后一个元素置0
arr[arr.length-1] = 0;
}
// 验证
for(int i = 0;i<arr.length;i++){
System.out.print(arr[i]+"\t");
}
}
}
冒泡排序
public class Test10{
public static void main(String[] args){
// 对一个无序的数组进行排序
int[] arr = {10,5,3,4,2,9,7};
int tmp = 0;
for(int i=0;i<arr.length-1;i++){ // 外层控制趟数
for(int j=0;j<arr.length-1-i;j++){ // 两两比较
if(arr[j]>arr[j+1]){
tmp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = tmp;
}
}
}
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+"\t");
}
}
}
十七、Java常用类
引用类型String和StringBuffer
基本数据类型包装类
数组对象
日期类
List
Set
数学运算Math类
Random类
Calendar日历类
System类
Runtime类
十八、Java异常处理机制
1.Java所有异常类都是 Throwable的子类。它包括Java异常处理的两个重要子类：Error和Exception.
Error：Error及其子类用来描述Java运行系统中的内部错误以及资源耗尽的错误，是程序无法处理的错误，这类错误比较严 重。这类的大多数错误与代码编写者执行的操作无关，如，运行代码时，JVM（Java虚拟机）出现的问题，例如，Java虚拟机运行错误（Virtual MachineError），当 JVM 不再有继续执行操作所需的内存资源时，将出现 OutOfMemoryError。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止。 这些错误是不可查的，因为它们在应用程序的控制和处理能力之外，而且绝大多数是程序运行时不允许出现的状况。对于设计合理的应用程序来说，即使确实发生了错误，本质上也不应该试图去处理它所引起的异常状况。
Exception：可以通过捕捉处理使程序继续执行，是程序自身可以处理的异常，也称为非致命性异常类。根据错误发生原因可分为RuntimeException异常和除RunTimeException之外的异常，如IOException异常。RuntimeException 类及其子类表示“JVM 常用操作”引发的错误。例如，若试图使用空值对象引用、除数为零或数组越界，则分别引发运行时异常（NullPointerException、ArithmeticException）和 ArrayIndexOutOfBoundException。
异常与错误的区别是：异常可以通过程序自身捕捉处理，而错误是程序自身无法处理的。
2. 在 Java 应用程序中，异常处理机制为：抛出异常，捕捉异常。
抛出异常：当一个方法出现错误引发异常时，方法创建异常对象并交付运行时系统，异常对象中包含了异常类型和异常出现时的程序状态等异常信息。运行时系统负责寻找处置异常的代码并执行。
捕捉异常：在方法抛出异常之后，运行时系统将转为寻找合适的异常处理器（exception handler）。潜在的异常处理器是异常发生时依次存留在调用栈中的方法的集合。当异常处理器所能处理的异常类型与方法抛出的异常类型相符时，即为合适的异常处理器。运行时系统从发生异常的方法开始，依次回查调用栈中的方法，直至找到含有合适异常处理器的方法并执行。当运行时系统遍历调用栈而未找到合适的异常处理器，则运行时系统终止。同时，意味着Java程序的终止。
3.抛出异常的方法：throws和throw
throws：通常被用在声明方法时，用来指定方法可能抛出的异常，多个异常可使用逗号分隔。throws关键字将异常抛给上一级，如果不想处理该异常，可以继续向上抛出，但最终要有能够处理该异常的代码。
throw：通常用在方法体中或者用来抛出用户自定义异常，并且抛出一个异常对象。程序在执行到throw语句时立即停止，如果要捕捉throw抛出的异常，则必须使用try-catch语句块或者try-catch-finally语句。
十九、集合
推荐博客：https://www.cnblogs.com/chenglc/p/8073049.html
二十、Java I/O
推荐博客：https://www.cnblogs.com/ylspace/p/8128112.html
二十一、Java多线程
推荐博客：https://www.cnblogs.com/wxd0108/p/5479442.html
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
