JAVA基础
6.内部类、异常处理
6.1什么是内部类？内部类有几种？每一中内部类如何表示有那些些特征？
将一个类定义在另一个类里面，形成了包含关系。
内部类–被包含的类
外部类–包含内部类的类。
内部类一共有三种：成员内部类、静态内部类、方法内部类、匿名内部类
成员内部类:
格式：
public class 外部类{
public class 成员内部类{
}
}在这里我们可以认为成员内部类就相当于外部类中的一个成员变量/实例方法。
A.成员内部类中不能定义静态变量和静态方法。
B.外部类的静态方法是不能访问成员内部类的。
C.其他的类中如果想访问成员内部类中的变量和方法，就得先创建外部类对象。
1.成员内部类中的变量和方法的调用关系。
- 成员内部类的构造方法中可以访问成员内部类实例变量/成员内部类的实例方法,默认this.,可以省略this.
- 成员内部类的构造方法中可以访问成员内部类中其他的构造方法,通过new访问
- 成员内部类的实例方法中中可以访问成员内部类实例变量/成员内部类的实例方法,默认this.,可以省略this.
- 成员内部类的实例方法中中可以访问成员内部类构造方法,通过new访问
2.成员内部类中的方法访问外部类中的变量和方法
- 成员内部类的构造方法中可以访问外部类的实例变量/外部类的实例方法，默认外部类的类名.this,可以省略外部类的类名.this。
- 成员内部类的构造方法中可以访问外部类的类变量/类方法，默认类名访问，也可以外部类的类名.this，可以省略类名/外部类的类名.this。
- 成员内部类的构造方法中可以访问外部类的构造方法，通过new访问。
- 成员内部类的实例方法中可以访问外部类的实例变量/外部类的实例方法，默认外部类的类名.this,可以省略外部类的类名.this。
- 成员内部类的实例方法中可以访问外部类的类变量/类方法，默认类名访问，也可以外部类的类名.this，可以省略类名/外部类的类名.this。
- 成员内部类的实例方法中可以访问外部类的构造方法，通过new访问。
3.外部类中的方法访问成员内部类中的变量和方法 - 外部类的构造方法/实例方法中可以访问成员内部类的构造方法【new】,实例变量/实例方法【对象调用】
- 外部类的类方法中不能访问成员内部类。
- 其他类中访问成员内部类中的变量和方法
其他中可以访问成员内部类，先创建外部类对象，然后在创建内部类对象
例如：
package com.click369.test1;
//外部类
public class TestClass3 {
//InnerClass--成员内部类
public class InnerClass{
//成员内部类的实例变量
public int innerid=1001;
//成员内部类的构造方法
public InnerClass(){
}
//成员内部类的实例方法
public void test1(){
}
}
}package com.click369.test1;
public class OtherClass {
public OtherClass(){
//TestClass3.InnerClass inner=new TestClass3().new InnerClass();
TestClass3 t3=new TestClass3();
TestClass3.InnerClass inner=t3.new InnerClass();
System.out.println(inner.innerid);
inner.test1();
}
public void testOther(){
TestClass3.InnerClass inner=new TestClass3().new InnerClass();
//TestClass3 t3=new TestClass3();
//TestClass3.InnerClass inner=t3.new InnerClass();
System.out.println(inner.innerid);
inner.test1();
}
public static void testStaticOther(){
TestClass3.InnerClass inner=new TestClass3().new InnerClass();
//TestClass3 t3=new TestClass3();
//TestClass3.InnerClass inner=t3.new InnerClass();
System.out.println(inner.innerid);
inner.test1();
}
}静态内部类:
静态内部类是 static 修饰的内部类，这种内部类的特点是：
1、 静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问
2、 如果外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员
3、 创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名= new 内部类();
示例代码：
public class HelloWorld {
// 外部类中的静态变量score
private static int score = 84;
// 创建静态内部类
public static class SInner {
// 内部类中的变量score
int score = 91;
public void show() {
System.out.println("访问外部类中的score：" + HelloWorld.score );
System.out.println("访问内部类中的score：" + score);
}
}
// 测试静态内部类
public static void main(String[] args) {
// 直接创建内部类的对象
SInner si=new SInner();
// 调用show方法
si.show();
}
}方法内部类—在这里我们可以认为方法内部类就相当于方法中的一个局部变量:
将java类定义在某一个方法中。
1、定义方法内部类的时候没有访问修饰符
2.方法内部类中不能出现类变量和类方法
3.方法内部类中的构造方法/实例方法，可以访问本方法中的局部变量，jdk8.0之前需要使用final修饰局部变量，包括参数
4方法内部类中的构造方法/实例方法，可以访问外部类的实例变量/实例方法，默认外部类类名.this. , 可以省略外部类类名.this.
5.方法内部类中的构造方法/实例方法，可以访问外部类的类变量/类方法，默认外部类类名，也可以外部类类名.this. ,可以省略外部类类名/外部类类名.this.
6.定义该方法内部类的方法中可以访问这个方法内部类中的变量和方法，对象访问
7.外部类中的方法中是不能访问方法内部类的。【方法内部类当于方法中的一个局部变量】
例如：
package com.click369.test2;
import com.click369.test1.TestClass2.InnerClass;
public class TestClass {
//外部类的实例变量
public int testid=1000;
//外部类的类变量
public static String testname="lisi";
//外部类的构造方法
public TestClass(){
}
//外部类的实例方法
public void dox(){
//外部类中的方法中是不能访问方法内部类的。
//InnerClass inner=new InnerClass();
}
//外部类的类方法
public static void doxStatic(){
}
public void test1(double num2){
//test1方法中的局部变量
int num1=100;
//方法内部类---就相当于本方法中的局部变量
//A 定义方法内部的时候没有访问修饰符
//B 方法内部类中不能出现类变量和类方法
//C 方法内部类可以访问本方法中的局部变量，jdk8.0之前需要使用final修饰局部变量，包括参数
class InnerClass{
//方法内部类中的实例变量
public int innerid=1001;
//方法内部类中不能有类变量
//public static String innername="1001";
//方法内部类中的构造方法
public InnerClass(){
//方法内部类中的构造方法,可以访问本方法中的局部变量,jdk8.0之前需要使用final修饰局部变量，包括参数
System.out.println(num1);
System.out.println(num2);
//方法内部类中的构造方法,可以访问外部类的实例变量/实例方法,默认外部类类名.this. , 可以省略外部类类名.this.
System.out.println(TestClass.this.testid);
System.out.println(testid);
TestClass.this.dox();
dox();
//方法内部类中的构造方法,可以访问外部类的类变量/类方法,默认外部类类名 ,
//也可以外部类类名.this. ,可以省略外部类类名/外部类类名.this.
System.out.println(TestClass.testname);
System.out.println(TestClass.this.testname);
System.out.println(testname);
TestClass.doxStatic();
TestClass.this.doxStatic();
doxStatic();
}
//方法内部类中的实例方法
public void innerMethod(){
//方法内部类中的实例方法,可以访问本方法中的局部变量,jdk8.0之前需要使用final修饰局部变量，包括参数
System.out.println(num1);
System.out.println(num2);
//方法内部类中的实例方法,可以访问外部类的实例变量/实例方法,默认外部类类名.this. , 可以省略外部类类名.this.
System.out.println(TestClass.this.testid);
System.out.println(testid);
TestClass.this.dox();
dox();
//方法内部类中的实例方法,可以访问外部类的类变量/类方法,默认外部类类名 ,
//也可以外部类类名.this. ,可以省略外部类类名/外部类类名.this.
System.out.println(TestClass.testname);
System.out.println(TestClass.this.testname);
System.out.println(testname);
TestClass.doxStatic();
TestClass.this.doxStatic();
doxStatic();
}
//方法内部类中不能有类方法
//public static void innerStaticMethod(){}
}
//在定义该方法内部类的方法中，访问方法内部类中的变量和方法,只能对象访问
InnerClass inner=new InnerClass();
System.out.println(inner.innerid);
inner.innerMethod();
}
}匿名内部类—类/抽象类/接口的子类:
没有名字的内部类
1.继承式的匿名内部类
例如：
package com.click369.test3;
public class TestMain {
public static void main(String[] args) {
//调用MyClass中的实例方法
MyClass mc=new MyClass();
//当一个方法的参数是抽象类类型的时候，可以是传递子类对象、上转型对象
//子类对象、上转型对象在创建的时候需要独立构建一个子类。
//如果我偏不构建这个子类，还想调用这个参数是抽象类类型的方法,怎么办？？？？？
//可以使用匿名内部类的结构完成对子类的构建，只是现在构建出来的这个子类没有名称
//所以才叫匿名内部类
mc.myTest(new TestClass(){
@Override
public void testAbstractMethod() {
System.out.println("重写抽象类中的抽象方法");
}
});
/*
* 匿名内部类
new TestClass(){
@Override
public void testAbstractMethod() {
}
}
上面的这种结构就是一个匿名内部类，它代表TestClass类的子类，只是这个子类没有名字
*/
//优点：可以有效的减少类的创建
//缺点：不利于程序的阅读和理解
}
}2.接口式的匿名内部类
例如：
package com.click369.test4;
public class TestMain {
public static void main(String[] args) {
//调用MyClass这个普通类中的实例方法
MyClass mc=new MyClass();
//当一个方法的参数为接口类型是，我们可以传递接口的子类对象/接口回调对象
//子类对象/接口回调对象,都需要构建一个独立的子类。
//如果我偏不构建这个子类，还想调用这个参数是接口类型的方法,怎么办？？？？？
//可以使用匿名内部类的结构完成对接口子类的构建，只是现在构建出来的这个接口的子类没有名称
//所以才叫匿名内部类
mc.dox(new MyInterface() {
@Override
public void test1() {
System.out.println("重写接口的抽象方法");
}
});
/*
* new MyInterface() {
@Override
public void test1() {
System.out.println("重写接口的抽象方法");
}
}
上面的这种结构就是一个匿名内部类，它代表MyInterface接口的子类，只是这个接口子类没有名字
*/
//优点：可以有效的减少类的创建
//缺点：不利于程序的阅读和理解
}
}6.2异常类的体系结构？Error和Exception的区别？
1.任何人所写的程序都有可能出现异常，就像人会生病一样，程序出现异常是一种正常现象。
2.程序运行的时候可能出现的一些不正常的现象就是异常【Exception】。【可纠正，可避免】【感冒发烧】
3.程序运行的时候可能出现的一些不可回避的问题就是错误【Error】。【不可纠正】【癌症晚期】
4.java中的异常【Exception】和错误【Error】都是Throwable的子类。
public class Exception extends Throwable{}
public class Error extends Throwable{}
Throwable是java中异常处理类的顶级类。
6.3运行时异常与非运行时异常？
异常【Exception】有2大类构成
1.运行时异常—程序编写的时候没有异常，在运行的时候才会出现的异常
2.非运行时异常—我们在编写程序的时候，就已经出现的异常。
6.4如何处理异常？Try{}catch(){} throws throw finally
使用try{}catch(异常类型){}捕获处理异常。
例如：
package com.click369.test1;
public class TestMain {
public static void main(String[] args) {
int a=10;
int b=0;
int c=0;
c=a/b;
System.out.println("c=="+c);
}
}运行结果：
当我们没有使用try{}catch(){}捕获处理异常的时候，默认java程序会将这个程序中的异常输出到控制台上。
例如：
package com.click369.test1;
public class TestMain {
public static void main(String[] args) {
try{
int a=10;
int b=0;
int c=a/b;
System.out.println("c=="+c);
}catch(Exception e){
System.out.println("处理异常的程序");
}
}
}当我们使用try{}catch(){}捕获处理异常以后，那么程序出现异常以后会执行我们的异常处理程序。
例如：
package com.click369.test1;
public class TestMain {
public static void main(String[] args) {
try{
int a=10;
int b=0;
int c=a/b;
System.out.println("c=="+c);
}catch(Exception e){
//打印堆栈异常信息到控制台
e.printStackTrace();
}
}
}当我们不想处理这个异常的时候，也可以通过try{}catch(){}将异常信息输出到控制台。
e.printStackTrace();//打印堆栈异常信息到控制台
结构：
try{
可能出现异常的java代码
}catch(异常类型){
捕获,处理异常
}
try{}catch(){}捕获处理异常的过程：
将可能出现异常的java代码使用try{}包围，当try{}中的java代码出现异常，程序就会立刻停止运行，转而执行try{}后面的catch(异常类型){}中的内容，catch块就是书写处理异常的代码。
1.try{}catch(异常类型){}中的catch中的异常类类型，往往是需要一个具体的异常类型。
例如上面的实例中输出的“java.lang.ArithmeticException”就是一个除数为0的具体异常类型
例如：
package com.click369.test1;
public class TestMain {
public static void main(String[] args) {
try{
int a=10;
int b=0;
int c=0;
c=a/b;
System.out.println("c=="+c);
}catch(ArithmeticException th){
System.out.println("catch块捕获处理异常");
//打印堆栈异常信息
th.printStackTrace();
}
}
}但是我们往往不知道这种具体的异常类型是什么，我们就可以使用Exception或Throwable代替具体异常类型。
package com.click369.test1;
public class TestMain {
public static void main(String[] args) {
try{
int a=10;
int b=0;
int c=0;
c=a/b;
System.out.println("c=="+c);
}catch(Throwable th){
System.out.println("catch块捕获处理异常");
//打印堆栈异常信息
th.printStackTrace();
}
}
}或者
package com.click369.test1;
public class TestMain {
public static void main(String[] args) {
try{
int a=10;
int b=0;
int c=0;
c=a/b;
System.out.println("c=="+c);
}catch(Exception e){
e.printStackTrace();
}
}
}为什么可以使用Exception或Throwable代替具体异常类型？
Exception是所有具体异常类型的父类，Throwable是Exception的父类。
2.一个try{}后面可以出现多个catch(异常类型){}。当出现多个catch(异常类型){}的时候根据catch中的异常类型按照异常类型的级别从小到大排列。
区分异常类型的级别大小，看异常类型的继承关系
Throwable异常的顶级类，有一个子类Exception，Exception有很多的子类 ArithmeticException 是Exception众多子类中的一个。
由小到大的级别排列：
ArithmeticException Exception Throwable
Public class Throwable{
}
Public class Exception extends Throwable{
}
Public class ArithmeticException extends Exception {
}
例如：
package com.click369.test1;
public class TestMain {
public static void main(String[] args) {
try{
int a=10;
int b=0;
int c=0;
c=a/b;
System.out.println("c=="+c);
}catch(ArithmeticException e){
e.printStackTrace();
}catch(Exception e){
e.printStackTrace();
}catch(Throwable th){
th.printStackTrace();
}
}
}3.finally{}块出现在最后一个catch块的后面，程序有没有异常都会被执行的部分。
例如：
package com.click369.test1;
public class TestMain {
public static void main(String[] args) {
try{
int a=10;
int b=1;
int c=0;
c=a/b;
System.out.println("c=="+c);
}catch(ArithmeticException e){
e.printStackTrace();
}catch(Exception e){
e.printStackTrace();
}catch(Throwable th){
th.printStackTrace();
}finally{
System.out.println("程序有没有异常都要执行的部分");
}
}
}4.在方法定义部分，使用throws 异常类型，声明该方法抛出异常。谁调用这个方法谁就要
处理这个方法抛出的异常。什么位置调用，什么位置处理。
例如：
package com.click369.test1;
public class TestClass {
//在方法定义部分，使用throws 异常类型，声明该方法抛出异常。
public int getValue()throws Exception{
int a=10;
int b=0;
int c=0;
c=a/b;
return c;
}
}package com.click369.test1;
public class TestMain {
public static void main(String[] args){
try{
//谁调用这个方法谁就要,处理这个方法抛出的异常。什么位置调用，什么位置处理。
TestClass tc=new TestClass();
tc.getValue();
}catch(Exception e){
e.printStackTrace();
}
//谁调用这个方法谁就要,处理这个方法抛出的异常。什么位置调用，什么位置处理。
TestClass tc1=new TestClass();
tc1.getValue();
}
}package com.click369.test1;
public class TestMain {
public static void main(String[] args)throws Exception{
//谁调用这个方法谁就要,处理这个方法抛出的异常。什么位置调用，什么位置处理。
TestClass tc1=new TestClass();
tc1.getValue();
}
}当程序出现异常以后，有两种做法
- 我们自己使用try{}catch(){}捕获处理异常
- 使用throws 声明异常从方法上抛出，谁使用这个带有异常的方法，谁就处理这个方法的异常。
5.手动引发异常throw 异常对象。
6.自定义异常—java没有提供的异常类型，在应用的时候，我们根据自己的需求自己定义产生的一个异常类型。
①Throwable是java中异常的顶级类。
②在Throwable类下派生出异常【Exception类】和错误【Error类】。
③由于错误【Error类】我们无法处理，所我们不学。
④异常【Exception类】所有异常类的父类。
通过新建一个java类继承Exception类/Throwable类，就可以做一个自定义异常。
例如：
package com.click369.test3;
//继承Exception类/Throwable类,就可以做一个自定义异常.
public class MyTestException extends Exception{
/**
* 创建自己的构造方法，通过参数提供异常信息
* @param exceptioninfo
*/
public MyTestException(String exceptioninfo){
//调用父类的构造方法去输出异常信息
super(exceptioninfo);
}
}package com.click369.test3;
public class MyArray {
private int len=0;
public MyArray(int len)throws MyTestException{
this.len=len;
cheack();
}
//检查数组大小的方法
public void cheack()throws MyTestException{
if(len<0){
//手动引发异常throw 异常对象
throw new MyTestException("数组大小不能为负数!");
}
}
//得到一个字符数组
public char[] getCharArray(){
char chararray[]=new char[len];
return chararray;
}
}package com.click369.test3;
public class TestMain {
public static void main(String[] args) throws MyTestException{
MyArray my=new MyArray(-12);
char array[]=my.getCharArray();
}
}运行结果：
Exception in thread “main” com.click369.test3.MyTestException: 数组大小不能为负数!
at com.click369.test3.MyArray.cheack(MyArray.java:13)
at com.click369.test3.MyArray.(MyArray.java:7)
at com.click369.test3.TestMain.main(TestMain.java:6)
com.click369.test3.MyTestException–我们自己定义的异常类型
Exception in thread “main” com.click369.test3.MyTestException: 数组大小不能为负数!
at com.click369.test3.MyArray.cheack(MyArray.java:13)
at com.click369.test3.MyArray.(MyArray.java:7)
at com.click369.test3.TestMain.main(TestMain.java:6)
上面的输出内容就是程序运行是产生的堆栈异常信息，
com.click369.test3.MyTestException-------异常类型
“数组大小不能为负数!”------异常提示信息【出现错误的原因】
at com.click369.test3.MyArray.cheack(MyArray.java:13)
at com.click369.test3.MyArray.(MyArray.java:7)
at com.click369.test3.TestMain.main(TestMain.java:6)
出现异常的位置
例如：判断整数的实例
package com.click369.test4;
import java.util.Scanner;
public class MyClass {
public int getIntNum(){
int intnum=0;
Scanner read=new Scanner(System.in);
System.out.println("请输一个整数:");
intnum=read.nextInt();
return intnum;
}
}package com.click369.test4;
public class TestMain {
public static void main(String[] args) {
MyClass mc=new MyClass();
int intnum=mc.getIntNum();
System.out.println("年龄是=="+intnum);
}
}运行结果:
请输一个整数:
as
Exception in thread “main” java.util.InputMismatchException
at java.util.Scanner.throwFor(Scanner.java:864)
at java.util.Scanner.next(Scanner.java:1485)
at java.util.Scanner.nextInt(Scanner.java:2117)
at java.util.Scanner.nextInt(Scanner.java:2076)
at com.click369.test4.MyClass.getIntNum(MyClass.java:27)
at com.click369.test4.TestMain.main(TestMain.java:9)
输入一个字符串类型，就会抛出InputMisMatchException异常。
public int getIntNum(){
int intnum=0;
Scanner read=new Scanner(System.in);
System.out.println("请输一个整数:");
try{
intnum=read.nextInt();
}catch(InputMismatchException e){
System.out.println("您输入的不是一个整数，请重新输入!");
intnum=getIntNum();
}
return intnum;
}运行结果：
Java异常处理的总结：
1、不要丢弃异常，捕获异常后需要进行相关处理。如果用户觉得不能很好地处理该异常，就让它继续传播，传到别的地方去处理，或者把一个低级的异常转换成应用级的异常，重新抛出
2、catch语句应该指定具体的异常类型。不能把不该捕获的异常也捕获了
3、在finally里面释放资源。如果finally里面也会抛出异常，也一样需要使用try…catch处理
4、不要把大量的代码塞在try…catch块里面，分离各个可能出现异常的语句并分别捕获异常
5、由于异常可能导致输出的数据不完整，因此用户需要作出相对应的处理，至少应该提示该数据的不完整
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持脚本之家。
6.5常见的异常？
1、常见异常总结图
2、java中异常分类
Throwable类有两个直接子类：
（1）Exception：出现的问题是可以被捕获的
（2）Error：系统错误，通常由JVM处理
3、被捕获的异常分类
（1）Check异常: 派生自Exception的异常类，必须被捕获或再次声明抛出
（2）Runtime异常：派生自RuntimeException的异常类。使用throw语句可以随时抛出这种异常对象 throw new ArithmeticException(…);
二、发生异常的原因
1、用户输入了非法数据。
2、要打开的文件不存在。
3、网络通信是连接中断
4、JVM内存溢出
三、java程序中几种常见的异常以及出现此异常的原因
1、java.lang.NullpointerException(空指针异常)
原因：这个异常经常遇到，异常的原因是程序中有空指针，即程序中调用了未经初始化的对象或者是不存在的对象。
经常出现在创建对象，调用数组这些代码中，比如对象未经初始化，或者图片创建时的路径错误等等。对数组代码
中出现空指针，是把数组的初始化和数组元素的初始化搞混淆了。数组的初始化是对数组分配空间，而数组元素的
初始化，是给数组中的元素赋初始值
2、 java.lang.ClassNotFoundException（指定的类不存在）
原因：当试图将一个String类型数据转换为指定的数字类型，但该字符串不满足数值型数据的要求时，就抛出这个异
常。例如将String类型的数据"123456"转换为数值型数据时，是可以转换的的。但是如果String类型的数据中包含了
非数字型的字符，如123*56，此时转换为数值型时就会出现异常。系统就会捕捉到这个异常，并进行处理
3、java.lang.ClassNotFoundExceptio（指定的类不存在）
原因：是因为类的名称和路径不正确，通常都是程序试图通过字符串来加载某个类的时候可能会引发异常。例如：
调用Class.forName()、或者调用ClassLoad的finaSystemClass()、或者是LoadClass()时出现异常
4、java.lang.IndexOutOfBoundsException（数组下标越界异常）
原因：查看程序中调用的数组或者字符串的下标值是不是超出了数组的范围，一般来说，显示调用数组不太容易出这
样的错，但隐式调用就有可能出错了，还有一种情况，是程序中定义的数组的长度是通过某些特定方法决定的，不是
事先声明的，这个时候可以先查看一下数组的length，以免出现这个异常
5、java.lang.IllegalArgumentException（方法的参数错误）
例如g.setColor(int red,int green,int blue)这个方法中的三个值，如果有超过２５５的会出现这个异常，如果程
序中存在这个异常，就要去检查一下方法调用中的参数传递或参数值是不是有错
6、java.lang.IllegalAccessException（没有访问权限）
当程序要调用一个类，但当前的方法即没有对该类的访问权限便会出现这个异常。如果程序中用了Package的情况下
有可能出现这个异常
7、java.lang.ArithmeticException（数学运算异常）
当数学运算中出现了除以零这样的运算就会出这样的异常。
8、java.lang.ClassCastException（数据类型转换异常）
当试图将对某个对象强制执行向下转换，但该对象又不可转换或又不可转换为其子类的实例时将出现该异常
9、 java.lang.FileNotFoundException（文件未找到异常）
当程序打开一个不存在的文件来进行读写时将会引发该异常。该异常由FileInputStream,FileOutputStream,
RandomAccessFile的构造器声明抛出，即使被操作的文件存在，但是由于某些原因不可访问，比如打开一个
只有只读权限的文件并向其中写入数据，以上构造方法依然会引发异常
10、java.lang.ArrayStoreException（数组存储异常）
当试图将类型为不兼容类型的对象存入一个Object[]数组时将引发异常
11、java.lang.NoSuchMethodException（方法不存在异常）
当程序试图通过反射来创建对象，访问(修改或读取)某个方法，但是该方法不存在就会引发异常。
12、 java.lang.EOFException（文件已结束异常）
当程序在输入的过程中遇到文件或流的结尾时，引发异常。因此该异常用于检查是否达到文件或流的结尾
13、java.lang.InstantiationException（实例化异常）
当试图通过Class的newInstance()方法创建某个类的实例,但程序无法通过该构造器来创建该对象时引发。
Class对象表示一个抽象类，接口，数组类，基本类型 。该Class表示的类没有对应的构造器。
14、java.lang.InterruptedException（被中止异常）
当某个线程处于长时间的等待、休眠或其他暂停状态，而此时其他的线程通过Thread的interrupt方法终止该线程时抛出该异常。
15、java.lang.CloneNotSupportedException （不支持克隆异常）
当没有实现Cloneable接口或者不支持克隆方法时,调用其clone()方法则抛出该异常
16、java.lang.OutOfMemoryException （内存不足错误）
当可用内存不足以让Java虚拟机分配给一个对象时抛出该错误
17、java.lang.NoClassDefFoundException （未找到类定义错误）
当Java虚拟机或者类装载器试图实例化某个类，而找不到该类的定义时抛出该错误
