内部类和异常处理体系

内部类：

             1、内部类也是一个独立的类，编译后内部类会产生独立的.class文件，并在前面加上 外部类$ 符号

            2、内部类可以直接访问外部类中的成员，（因为内部类中持有一个外部类的引用   外部类.this   ）    外部类. this

            3、内部类声明成静态的，就只能访问外部类的静态成员

   内部类访问规则：

1、外部类访问内部类：    必须先建立内部类对象

                2、外部其他类要访问内部类：    必须指定是那个类的内部类

                        类名 . 内部类  变量=new 外部类（）. new 内部类（）

    静态内部类：

               1、内部类定义在成员位置上，static修饰：    当内部类被static修饰后，只能访问外部类中的static成员

                        外部类访问静态内部类：    new 外部类（）. 内部类（）. 内部类方法（）

               2、当内部类中定义了static静态成员，该内部类也必须是static的

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

    方法内部类：将内部类定义在方法中

                        方法中的内部类要访问局部变量，局部变量要声明为    final     类型

                局部内部类：    就是讲内部类定义在外部类的方法中

                        class Outer外部类 { 

                              void fun()外部类方法  { 

                                   class Inner()方法内部类 { 

                                           void function()内部类方法

                                    }

                                }

                          }

                 注意：

                        1，static是成员修饰符，不能修饰局部

                            所以，方法内部类（局部内部类） 不能修饰方法内部类 

                       2，方法内部类中访问局部变量，局部变量要声明为final最终类型

内部类访问成员变量

Outer
{
	private int x = 3;
	class Inner 
	{	
		int x = 4;
		void function()
		{
			int x =6;
			System.out.println("x="+x);//内部类局部变量 6
			System.out.println("x="+this.x);//内部类成员变量 4
			System.out.println("x="+Outer.this.x);//外部类成员变量 3		
		}
	}
	void method()
	{
		Inner in = new Inner();
		in.function();
	}
}
class InnerFace 
{
	public static void main(String[] args) 
	{
		Outer out = new Outer();
		out.method();
		//Outer.Inner in = new Outer().new Inner();//直接访问内部类成员
		//in.function();
	}
}

执行结果：

重要：

 方法中的内部类能不能访问方法中的局部变量，为什么？

不能，因为内部类也是一个类，它存在与堆内存中，只有当该类的引用 消失后，内部类才会消失。而方法中的局部变量存在与栈内存中，当调用结束后， 即内存中这个属性就会消失，所以内部类的生命周期大于方法中的局部变量生命周期，内部类可能访问到已经消失的属性，所以不能访问

解决方法，在局部变量前加final修饰，此时，局部变量就会存在堆内存中，生命周期跟工程周期一样，此时，内部类就可以访问方法中的局部变量了

   

匿名内部类：

1、没有名字的内部类，就是内部类的简写格式，一般只使用一次

2、匿名内部类就是一个匿名子类对象

想要定义匿名内部类：内部类必须继承一个类或实现一个接口

匿名内部类格式：    new 父类名（接口名）{ 定义子类成员（覆盖父类方法）} . 方法（）

什么时候使用匿名内部类：

一般来说，当接口或者抽象类中的方法在3个以下的时候。考虑使用匿名内部类。以后在你看到一个方法接收的形式参数是一个抽象类或者接口的时候。就可以考虑采用匿名内部类实现。

格式：

         1、直接调用：

                   new  类名或接口（）{

                            重写抽象类或接口中的方法；

                            也可以自定义自己的方法；

                   } . 方法名（）； 

2、使用多态进行调用：

                   父类名（接口） 变量 = new 类名或接口（）{ }；

                   变量 . 方法名（）；

匿名内部类的调用

abstract class AbsDemo
{
	abstract void show();
}
class Outer
{
	int x=3;	
	public void function()
	{
		//匿名内部类
		AbsDemo d = new AbsDemo()
		{
			int num = 9;
			void show()
			{
				System.out.println("num==="+num);
			}
			void abc()
			{
				System.out.println("haha");
			}
		};
		d.show();
		//d.abc();//编译失败
	}
}
class InnerFace
{
	public static void main(String[] args) 
	{
		new Outer().function();
	}
}

执行结果：

异常

概念：

异常，就成程序运行出现的不正常情况

异常处理原则：

功能抛出几个异常，功能调用如果进行try处理，需要与之对应的catch处理代码块

这样的处理有针对性，抛几个就处理几个。

