java第八课_内部类，匿名内部类，异常

内部类：

 将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类，嵌套类）。

 当描述事物时，事物的内部还有事物，该事物用内部类来描述。因为内部事务在使用外部事物的内容。

 访问特点：

  l 内部类可以直接访问外部类中的成员，包括私有成员。

  l 外部类要访问内部类中的成员必须要建立内部类的对象。

  l 局部内部类不能被private和static所修饰，因为它们只能修饰成员。

  l 局部内部类可以直接访问外部类中的成员，因为还持有外部类中的引用。但是不可以访问它所在的局部中的变量  ，只能访问被final修饰的局部变量。

 l 当内部类在成员位置上，就可以被成员修饰符所修饰。

  比如：private：将内部类在外部类中进行封装。

  Static:内部类就具备static的特性。只能直接访问外部类中的static成员，出现了访问局限。

 在外部其他类中，直接访问static内部类的非静态成员：

 new outer.Inner().function();

 在外部其他类中，直接访问static内部类的静态成员：

 Outer.inner.function（）；

 当内部类定义了静态成员，该内部类必须是static。

 当外部类中的静态方法访问内部类时，内部类也必须是static的。

 新建内部类对象：

 Outer.inner In = new Outer () .new Inner();

 在有局部变量的时候变量的作用范围：

 之所以可以直接访问外部类中的成员，是因为内部类中持有一个外部类的引用，格式为 外部类名.this 。

-----------------------------------------------------------

匿名内部类：

l 匿名内部类其实就是内部类的简写格式。

l 定义匿名内部类的前提是：内部类必须是继承一个类或者实现接口。

l 匿名内部类格式：  new 父类或者接口（）｛定义子类的内容｝

l 其实匿名内部类就是一个匿名子类对象。而求这个对象有点“胖”可以理解为带内容的对象。

l 匿名内部类中定义的方法最好不超过3个

public class AnonymityInnerClass {
public static void main(String[] args) {
Test.function().method();//此处调用了Inner接口的method方法，所以function方法返回了一个Inner的子类对象。
}
}
interface Inner
{
void method();
}
class Test
{
static Inner function()//通过匿名内部类实现。补足代码。
{
return new Inner()//匿名内部类。
{
public void method()
{
System.out.println("method run");
}
};
}
}

----------------------------------------------------------------------------------

异常：

 就是程序运行时出现的不正常情况。

 异常的好处：

1. 将问题进行封装。

2. 将正常流程代码和问题处理代码相分离，方便于阅读。

异常体系：

l Throwable

  Error

      通常出现重大问题如：运行的类不存在或者内存溢出等。

      不编写针对代码对其处理

  Exception

      在运行时运行出现的一些情况，可以通过try catch finally处理

Exception和Error的子类名都是以父类名作为后缀。

Exception和Error都具有一些共性内容。比如：不正常信息，引发原因等。

异常由来：

问题也是现实生活中一个具体的事物，也可以通过java的类的形式进行描述，并封装成对象。其实就是java对不正常情况进行描述后的对象体现。

异常的处理：

Java提供了特有语句进行处理：

Try

｛

   需要被检测的代码

｝

Catch （异常类  变量）

｛

   处理异常代码：（处理方式）

  （建立catch处理时，catch中一定要定义具体的处理方式。不要简单定义一句e.printStacktrace(),也不要简单的就书写一条输出语句。）

  （异常的常见处理信息：

      getMessage:得到异常信息；

      toString:异常名称：异常信息

      printStackTrace:异常名称，异常信息，异常出现的位置。

      其实JVM默认的异常处理机制，就是在调用此方法，打   印异常的堆栈的跟踪信息）

｝

Finally

｛

    一定会执行的语句。

    这条语句与方法中的语句的区别是：如果在处理中出现异常并且终止程序，那么over不再执行，但是finally是始终执行。

    Finally中定义的通常是关闭资源代码。因为资源必须释放。

    Finally只有一种情况不会执行。当执行到System。Exit(0)；finally不会执行。

｝

三种结合格式：

Try、catch     try、finally   try、catch、finally

对多异常的处理：

  声明异常时，建议声明更为具体的异常。这样处理的可以更具体。

  对方声明几个异常，就对应有几个catch块。不要定义多余的catch块。如果多个catch块中的异常出现继承关系，父类异常catch块放到最下面。

