JAVA笔记
八、类的特性
类的私有成员与公共成员与缺省访问控制符
private：私有成员修饰符，无法从该类的外部访问到该类内部的成员，而只能被该类自身访问和修改，而不能被任何其他类获取或引用，从而达到对数据的最高级别保护
public：公共访问控制符，该成员可以被所有其他类所访问，会造成安全性和数据封装性的下降，所以一般应减少公共成员的使用。
可以在公共成员方法内加上判断代码，可以杜绝错误数据的输入。
缺省访问控制符：不加任何访问控制符，表示这个成员只能被同一个包（类库）中的类所访问和调用，其他包中的任何类都不能访问缺省访问控制成员。对于类来说，只能被同一包中的类访问和引用，而不可以被其他包的类所使用。
方法的重载，，，见第七章
构造方法
作用：在对象被创建时初始化对象的成员的方法。
构造方法的名称必须与它所在的类名完全相同。没有返回值但不能用void修饰，因为一个类的构造方法的返回值就是该类本身。创建对象时会自动调用，不需要直接调用，对象产生时自动执行。
特殊性：
构造方法的方法名与类名相同
构造方法没有返回值，但不能写void
构造方法的主要作用是完成对类对象的初始化工作。
构造方法一般不能由编程人员显式地直接调用，而是用new来调用。
在创建一个类的对象的同时，系统会自动调用该类的构造方法为新对象初始化。
默认构造方法：类名（）{}
一旦用户为该类定义了构造方法，系统就不再提供默认的构造方法。这是由Java的覆盖导致的。
构造方法的重载
可以让用户用不同的参数来构造对象，对对象赋值不同的参数。
从一个构造方法调用另一个构造方法
为缩短程序代码，减少开发程序时间。从某一构造方法内调用另一种构造方法，通过关键字this来调用。
公共构造方法和私有构造方法
构造方法一般都是共有（public）的，因为在创建对象时，是在类的外部自动调用的。
如果声明为private，则无法在该构造方法所在的类之外的地方调用，但在该类的内部还是可以被调用的。
静态成员
static被修饰的称为静态成员/类成员，不用static修饰称为实例成员
实例成员：各自拥有自己存储成员的空间，而不与其他对象共享，成员变量各自独立，且存在不同的内存之中，具有此特性的成员变量称之为实例变量。
静态变量 类似全局变量
静态变量/类变量。静态变量隶属于类的变量，而不是属于任何一个类的具体的对象。
静态变量是一个公共的存储单元，保存在类的内存空间的公共存储单元中，静态变量某种程度上与其他语言的全局变量相似。静态变量不需要实例化就可以使用，也可以通过实例对象来访问静态变量。
静态变量的使用格式： 类名.静态变量名
对象名.静态变量名
类中若有静态变量，则静态变量必须独立于方法之外，就像其他高级语言在声明全局变量时必须在函数之外声明一样。
静态方法/类方法
静态方法是属于类的方法，而不加static修饰符的方法，是属于某个具体对象的方法，
方法声明为static的含义：
（1）非static的方法是属于某个对象的方法，在这个对象创建时，对象的方法在内存中拥有属于自己专用的代码段。而static的方法是属于整个类的，在内存中的代码将被所有的对象所共有，而不被任何一个对象所专用。
（2）static方法，不能操纵和处理属于某个对象的成员，即static方法只能访问static成员变量或调用static成员方法，或说在静态方法中不能访问实例变量与实例方法。
（3）在静态方法中不能使用this或super。因为this是代表调用该方法的的对象，但现在“静态对象”既然不能使用对象来调用，this也自然不应存在于“静态方法”内部。
（4）调用静态方法，可以使用类名直接调用，也可以用某一个具体的方法名来调用。
若通过对象名来调用静态方法，则必须先创建对象，然后才能进行调用。
采用“类名.静态方法名（）”
静态初始化器
静态初始化器与构造方法的不同：
（1）构造方法是对每个新创建的对象初始化，而静态初始化器是对类自身进行初始化
（2）静态初始化器一般不能由程序来调用，它是在所属的类被加载内存时由系统调用执行的
（3）静态初始化器是在类被加载内存时只执行一次，与创建多少个对象无关。
（4）不同于构造方法，静态初始化器不是方法，因而没有方法名、返回值和参数。
类是在第一次被使用的时候才被装载，而不是在程序启动的时就装载程序中的所有可能要用到的类。
总之，静态初始化器的作用是对整个类完成初始化操作，包括给static成员变量赋初值，它在系统向内存加载时自动完成。
对象的应用
可以将对象称为“类类型的变量”，它属于非基本类型的变量。实际上对象是一种引用型的变量，而引用型变量实际上保存的是对象在内存中的首地址（也称为对象的句柄），所以就对象的功能而言，对象是“指向对象的变量”，但就其类型而言它是属于“类类型的变量”。因此在某些场合，可以像使用基本类型变量那样使用对象。
对象的赋值与比较
一般是先用new运算符创建对象，然后再对其进行操作处理。但有时没有使用new运算创建新对象，仍然可以对其进行赋值。
通过任一个引用变量所指向的对象内容也会随着更改。
当参数是引用变量时，是传址方式调用，引用变量也可以作为方法的参数来使用。
比较两个对象的相等还可以用equals（）方法
引用变量作为方法的返回值
若要方法返回类类型的变量，只需在方法声明的前面加上要返回的类型即可。
public Person compare(Person p) //返回值的类型为对象
类类型的数组
数组也可以用来存放对象，步骤：
（1）声明类类型的数组变量，并用new运算符分配内存空间给数组
（2）用new创建新的对象，分配内存空间给它，并让数组元素指向它
以对象数组为参数进行方法调用
可将对象数组作为参数传递到方法中。
public static int minAge(Person[ ] p) //以对象数组作为参数传递给方法
格式：类名[ ] 数组名 传递参数时的实参只需给出其数组名即可。
九、继承、抽象类和接口
类的继承
通过继承实现代码复用。
子类继承父类的成员变量和成员方法，同时可以修改父类成员变量或重写父类的方法，还可以添加新的成员变量或成员方法。
类的继承是通过extends关键字实现的。
class SubClass extends SuperClass { … }
新定义的类称为子类，它可以从父类那里继承所有非private的成员作为自己的成员。
如果没有extends关键字，则该类默认为java.lang.Object类（祖宗类）的子类，java语言中的所有类都是通过直接或间接地继承java.lang.Object类得到的。
子类的每个对象也是其父类的对象，而父类的对象不一定是它的子类的对象。
在java语言的继承中，在执行子类的构造方法之前，会先调用父类中没有参数的构造方法，其目的是为了要帮助继承自父类的成员做初始化操作。
说明：
在使用继承的成员时，可以利用惯用的语法，利用子类所产生的stu对象，调用从父类继承而来的方法。如：stu.setNameAge(“张小三”，21);
在执行子类的构造方法之前，会先自动调用父类中没有参数的构造方法，其目的是为了帮助继承自父类的成员做初始化操作。
在严格意义上说，构造方法是不能被继承的，但并不意味着子类不能调用父类的构造方法。
调用父类中特定的构造方法
如果父类中有多个构造方法，如何调用父类中某个特定的构造方法？
是在子类的构造方法中通过super（）来调用父类特定的构造方法。如：super（name,age）;
说明：
如果省略super（）语句，则父类中没有参数的构造方法还是会被调用的
调用父类构造方法的super（）语句必须写在子类构造方法的第一行，否则编译时会出现错误信息
子类中访问父类的构造方法，格式：super（参数列表）。super（）可以重载，约等于父类构造方法的重载，super（）会根据参数的个数与类型，执行父类相应的构造方法。
在执行子类的构造方法之前，如果没有用super（）来调用父类特定的构造方法，则会先调用父类中“没有参数的构造方法”。所以父类在有参数的构造方法的同时一般都有没有参数的构造方法，如“public Person（）{}”
super（）和this（）的功能相似，但super（）是从子类的构造方法调用父类的构造方法，而this（）则是在同一个类内调用其他构造方法。
因为super和this都要在构造方法内第一行，所以super和this不能同时在一个构造方法内
super指的也是对象，所以super同样不能在static环境中使用，包括静态方法和静态初始化器（static语句块）。
在子类中访问父类的成员
格式：super.变量名；
super.方法名;
子类中不能继承父类中的private成员，但protected成员不仅可以在父类中直接访问，同时也可以在其子类中访问。 被protect修饰的成员，可以在子类中直接访问父类的成员，也可以用super关键字访问父类的成员。
说明：被protect修饰的成员可以被三种类引用：该类自身、与它同一个包中的其他类，在其它包中该类的子类。好处：同时兼顾安全性与便利性。
覆盖/重写
重载：是指同一个类内定义多个名称相同，但参数个数或类型不同的方法
覆盖：在子类中，定义名称、参数个数与类型均与父类中完全相同的方法，用于实现重写父类中同名方法的功能。
作用：可以达到不更改父类的方法创建子类的方法，使程序更加安全。
1.覆盖父类的方法
子类定义的方法时与父类的方法名、返回值类型和参数列表完全相同。
子类中不能覆盖父类中声明为final或static的方法。
在子类中覆盖父类的方法时，可以扩大父类中的方法权限，但不可以缩小方法权限。
2.用父类的对象访问子类的成员
通过父类的对象访问子类成员，只限于“覆盖”的情况发生时。
向上转型：子类对象赋值给父类类型的变量。将子类对象看作父类对象，具体的类到抽象的类的转变，是安全的
向下转型：将父类对象通过强制转换为子类型再赋值给子类对象的技术。使用向下转型时，必须使用显式类型转换，如Student stu=(Stundent)per
不可继承的成员与最终类
如果父类成员不希望被子类的成员所覆盖可以将它们声明为final，说明该成员变量是最终变量，即常量，可以访问但不能修改。
如果一个类被final修饰符所修饰，则说明这个类不能再被其他类所继承，即不能有子类，称为最终类。
所有已被private修饰符限定为私有的方法，以及所有包含在final类中的方法，都被默认为是final的。这些方法即不能被子类所继承，也不可以被覆盖。
一个成员变量被static final两个修饰符所限定时，它的实际含义就是常量，所以在程序中通常用static和final一起来指定一个常量，且这样的常量只能在定义时被赋值。
Object类
Object类是所有类的源，所有类的父类。
Object类常用方法：
序号方法 & 描述
创建并返回一个对象的拷贝
比较两个对象是否相等
当 GC (垃圾回收器)确定不存在对该对象的有更多引用时，由对象的垃圾回收器调用此方法。
获取对象的运行时对象的类
获取对象的 hash 值
唤醒在该对象上等待的某个线程
唤醒在该对象上等待的所有线程
返回对象的字符串表示形式
让当前线程进入等待状态。直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法。
让当前线程处于等待(阻塞)状态，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过参数设置的timeout超时时间。
11void wait(long timeout, int nanos)
与 wait(long timeout) 方法类似，多了一个 nanos 参数，这个参数表示额外时间（以纳秒为单位，范围是 0-999999）。 所以超时的时间还需要加上 nanos 纳秒。。
对象运算符 instanceof
利用对象运算符instanceof来测试一个指定对象是指定类或者它的子类的实例，若是返回ture，否则返回false
抽象类
创建专门的父类，专门用来被继承的，称为”抽象类“，只能由抽象类派生出新的子类，再由其子类来创建对象。抽象类不能用new运算符来创建实例对象的类，可以作为父类被其子类共享。（只需声明，不需实现）
抽象类与抽象方法
抽象类是以abstract修饰的类
语法格式如下：
abstract class 类名{
声明成员变量；
返回值的数据类型 方法名（参数表）
{ 。。。。 }
abstract 返回值的数据类型 方法名（参数表）； //抽象方法，在抽象方法中不能定义方法体
}
对抽象方法只需声明，而不需要实现，即用 ； 结尾，意味着这个方法必须被子类的方法覆盖。抽象方法声明中修修饰符static和abstract不能同时使用。
抽象类的子类必须实现父类中的所有抽象方法，或者将自己也声明为抽象的。
注意：抽象类是要被继承的，所以abstract类不能用final来修饰。
abstract不能与private，static，final或native并列修饰同一个方法。
抽象类不一定包含抽象方法，但包含抽象方法的类一定为抽象类。 一个类被定义为抽象类，则该类就不能用new运算符创建具体实例对象，而必须通过覆盖的方式实现抽象类中的方法。
抽象类可以有构造方法，且构造方法可以被子类的构造方法所调用，但构造方法不能声明为抽象的。由于不能new创建对象，因此在某些情况下在抽象类内定义构造方法是多余的。
接口
接口就是一种特殊的抽象类。
作用：（1）丰富Java面向对象的思想
（2）利于代码的规范
（3）有利于对代码进行维护
（4）保证代码的安全和严密
接口是Java中的重要功能，与抽象类非常相似，接口本身也具有数据成员和抽象方法，但是有所不同：
（1）接口中的数据成员都是静态的且必须初始化
（2）接口中的方法必须全部都声明为abstract的，也就是说不像抽象类一样拥有一般的方法，而必须全部是抽象方法。
接口与类的区别：
接口不能实例化对象
没有构造方法
所以方法必须都是抽象的（只声明无方法体）
不能包含成员变量，除static和fianl
不是被类继承。而是要被类实现。
接口支持多继承
[ public ] interface 接口名称 [extendes 父接口名列表]
{
[ public ][ static ][ final ] 数据类型 成员变量名 = 常量；
…
[ public ][ abstract ] 返回值的数据类型 方法名 （参数表）;
…
}
接口（默认情况下）只能被与它处在同一包中的成员访问。当修饰符声明为public时，接口能被任何类的成员所访问。
记住如下两点：接口里的“抽象方法”只需声明，不需定义方法体；二是数据成员都是静态的且必须赋初值，即数据成员必须是静态常量。
接口的实现与引进
利用接口创建新类
class 类名称 impements 接口名表
{ … }
一个类要实现一个接口时应注意的问题：
在非抽象类中不能存在抽象方法
一个类在实现某接口的抽象方法时，必须使用完全相同的方法头。
接口中抽象方法的访问控制符都已被指定为public，所以类在实现方法时，必须显式地使用public修饰符，否则将被系统警告为缩小接口中定义的方法的控制范围。
可以声明接口类型的变量或数组，并用它来访问实现该接口类的对象。
接口的继承：一个接口可以有一个以上父接口，他们之间用逗号分隔，形成父接口列表。新接口将继承所有父接口中的变量与方法。如果子接口中定义了与父接口同名的常量或者相同的方法，则父接口中的常量被隐藏，方法被覆盖。
例：inteface Face3 extends Face1,Face2 //接口的多重继承
利用接口实现类的多重继承：多重继承是指一个子类可以有一个以上的直接父类，该子类可以继承它所有直接父类成员。Java语言虽然不支持类的多重继承，但是可以利用接口间接地解决多重继承问题，并能实现更强的功能。
一个类可以同时实现若干个接口，如果把接口理解成特殊的类，那么这个类利用接口实际上就获得了多个父类，即实现了多重继承。
内部类与匿名内部类
内部类是定义在类中的类，内部类的主要作用是将逻辑上相关的类放到一起，而匿名内部类是一种特殊的内部类，它没有类名，在定义类的同时，就生成该类的一个实例，由于不会在其他地方用到该类，所以不用取名字，因而被称为匿名内部类。
内部类/嵌套类/成员类
内部类可以拥有自己的成员变量与成员方法，通过建立内部类对象，可以访问其成员变量或调用成员方法。
定义内部类时只需将类的定义置于一个用于封装它的类的内部即可。，但注意的是内部类不能与外部类同名，否则编译器将无法区分内部类与外部类。
在封装它的类的内部使用内部类，与普通类的使用方式相同，但在外部引用内部类时，则必须在内部类名前冠以其所属内部类的名字才能使用。在用new运算符创建内部类时，也要在new面前冠以对象变量。
内部类的特性：
内部类可以声明为private或protected
内部类的前面用final修饰，则表明该内部类不能被继承
内部类可以定义为abstract，但需要被其他的内部类继承或实现
内部类不能与包含它的外部类名相同
内部类既可以使用外部类的成员变量，包括静态和实例成员变量，也可以使用内部类所在方法的局部变量
内部类可以是一个接口，该接口必须由另一个内部类实现
内部类不但可以在类中定义，也可以在程序块之内定义内部类。例如，在方法中或循环体内部都可以定义内部类。但是方法中定义的内部类只能访问方法中的final类型的局部变量
内部类如果被声明为static，则静态内部类将自动转化为“顶层类”，即它没有父类，而且不能引用外部类成员或其他内部类中的成员。非静态内部类不能声明静态成员，只有静态内部类才能声明静态成员
匿名内部类：
利用内部类创建没有名称的对象，这种类不取名字，而直接用其父类的名字或者它所实现的接口的名字，而且匿名内部类的定义与创建该类的一个实例同时进行，即该类的定义面前有一个new运算符，而不是使用关键字class，同时带上小括号（）表示创建对象。
格式如下：
（ //创建匿名内部类，并执行所定义的方法
new 类名（）
{
方法名（参数1，参数2，…，参数n）
{ 方法体语句； }
}
）.方法名（参数1，参数2，…，参数n）；
创建匿名内部类主要是用来补充内部类中没有定义到的方法，并可有效地简化程序代码。
说明：匿名内部类名前不能有修饰符，也不能定义构造方法，因为它没有名字，也正是由于这个原因，在创建对象时也不能带参数，因为默认构造方法不能带参数。
匿名内部类在编译完成之后，所产生都文件名称为“外部类名$编号.class”。
在java窗口程序设计中，经常利用匿名内部类的技术来编写“事件”（Event）的程序代码。
包
包用来对类和接口进行分类。包是文件夹，类是文件，包中还可以再有包，称为包等级。同一包中的类名不能重复，不同包中的类名可以相同。
文件声明规则 定义包
必须以package语句作为java源文件的第一条语句，格式为：
package 包名1[.包名2[.包名3]…];
当在一个源文件中定义多个类，并且还有import语句和package语句时，要特别注意这些规则。
一个源文件中只能有一个public类
源文件的名称应该和 public 类的类名保持一致。例如：源文件中 public 类的类名是 Employee，那么源文件应该命名为Employee.java。
如果一个类定义在某个包中，那么 package 语句应该在源文件的首行。
如果源文件包含 import 语句，那么应该放在 package 语句和类定义之间。如果没有 package 语句，那么 import 语句应该在源文件中最前面。
import 语句和 package 语句对源文件中定义的所有类都有效。在同一源文件中，不能给不同的类不同的包声明。
注意：包名与对应文件夹名的名字大小写应一致。
包层次的根目录是由环境变量ClassPath来确定的。若没有使用package语句声明类所在的包，没有包名，即无名包，无名包中不能有子包。包与子包的定义，解决名字空间、名字冲突的问题，它与类的继承没有关系。事实上，一个子类与其父类可以位于不同的包中。使用包名时要十分小心，如果要改变一个包名，就必须同时改变对应得文件夹名。
import语句
import语句是用来提供一个合理的路径，使得编译器可以找到某个类。
*只能表示本层次的所有类，不包括子层次下的类。
java语言的垃圾自动回收
java运行提供一个系统的垃圾回收线程，负责自动回收那些没有与之相连的对象所占用的内存，这种清除无用对象进行内存回收的过程就叫做垃圾回收，是Java语言提供的一种自动内存回收功能，可以让程序员减轻许多呢内存管理的负担，也减少程序员犯错的机会。
好处：把程序员从复杂的内存追踪、监测、释放等工作中解放出来。
防止了系统内存被非法释放，从而使系统更加稳定。
不能通过程序强迫垃圾回收器立即执行。
当垃圾回收器将要释放无用对象占用的内存时，先调用该对象的finalze（）方法。
this、static关键字
在某一构造方法内调用另一构造方法必须使用this关键字来调用，否则编译时将会出现错误。
this的本质就是“创建好的对象的地址”
this最常的用法：
在程序中产生二义性之处，应使用this来指明当前对象;普通方法中，this总是指向调用该方法的对象。构造方法中，this 总是指向正要初始化的对象。
使用this关键字调用重载的构造方法，避免相同的初始化代码。但只能在构造方法中用，并且必须位于构造方法的第一句。
this不能用于static方法中。
this关键字三种用法：
this.属性名
如果方法里有个局部变量和成员变量同名，但程序又需要在该方法里访问这个被覆盖的成员变量，则必须使用this前缀。
当一个类的属性（成员变量）名与访问该属性的方法参数名相同时，则需要使用this关键字来访问类中的属性，以区分类的属性和方法中的参数。
this.方法名
this关键字最大的作用就是让类中一个方法，访问该类里的另一个方法或实例变量。
对于static修饰的方法而言，可以使用类来直接调用该方法，如果在 static 修饰的方法中使用 this 关键字，则这个关键字就无法指向合适的对象。所以，static 修饰的方法中不能使用 this 引用。并且 Java 语法规定，静态成员不能直接访问非静态成员。
省略this前缀只是一种假象，虽然程序员省略了调用jump（）方法之前的this，但实际上这个this依然是存在的。
this（）访问构造方法
this( ) 用来访问本类的构造方法（构造方法是类的一种特殊方法，方法名称和类名相同，没有返回值。详细了解可参考《Java构造方法》一节），括号中可以有参数，如果有参数就是调用指定的有参构造方法。
注意：
this（）不能在普通方法中使用，只能写在构造方法中
在构造方法中使用时，必须使第一条语句。
static关键字：
static成为静态修饰符，修饰类中的成员，被修饰的成员被成为静态成员，也成为类成员，而不用static修饰的成员成为实例成员。
静态成员不依赖于类的特定实例，被类的所有实例共享，就是说 static 修饰的方法或者变量不需要依赖于对象来进行访问，只要这个类被加载，Java 虚拟机就可以根据类名找到它们。
静态变量
类的成员变量可以分为以下两种：
静态变量（或称为类变量），指被 static 修饰的成员变量。
实例变量，指没有被 static 修饰的成员变量。
静态变量与实例变量的区别如下：
1）静态变量
运行时，Java 虚拟机只为静态变量分配一次内存，在加载类的过程中完成静态变量的内存分配。
在类的内部，可以在任何方法内直接访问静态变量。
在其他类中，可以通过类名访问该类中的静态变量。
2）实例变量
每创建一个实例，Java 虚拟机就会为实例变量分配一次内存。
在类的内部，可以在非静态方法中直接访问实例变量。
在本类的静态方法或其他类中则需要通过类的实例对象进行访问。
静态变量在类中的作用如下：
静态变量可以被类的所有实例共享，因此静态变量可以作为实例之间的共享数据，增加实例之间的交互性。
如果类的所有实例都包含一个相同的常量属性，则可以把这个属性定义为静态常量类型，从而节省内存空间。例如，在类中定义一个静态常量 PI。
publicstaticdoublePI=3.14159256;
静态方法
与成员变量类似，成员方法也可以分为以下两种：
静态方法（或称为类方法），指被 static 修饰的成员方法。
实例方法，指没有被 static 修饰的成员方法。
静态方法与实例方法的区别如下：
静态方法不需要通过它所属的类的任何实例就可以被调用，因此在静态方法中不能使用 this 关键字，也不能直接访问所属类的实例变量和实例方法，但是可以直接访问所属类的静态变量和静态方法。另外，和 this 关键字一样，super 关键字也与类的特定实例相关，所以在静态方法中也不能使用 super 关键字。
在实例方法中可以直接访问所属类的静态变量、静态方法、实例变量和实例方法。
在访问非静态方法时，需要通过实例对象来访问，而在访问静态方法时，可以直接访问，也可以通过类名来访问，还可以通过实例化对象来访问。
静态代码块
静态代码块指 Java 类中的 static{ } 代码块，主要用于初始化类，为类的静态变量赋初始值，提升程序性能。
静态代码块的特点如下：
静态代码块类似于一个方法，但它不可以存在于任何方法体中。
静态代码块可以置于类中的任何地方，类中可以有多个静态初始化块。
Java 虚拟机在加载类时执行静态代码块，所以很多时候会将一些只需要进行一次的初始化操作都放在 static 代码块中进行。
如果类中包含多个静态代码块，则 Java 虚拟机将按它们在类中出现的顺序依次执行它们，每个静态代码块只会被执行一次。
静态代码块与静态方法一样，不能直接访问类的实例变量和实例方法，而需要通过类的实例对象来访问。
十、异常处理
异常是程序中的一些错误，但并不是所有的错误都是异常，并且错误有时候是可以避免的。
比如说，你的代码少了一个分号，那么运行出来结果是提示是错误 java.lang.Error；如果你用System.out.println(11/0)，那么你是因为你用0做了除数，会抛出 java.lang.ArithmeticException 的异常。
异常发生的原因有很多，通常包含以下几大类：
用户输入了非法数据。
要打开的文件不存在。
网络通信时连接中断，或者JVM内存溢出。
这些异常有的是因为用户错误引起，有的是程序错误引起的，还有其它一些是因为物理错误引起的。-
要理解Java异常处理是如何工作的，你需要掌握以下三种类型的异常：
检查性异常：最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。
运行时异常： 运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。
错误： 错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。
try-catch-finally语句捕获和处理异常
try
{
要检查语句序列
}
catch（异常类名 形参对象名）
{
异常发生时的处理语句序列
}
finally
{
一定会运行的语句序列
}
Catch 语句包含要捕获异常类型的声明。当保护代码块中发生一个异常时，try 后面的 catch 块就会被检查。
如果发生的异常包含在 catch 块中，异常会被传递到该 catch 块，这和传递一个参数到方法是一样。
© 著作权归作者所有,转载或内容合作请联系作者
没有回复内容