一、内部类（内置类，嵌套类）
将一个类定义在另一个类的里面，对里面那个类就成为内部类。
访问特点：
1.内部类可以直接访问外部类中的成员，包括私有成员。
2.而外部类要访问内部类中的成员必须要建立内部类的对象。
示例：
class Outer
{
     int x = 3;
     class Inner//内部类,因为它在成员位置上时可以用private和static修饰。（只限于在成员位置上）
     {
           void function()
           {
               system.out.println("inner :");
           }
     }
    void method()
    {
         System.out.println(x);
     }
]
在主函数中直接调用内部类成员格式：Outer.Inner in = new Outer().new Inner();
内部类能直接访问外部类是因为：内部类中持有一个外部类引用。写法是：外部类名.this
被static修饰的内部类：只能直接访问外部类中的静态成员。
在主函数中直接访问静态内部类中的非静态成员： new Outer.Inner().function();
在主函数中直接访问静态内部类中的静态成员：Outer.Inner.function();
内部类定义在局部时：不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量。
注：
当内部类中定义了静态成员，该内部类必须是static的。
当外部类中的静态方法访问内部类时，内部类也必须是静态的

二、匿名内部类
1匿名内部类其实就是内部类的简写格式。
2.定义匿名内部类的前提：内部类必须是继承一个类或者实现接口。
3.匿名内部类的格式：new 父类或者接口（）{定义子类的内容}
示例：
abstract class AbsDemo
{
       abstract void show();
}
class Outer
{
       int x =3;
/*
       class Inner extends AbsDemo
       {
                    void show()
                  {
                            system.out.println("method:"+x);
                   }
        }
*/
       public void function()
       {
            //new Inner().show();
                 new AbsDemo()//匿名对象格式，代替上方绿色代码。匿名内部类就是一个匿名子类对象。即带内容的对象
                  {
                    void show()
                  {
                            system.out.println("method:"+x);
                   }                        
                  }.show();
       }
}

三、异常机制
异常：就是程序在运行时出现不正常情况。
1.异常由来：问题也是现实生活中一个具体的事物，也可以通过java的类的形式进行描述。并封装成对象。其实就是java对不正常情况进行描述后的对象体现。
2.问题划分：
严重的，Error：对于error一般不编写针对性的代码对其进行处理。
非严重的，Exception：对于Exception可以使用针对性的处理方式进行处理。
Throwable俩个子类Error 和 Exception，它是所有错误或异常的超类.
3.异常的处理,java提供了特有的语句进行处理。
格式：
try
{ 需要被检测的代码； }
catch（异常类 变量）
{ 处理异常的代码；（处理方式） }
finally
{ 一定会执行的语句；  }
其实jvm默认的异常处理机制，就是在Throwable类中调用printStackTrace方法。打印异常的堆栈跟踪信息。
定义功能时，因为参数的不确定性，会导致问题的发生。所以在功能上通过throws的关键字生命了该功能有可能会出现问题。即抛出异常。
例：int div(int a,int b)throws Exception

4.特殊情况对多异常的处理：
1.声明异常时，建议声明更为具体的异常。这样处理的可以更具体。
2.对方声明抛出几个异常就应该有几个catch。不要定义多余的catch块。
如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面。
5.自定义异常：
自定义异常只能手动抛出，一般情况下。函数内出现异常，函数上需要声明。
因为父类中已经把异常信息的操作都完成了。
所以子类只要在构造时，必须是继承Exception，然后通过super语句将异常信息传递给父类。（可以直接通过getMessage方法获取自定义的异常）
为什么要继承Exception？
异常体系有一个特点：异常类和异常对象都需要被抛出。他们都具备可抛性。这个可抛性是throwable这个体系中的独有特点。只有这个体系中的类和对象才可以被throws和throw操作。
示例：
class FuShuException extends Exception
{
    FuShuException(String msg)
    { super(msg); }
}
6.throw关键字：
throw new FuShuException(); 手动通过Throw关键字抛出一个自定义异常对象。
throws和throw的区别：
throws：使用在函数上，后面跟的异常类。可以跟多个，并用逗号隔开。
throw： 使用在函数内，后跟的是异常类对象。
7.RuntimeExecption：Exception中有一个特殊的子类异常RuntimeExecption（即运行时异常）。如果在函数内抛出该异常，函数上可以不用声明，编译通过。
如果在函数上声明了该异常。调用者可以不用进行处理，编译通过。
之所以不用函数说明，是因为不需要让调用者处理。
当该异常发生，希望程序停止。因为在运行时，出现了无法继续运算的情况，希望停止程序后，对代码进行修正。


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

总结的好好，学习学习

学习学习！

没有第七天吗？

挺细心的

明天开始面向对象的学习，激动ing

加油，天天总结天天进步。

顶                                         

赞一个。。。。。。

学的好快啊   我也是学到第九天，明天才开始抽象类

学习学习 挺好的

两大难点都总结的很好。