匿名内部类是内部类的一种简写形式，不写名字而已。
使用有个前提是：匿名内部类必须是继承一个类或者实现接口。
格式： new 父类(){里面重写要写的方法}.方法();
事实上，方法前面的一堆相当于是一个子类对象。
通常，匿名内部类中定义的方法最好不要超过3个。因为匿名内部类就是为了简化代码而已，它把1复写父类2建立对象3调用方法 放在一起写了。所以方法一定要少，一般不多于3个。
最常见使用内部类的情况是：需要传一个方法少于三个的接口作为参数时。举例如下：
show(new Inner()
{
public void balabala()
{
Sys("");
}
});
*/
abstract class Abs
{
abstract void method();
}
class Outer
{
int x = 3;
/*
class Inner extends Abs
{
void method()
{
System.out.println("method:"+x);
}
}
*/
public void fun()
{
// new Inner().method();
new Abs() //匿名内部类
{
void method()
{
System.out.println("method:"+x);
}
}.method();
}
}
class AbsDemo
{
public static void main(String[] args)
{
new Outer().fun();
}
}
还可以这样写：
public void fun()
{
// new Inner().method();
Abs in = new Abs()
{
void method()
{
System.out.println("method:"+x);
}
void print()
{
System.out.println("i am a little tired ");
}
}
in.method();
in.print(); //前提是父类中也有这个方法。若没有刚不能这样调用。
}
下面讲的是异常。
异常：程序在运行时出现的不正常情况。
异常也是一种生活中存在的事物，也被描述成了类并封装成对象。
其实就是把一些常见问题封装成了对象，叫异常。
分成两种，严重的一种封装成Error类，不严重的封装成Exception类
对error一般不写针对性代码对其处理。
对exception一般有针对性代码对其处理。
把error和exception向上抽取出共性的东西组成了异常的超类 throwable
偷师：java中为了提高可读性把父类名字写成子类名的后缀，这点很好，比如xxError一看就知道是Error类的子类。
格式：
try{
要被检测的代码
}
catch(异常类 变量){ 处理方法}
finally{一定会执行的语句}
常用对捕获的异常进行的操作：
1 getMessage()
2 printStackTrace()
3 toString()
throws Exception的含意：抛给虚拟机
对多异常的处理：
1、抛出异常时建议声明为更具体的异常，这样方便处理。比如throws AtithmeticException,ArrayIndexOutOfBoundsException
但此时需要用两个catch去处理。发生哪个异常哪个catch去处理，但只会有一个catch被执行。
2、如果声明的几个异常出现继承关系，父类异常放最下面。
3、不要定义多余的catch块。
4、catch中要有具体的解决方法，或者形成异常日志文件。
class Demo
{
int div(int a,int b)throws Exception //在功能上通过关键字声明出该功能可能会出现问题。
{
return a/b;
}
}
class ExDemo
{
public static void main(String[] args)
{
Demo d = new Demo();
try
{
int x=d.div(4,0);
System.out.println("x="+x);
}
catch(Exception e)
{
System.out.println("除零错误");
System.out.println(e.getMessage());
System.out.println(e.toString()); //异常信息：异常名称
e.printStackTrace();//异常名称：异常信息，异常出现的位置。（JVM默认异常处理就是它。）
}
System.out.println("over");
}
}
自定义异常：一些我们项目中特有的而java没有封装的异常。必须是继承自Exception否则没用。
继承的原因：异常类和异常对象都需要被抛出因为它们会导致跳转，它们都具备可抛性，这个可抛性只有throwable类的独有特点，
只有这个体系中的成员才能被throw和throws这两个关键字操作。
throws 和 throw 区别：
1、throws 使用位置在函数上（小括号和大括号之间），throw在函数内
2、throws 后面跟的是异常类，可以跟多个，用逗号隔开。throw 后面跟异常对象。
需求：在本程序中除数不可以为负数。
当函数内部已经出现异常，则必须有解决，常用方法有两种：1在内部try catch处理 2在函数上声明，让调用者处理。
自定义的异常如何定义所属信息？（重写父类中的getMessage方法）
因为父类中都写完了，子类只需要在构造时将异常信息传递给父类，通过super语句，那么就可以通过getMessage方法获取自定义的异常信息了。
所有的函数内抛都必须在函数上声明，一个真香特例是runtimeException可以不这样做。
RunTimeException: 如果在函数内容出现异常，函数上可以不用声明，编译一样通过。
如果在函数上声明异常，调用者可以不用处理，编译一样通过。
class FuShuException extends Exception //定义异常类，注意起名时候后面有后缀（好习惯）
{
/*
private String msg;
FuShuException(String msg)
{
this.msg = msg;
}
public String getMessage()
{
return msg;
}*/
private int key;
FuShuException(String msg,int key)
{
super(msg);
this.key = key;
}
public int getKey()
{
return key;
}
}
class Demo
{
int div(int a,int b )throws FuShuException
{
if(b<0) //注意下面的throw没有s
throw new FuShuException("被除数小于零了呀！",b); //手动通过建立对象抛出自定义异常。
return a/b;
}
}
class Test
{
public static void main(String[] args)
{
Demo d = new Demo();
try
{ int x = d.div(4,-1);
System.out.println("x="+x);
}
catch(FuShuException e)
{
System.out.println(e.toString());
System.out.println("the wrong number is "+e.getKey());
}
System.out.println("over");
}
}