28、匿名内部类(局部内部类的简写) (重点)
                (1)前提：继承一个类或者实现一个接口
                (注意不要弄混匿名内部类的前提和多态的前提)
                (2)格式：
                        new 父类名或者接口名()
                        {
                                重写父类方法或者实现接口中的方法。
                                也可以自定义其他方法。
                        };
                (3)什么时候定义匿名内部类？
                        匿名内部类只是为了简化书写，匿名内部类有局限，通常定义匿名内部类时，该类方法不超过3个
                (4)匿名内部类的好处和弊端：
                        好处：简化代码书写
                        弊端：
                                不能直接调用自己的特有方法
                                不能执行强转换动作
                                如果该类里面方法较多，不允许使用匿名内部类
29、模板设计模式：
        在定义功能时，功能的一部分是确定的，有一部分是不确定的，而且确定的部分在使用不确定的部分，
        可将不确定的部分暴露出去，由该类的子类去完成。
        如：求一段程序的运行时间例子。
30、异常
        (1)程序运行过程中的不正常现象就叫异常。
        (2)导致程序运行不正常的现象有很多，所以，就有很多的异常对象。
           而这些异常对象存在着共性的内容，所以，可以不断的进行抽取。最终形成了异常的体系结构。
           异常体系的根类是:Throwable
           Throwable：
                |--Error:重大的问题，我们处理不了。也不需要编写代码处理。比如说内存溢出。
                |--Exception:一般性的错误，是需要我们编写代码进行处理的。
                        |--RuntimeException:运行时异常，这个我们也不需要处理。
                                            其实就是为了让他在运行时出问题，然后我们回来修改代码。
        (3)异常的分类               
                异常有两种：
                编译时被检测异常：
                        该异常在编译时，如果没有处理(没有抛也没有try)，编译失败。
                        该异常被标识，代表这可以被处理。
                运行时异常(编译时不检测)
                        在编译时，不需要处理，编译器不检查。
                        该异常的发生，建议不处理，让程序停止。需要对代码进行修正。
        (4)异常体系的特点：
                异常体系中的所有类及其子类对象都具备可抛性。也就是说可以被throw和throws关键字所操作。
        (5)main方法是如何处理异常的。
                A:在main里面编写代码进行处理
                B:交给jvm自己进行处理。采用的是jvm的默认处理方式。
                  其实就是相当于调用了异常对象的printStackTrace()方法。
        (6)Throwable类的学习
                getMessage():获取异常信息，返回字符串。
                toString():获取异常类名和异常信息，返回字符串。
                printStackTrace():获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。
        (7)异常的处理·
                A:try...catch...finally
                基本格式：
                        try
                        {
                                可能出现异常的代码
                        }
                        catch(异常对象)
                        {       
                                异常处理代码
                        }
                        finally
                        {
                                释放资源
                        }
               
                变形格式：
                        try...catch
                        try...catch...catch...
                        try...catch...catch...finally
                **多个异常同时被捕获的时候，记住一个原则：
                        先逮小的，再逮大的。
                **finally:永远被执行，除非退出jvm。System.exit(0);
                        面试题2个。
                        ***：final,finally,finalize区别。
                           final是最终的意思。它可以用于修饰类，成员变量，成员方法。
                           它修饰的类不能被继承，它修饰的变量时常量，它修饰的方法不能被重写。

                           finally:是异常处理里面的关键字。
                           它其中的代码永远被执行。特殊情况：在执行它之前jvm退出。System.exit(0);

                           finalize:是Object类中的一个方法。
                           它是于垃圾回收器调用的方式。

                        ***：假如catch中有return语句， finally里中的代码会执行吗？
                           是在return前，还是在return后呢？
                           会，在return前执行finally里面的代码。
        (8)Exception和RuntimeException的区别
                A:Exception:一般性的错误，是需要我们编写代码进行处理的。       
                B:RuntimeException:运行时异常，这个我们也不需要处理。
                                   其实就是为了让他在运行时出问题，然后我们回来修改代码。
                        在用throws抛出一个的时候，如果这个异常是属于RuntimeException的体系的时候，
                        我们在调用的地方可以不用处理。(RuntimeException和RuntimeException的子类)
                       
                        在用throws抛出一个的时候，如果这个异常是属于Exception的体系的时候，
                        我们在调用的地方必须进行处理或者继续抛出。
        (9)自定义异常
                定义类继承Exception或者RuntimeException
                1,为了让该自定义类具备可抛性。
                2，让该类具备操作异常的共性方法。
                class MyExcepiton extends Exception
                {
                        MyExcepiton(){}

                        MyExcepiton(String message)
                        {
                                super(message);
                        }
                }

                class MyException extends RuntimeException
                {
                        MyExcepiton(){}

                        MyExcepiton(String message)
                        {
                                super(message);
                        }
                }
        (10)throws和throw的区别
                A：有throws的时候可以没有throw。
                   有throw的时候，如果throw抛的异常是Exception体系，那么必须有throws在方法上声明。
                B：throws用于方法的声明上，其后跟的是异常类名，后面可以跟多个异常类，之间用逗号隔开
                   throw用于方法体中，其后跟的是一个异常对象名

学习 学习啊