异常处理体系

Throwable

| --- Error

| --- Exception

 

异常问题分两种：

一种严重的：Error，一种不太严重的：Exception

对于Error，一般不写针对性的代码进行处理

对于不太严重的，java对于Exception可以通过针对性的方式进行处理

特殊情况：try对应多个catch时，如果有父类的catch语句块，一定要放在下面。

Throwable中的方法：

         getMessage（）：返回错误的详细消息字符串

         toString（）：返回错误信息的简短描述；包括：全路径类的名字、冒号、getMessage消息字符串

         printStrackTrace（）：将错误信息显示到控制台

 

throw 和throws关键字的区别： 

throw用于抛出异常对象，后面跟的是异常对象；throw用在函数内。 

throws用于抛出异常类，后面跟的异常类名，可以跟多个，用逗号隔开。throws用在函数上。

try、catch、finally分别在什么情况下使用？        

try{}用来定义需要被检测的代码

catch(){}用来处理异常的代码

finally{}中是一定会执行的代码

注意：

finally中定义的通常是关闭资源代码

因为资源必须释放。当执行到System.exit(0)时，finally不会执行。

异常基本处理

class Demo
{
	int div(int a,int b)throws Exception//在功能上通过throws的关键字声明了该功能有可能会出现问题。
	{
		return a/b;
	}
}
class  ExceptionDemo
{
	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)//Exception e = new ArithmeticException();
		{
			System.out.println("除零啦");
			System.out.println(e.getMessage());//  / by zero;
			System.out.println(e.toString());// 异常名称 ： 异常信息。
			e.printStackTrace();//异常名称，异常信息，异常出现的位置。
							//其实jvm默认的异常处理机制，就是在调用printStackTrace方法。
							//打印异常的堆栈的跟踪信息。
		}	
		System.out.println("over");
	}
}

执行结果

多异常处理

class Demo
{
	int div(int a,int b)throws ArithmeticException,ArrayIndexOutOfBoundsException//在功能上通过throws的关键字声明了该功能有可能会出现问题。
	{
		int[] arr = new int[a];
		System.out.println(arr[4]);
		return a/b;
	}
}
class  ExceptionDemo
{
	public static void main(String[] args)
	{
		Demo d = new Demo();
		try
		{
			int x = d.div(2,0);
			System.out.println("x="+x);
		}	
		/*
		catch(Exception e)
		{
			System.out.println("hahah:"+e.toString());
		}
		*/
		catch (ArithmeticException e)
		{
			System.out.println(e.toString());
			System.out.println("被零除了!!");
		}
		catch (ArrayIndexOutOfBoundsException e)
		{
			System.out.println(e.toString());
			System.out.println("角标越界啦！！");
		}	
		System.out.println("over");
	}
}

执行结果

异常分类：编译时异常和运行是异常

特殊：

       Exception中有一个特殊的子类异常：RuntimeException运行时异常

当该异常发生时，希望程序停止，因为出现了无法继续运算的情况，希望程序停止后，对代码进行修正

如果在函数内抛出次异常，函数上可以不声明，编译一样通过

如果函数上声明了该异常，调用者可以不用处理，编译一样通过，因为该异常不需要调用者处理

异常小结：

1.自定义异常: 
 
class 异常类名 extends Exception 
{ 
    public 异常类名(String msg) 
    { 
        super(msg); 
     }
}  
 
2.标识可能抛出的异常: 
 
throws 异常类名1,异常类名2 
 
3.捕获异常: 
try{} 
catch(异常类名 y){} 
catch(异常类名 y){} 
 
4.方法解释 
getMessage() //输出异常的信息 
printStackTrace() //输出导致异常更为详细的信息 

JDK1.7异常处理新特性：

多个catch用一个catch替代

         格式：

                   catch（异常1 | 异常2 | 异常 3.... 变量名）

注意：

1、final、finally、finalized的区别？

final是修饰符

                   修饰类，是一个最终类，不可以被继承

                   修饰方法，是一个最终方法，不能够被重写

                   修饰变量，是一个常量，不能重新赋值

finally：异常处理体系的一部分

                   用于存放最终要执行的代码

                   注意：当遇到System.exit(0)时，不会执行

finalized：它是Object类中的一个方法，JVM的垃圾回收器调用的方法

2、假如，在catch里面有return语句，请问，finally里面的语句还会执行吗？在return前，还是在return后？

         会执行，在return前执行