java学习:内部类和异常

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


首先来看内部类。

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

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

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

java学习:内部类和异常_第1张图片

在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");
}
}

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

java学习:内部类和异常_第2张图片


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


你可能感兴趣的:(java,exception,String,Class,interface,reference)