public class ExceptionDemo {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Demo d=new Demo();
try
{
int x=d.div(4, 0);
System.out.println(x);
}
catch(ArithmeticException e)
{
System.out.println(e.toString());
System.out.println("被零除了！");
}
catch(ArrayIndexOutOfBoundsException e)
{
System.out.println(e.toString());
System.out.println("角标越界了！");
}
}


}
class Demo
{
int div(int a,int b)throws ArithmeticException,ArrayIndexOutOfBoundsException
{
int[] arr=new int[4];
System.out.println(arr[3]);
return a/b;
}
}

自定义异常：

定义类继承Exception或者RuntimeException

1. 为了让该自定义类具备可抛性。

2. 让该类具备操作异常的共性方法。

当要定义自定义异常的信息时，可以使用父类已经定义好的功能。异常信息传递给父类的构造函数。

class MyException extends Exception

{

MyException（String mes）

{

Super(mes);

}

}

因为项目中会出现特有的问题，而这些问题并未被java所描述并封装对象。所以对于这些特有的问题可以按照java的对问题封装思想，将特有的问题。进行自定义的异常封装。

在一般情况下，函数内出现异常，函数上需要声明。

当在函数内部出现了throw抛出异常对象，那么就必须要给对应的处理动作。要么在内部try catch处理。要么在函数上声明让调用者处理。

如何定义异常信息呢？

必须是自定义类继承Exception。因为父类中已经把异常信息的操作都完成了。所以子类只要在构造时，将异常信息通过super语句传递给父类。那么就可以直接通过getMessage方法获取自定义的异常信息。

继承exception原因是：异常体系有个特点：因为异常类和异常对象都被抛出。他们都具备可抛型。这个可抛性是Throwable这个体系中独有的特点。只有这个体系中的类和对象才可以被throw和throws操作。

Throw和throws的区别：

Throws用在函数上，  throw用在函数内。

Throws后面跟的异常类。可以跟多个，用逗号隔开。

Throw后跟的是异常对象。

对于异常分为两种：

编译时被检测的异常。

该异常在编译时，如果没有处理（没有抛出也没有try），编译失败。

该异常被标识，代表这可以被处理。

编译时不被检测的异常。（运行是异常。RuntimeException以及其子类）

在编译时，不需要处理，编译器不检查。

该异常的发生，建议不处理，让程序停止，需要对代码进行修正。

Exception中有一个特殊的子类异常RuntimeException运行是异常。

如果在函数内容抛出该异常类，函数上可以不用声明，编译一样通过。

如果在函数上声明了该异常，调用者可以不用进行处理，编译一样通过。

之所以不用在函数声明，是因为不需要让调用者处理。当该异常发生，希望程序停止，因为在运行时，出现了无法继续运算的情况，希望停止程序后对代码进行修正。

所以说，自定义异常时：如果该异常的发生，无法在继续运算时进行运算，就让自定义异常继承RuntimeException。

异常在子父类覆盖中的体现：

1. 子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类的异常或者该异常的子类。

2. 如果父类方法抛出多个异常，那么子类在覆盖方法时，只能抛出父类异常的子类。

3. 如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也可以抛出异常。如果子类方法发生了异常。就必须要进行try处理，绝对不能抛出。

异常的练习：

public class ComputerDemo {


/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Teacher tea=new Teacher("毕老师");
try {
tea.prelect();
} catch (NoplanException e) {
// TODO Auto-generated catch block
System.out.println("换老师或放假");
}

}
}
class BluescreenException extends Exception
{
private static final long serialVersionUID = 1L;
BluescreenException(String message) 
{
super(message);
}
}
class SmokeingException extends Exception
{
private static final long serialVersionUID = 1L;
SmokeingException(String message)
{
super(message);
}
}
class NoplanException extends RuntimeException
{
private static final long serialVersionUID = 1L;
NoplanException(String message)
{
super(message);
}
}
class Computer
{
private int state=2;
public void run()throws BluescreenException,SmokeingException
{
if(state==2) 
throw new BluescreenException("蓝屏了");
if(state==3)
throw new SmokeingException("冒烟了");
System.out.println("电脑运行");
}
public void reset()
{
state=1;
System.out.println("电脑重启");
}
}
class Teacher
{
private String name;
private Computer cm;
Teacher(String name)
{
this.name=name;
cm=new Computer();
}
public void prelect()
{
try 
{
cm.run();

} 
catch (BluescreenException e)
{
System.out.println(e.toString());
cm.reset();
}
catch(SmokeingException e)//冒烟异常，teacher无法处理。抛出。
{
System.out.println(e.toString());
test();
throw new NoplanException("课时无法继续");//不能处理的异常抛出。
//test();//写到RuntimeException后面的语句无法执行到，会包异常。
}
System.out.println(name+"讲课");
}
public void test()
{
System.out.println("练习");
}
}