java学习：内部类和异常

java的学习中断了半个多月了，今天算是接着学了。今天学习了内部类和异常，下面是今天的总结。

首先来看内部类。

在一个类中定义另外一个类，这个类就叫做内部类或者内置类(inner class)。

内部类可以让我们将逻辑上的相关的一组类组织起来，并由外部类(outer class)来控制内部类的可见性。

当我们建立了一个inner class时，其对象就拥有了与外部类对象之间的一种关系，这是通过一个特殊的this reference形成的，使得内部类对象可以随意的访问外部类中所有的成员。下面这个图就说明了这个特殊的this reference。

在main函数中声明了一个outer类的对象o，当它调用print方法时，产生了this指针，在print方法中又声明了inner的对象i，当调用i的print方法时，便有了i的this指针。同时，内部类有一个Outer.this这个指针指向outer类的对象，Outer.this这个指针就是特殊的this reference。

内部类不仅可以放在类中，也可以是在一个方法中或者一个语句块中。

在方法中定义的内部类，如果要访问方法中定义的本地变量或方法的参数，则变量必须被声明为final，那么在声明的时候也就要初始化了，只可访问，不可更改。

内部类可以声明为private、protected、abstract或者final。其权限就和这几个修饰符的权限一样了。

同时，内部类还可以声明为static的，但此时就不能再使用外部类的非static的成员变量和非static的成员方法。非static的内部类中的成员不能声明为static的，只有顶层类或static的内部类才可以声明static成员。

说了这么多，但是还不知道为什么要使用内部类。

首先，在内部类中，我们可以随意的访问外部类的成员，还可以让我们更好的组织管理我们的代码，增强代码的可读性。

其次，内部类可以用于创建适配器类，适配器类是用于实现接口的类，使用内部类来实现接口，可以更好的定位与接口关联的方法在代码中的位置。

第三，内部类可以使得有多种方法。比如说现在需要同时继承一个类和实现一个接口，而它们拥有共同的方法，那该如何处理呢？下面看段代码就明白了。

interface Machine
{
void run();
}


class Person
{
void run()
{
System.out.println("run");
}
}


class Robot extends Person
{
private class MachineHeart implements Machine
{
public void run()
{
System.out.println("heart run");
}
}
Machine getMachine()
{
return new MachineHeart();
}
}


class Test
{
public static void main(String[] args)
{
Robot robot=new Robot();
Machine m=robot.getMachine();
m.run();
robot.run();
}
}

这段代码就很好的解决了上述的问题。

在大致了解了内部类后，就开始接触异常了。

当打开一个不村子的文件、网络连接中断、数组下标越界、正在加载的类文件丢失等都会引发异常。

java中定义了两种相关的类，一个是异常类，一个是错误类。异常类定义了程序中遇到的轻微的错误条件；而错误类则定义了程序中不能恢复的严重错误条件，例如内存溢出、类文件格式错误等，这些错误由java运行系统处理，不需要我们去处理。

那么该如何处理异常呢？

java程序在执行过程中如果出现异常，会自动生成一个异常类对象，该异常对象会被提交给java运行时系统，这个过程称为抛出异常。

当java运行时系统接收到异常对象时，会寻找能处理这一异常的代码并把当前异常对象交给其处理，这一过程称为捕获异常。

如果java运行时系统找不到可以捕获异常的方法，则运行时系统将终止，相应的java程序也将退出。

处理异常主要是使用try/catch/finally语句。

对于RuntimeException，通常不需要我们去捕获，这类异常由java运行时系统自动抛出并自动处理。

如果父类中的方法抛出了多个异常，则子类中的覆盖方法要么抛出相同的异常，要么抛出异常的子类，但不能抛出新的异常，当然，出了构造方法外。

我们 可以在声明方法时，声明一个不会抛出的异常，java编译器就会强迫方法的使用者对异常进行处理，这种方法通常用于abstract base class和interface中。

下面还是来看一段代码，熟悉异常的处理。

import java.io.*;
class Excep
{
Excep() throws ArithmeticException
{
}
public int division(int a,int b) throws ArithmeticException,DivisorIsMinusException//Exception
{
//try
//{
if(b<0)
throw new DivisorIsMinusException("Divisor can't be minus");
return a/b;
/*}
catch(ArithmeticException e)
{

e.printStackTrace();
throw new Exception("can't divide by zero");
//throw e;
//return 0;
}*/

}
public int fn1(int a,int b) throws ArithmeticException,DivisorIsMinusException//Exception
{
return division(a,b);
}
}


class ChildExcep extends Excep
{
ChildExcep() throws FileNotFoundException
{
}
public int division(int a,int b) throws ArithmeticException,DivisorIsMinusException
{
return a/b;
}
}
class DivisorIsMinusException extends Exception
{
DivisorIsMinusException(String str)
{
super(str);
}
}
class ExcepTest
{
public static int method1(Excep excep)
{
try
{
return excep.division(5,0);
}
catch(ArithmeticException e)
{
System.out.println(e.toString());
}
catch(DivisorIsMinusException ex)
{
System.out.println(ex.toString());
//System.exit(-1);
//return;
}
return 0;
}
public static void main(String[] args) //throws Exception
{
ChildExcep ce=new ChildExcep();
method1(ce);
Excep excep=new Excep();
try
{
//excep.division(5,0);
excep.fn1(5,-1);
System.out.println("exception");
return;
}

catch(ArithmeticException e)
{
System.out.println(e.toString());
}
catch(DivisorIsMinusException ex)
{
System.out.println(ex.toString());
System.exit(-1);
//return;
}
catch(Exception e)
{
//System.out.println("can't divide by zero");
//System.out.println(e.getMessage());
//System.out.println(e.toString());
e.printStackTrace();
}
finally
{
System.out.println("finally");
}
System.out.println("finish");
}
}

我们再来看下异常的结构。

以上就是今天所学的大致内容，由于心情仍未完全缓过来，所以写的有点乱，学的过程中也总走神，自己思考的有些少了。哎，慢慢来，感情这东西。。。。