匿名内部类是内部类的一种简写形式,不写名字而已。
使用有个前提是:匿名内部类必须是继承一个类或者实现接口。
格式: 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");
}
}