JAVA基础——内部类与多态、异常

一    多态

        多态可以理解为事物在不同情况下的不同形态。

        例如动物中猫和狗。动物是父类，猫和狗都是动物，他们就体现了动物这个类的不同形态，这就是多态

一、体现

       1、父类的引用指向了自己子类的对象。 

        2、父类的引用也可以接收自己的子类对象。

二、前提

       1、类与类之间必须有关系，要么继承，要么实现。

        2、存在覆盖。父类中有方法被子类重写。

三、特点

1、多态中非静态成员函数的特点

        在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有编译失败。

        在运行时期：参阅对象所属的类中是否有调用的方法。这就是说，如果父类中有一个非抽象的方法，而子类继承后又将其复写了，在多态运行时，父类的引用调用这个同名函数时，被运行的将是父类中的方法。

        简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。

2、多态中成员变量的特点

        无论编译和运行，都参考左边（引用变量所属的类）。如：多态中的父类引用调用成员变量时，如果父类和子类有同名的成员变量，那么被调用的是父类中的成员变量。

3、多态中静态成员函数的特点

        无论编译和运行，都参考左边。也就是父类引用在调用静态同名函数时，被调用的是父类中的静态函数。这是因为，当类一被加载，静态函数就随类绑定在了内存中。此时，不需要创建对象，就可以使用类名直接调用。同时，父类中的静态成员函数一般是不被复写的。

 

二     内部类

一、概述

        将一个类定义在另一个类的里面，对里面那个类就称为内部类。

        当描述事物时，事物的内部还有事物，该事物用内部类来描述。因为内部事物在使用外部事物的内容。如定义一个描述人的类，而手、心脏等都属于人，然它们又有自己的功能描述，这时可以在人这个描述类中，定义一个描述心脏的类，也就是内部类。

        编译时，如果代码中有内部类，生成的class文件中会含有这样的文件：Test$1.class。编译器将会把内部类翻译成用$（美元符号）分隔外部类名和内部类名的常规类文件。这是内部类的一种编译现象。

二、内部类的访问规则

        1、内部类可以直接访问外部类中的成员，包括私有。

              之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式：  外部类名.this。

        2、外部类要访问内部类，必须建立内部类对象。

三、访问格式

1、当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。可以直接建立内部类对象。

        格式：

                 外部类名.内部类名  变量名 =外部类对象.内部类对象；

        如：    Outer.Inner in =new Outer().new Inner();

当内部类在外部类中的成员位置上时，可以被成员修饰符所修饰。比如：

        private：将内部类在外部类中进行封装。 

        static：内部类就局部static的特性。但是当内部类被static修饰后，只能直接访问外部类中的static成员。出现了访问局限。

在外部其他类中，直接访问static内部类的非静态成员的格式为：

        new 外部类名.内部类名（）.方法名（）；

        如：new  Outer.Inner().function();

在外部其他类中，直接访问static内部类的静态成员格式为：

        外部类名.内部类名.方法名（）；

        如：Outer.Inner.function();

注意：

        1）当内部类中定义了静态成员时，该内部类必须是static的。

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

        3）在实际应用中，内部类通常被定义为private，而很少定义为public。

2、内部类定义在局部

        内部类定义在外部类中的某个方法中，创建了这个类型的对象时，且仅使用了一次，那么可在这个方法中定义局部类。

        1）不可以被成员修饰符修饰。如public、private、static等修饰符修饰。它的作用域被限定在了声明这个局部类的代码块中

        2）可以直接访问外部类中的成员，因为还持有外部类中的引用。

注意：内部类不可以访问它所在的局部中非最终变量。只能访问被final修饰的局部变量。

四、匿名内部类

        1、匿名内部类其实就是内部类的简写格式。

        2、定义匿名内部类的前提：

              内部类必须是继承一个类或者实现接口。

              特殊情况：因为所以的类都有一个父类Object，所以在定义时也可以用Object。

        3、匿名内部类的格式：  new父类或者接口(){定义子类的内容}

        4、其实匿名内部类就是一个匿名子类对象。可以理解为带内容的对象。

       

三   异常

一、概述

        1、异常：就是程序在运行时出现不正常情况。

        2、异常由来：问题也是现实生活中一个具体的事物，也可以通过java的类的形式进行描述。并封装成对象。其实就是java对不正常情况进行描述后的对象体现。

        3、程序可能出现的错误或问题

                a、用户输入错误导致的异常：如用户不正常使用程序，输入一些非法参数

                b、设备硬件等发生的错误：如硬盘损坏等

                c、物理限制：如存储空间不足等

                d、代码错误：在程序编写的方法可能不正确，返回错误参数等。

二、异常体系

        有两种对问题的划分方式：

               一种是严重的问题；

              一种是非严重的问题。

         对于严重的问题，java通过Error类进行描述。对Error类一般不编写针对性的代码对其进行处理。

        对于非严重的，java通过Exception类进行描述。对于Exception可以使用针对性的处理方式进行处理。

         无论Error或者Exception都具有一些共性内容。比如：不正常情况的信息，引发原因等。

这也就构成了Java的异常体系：

        Throwable

                |---Error  //通常出现重大问题如：运行的类不存在或者内存溢出等。

                |---Exception //运行时出现的一起情况

                            |---R       untimeException    //特殊异常类，抛时不需要声明

        Exception和Error的子类名都是以父类名作为后缀。

异常体系的特点：

        1、异常体系中的所有类以及建立的对象都具备可抛性。

         2、也就是说可以被throw和throws关键字所操作。

        3、只有异常体系具备这个特点。

三、异常有两种：

        1、编译时被检测异常

              该异常在编译时，如果没有处理(没有抛也没有try)，编译失败。该异常被标识，代表着可以被处理。

         2、运行时异常(编译时不检测)

               在编译时，不需要处理，编译器不检查。该异常的发生，建议不处理，让程序停止。需要对代码进行修正。

四、异常的处理

1、 java提供了特有的语句进行处理。

        try

        {

                 需要被检测的代码。

        }

        catch（异常类  变量）

        {

                 处理异常的代码；（处理方式）

        }

        finally

        {

                 一定会执行的语句；

        }

有三个结合格式：

        a、try

             {

             }

             catch ()

             {

             }

        b、try

             {

             }

             finally

             {

             } 

        c、try

             {

             }

             catch ()

             {

             }

             finally

             {

             } 

注意：

        1）finally中定义的通常是关闭资源代码。因为资源必须释放。

        2）如果在一个功能中，定义了一些必须要执行的代码，可以用try{}finally{}的方式，将一定执行的代码放在finally代码块中。

        3）finally只有一种情况不会执行。当执行到System.exit(0);fianlly不会执行。

2、throw和throws的用法

        throw定义在函数内，用于抛出异常对象。

        throws定义在函数上，用于抛出异常类，可以抛出多个用逗号隔开。

3、调用者对抛出信息的处理

        当在函数内部出现了throw抛出异常对象，那么就必须要给对应的处理动作。要么在内部try catch处理。要么在函数上声明让调用者处理。

        一般情况下，函数内出现异常，函数上需要声明。在功能上通过throws的关键字声明了该功能有可能会出现异常类型。

五、自定义异常

        因为项目中会出现特有的问题，而这些问题并未被java所描述并封装对象。所以对这些特有的问题可以按照java中的面向对象思想。将特有的问题，进行自定义的异常封装。定义类继承Exception或者RuntimeException

        1，为了让该自定义类具备可抛性。

        2，让该类具备操作异常的共性方法。

这就叫做自定义异常。

        当自定义了异常类继承Exception后，如果未在类中定义异常信息，那么通过toString方法打印出来的结果就只有自定义的异常类名，不会显示异常信息。那么应该如何定义异常信息呢？

        要定义自定义异常的信息时，可以使用父类已经定义好的功能。异常信息传递给父类的构造函数。因为父类中已经把异常信息的操作都完成了。所以子类只要在构造时，将异常信息传递给父类通过super语句。那么就可以直接通过getMessage方法获取自定义的异常信息。

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

注：自定义异常：

                必须是自定义类有继承关系，通常继承Exception。

         继承Exception原因：

                 异常体系有一个特点：因为异常类和异常对象都被抛出。他们都具备可抛性。这个可抛性是Throwable这个体系中独有特点。

                 只有这个体系中的类和对象才可以被throws和throw操作。

六、异常的注意事项

        1、问题在内部被解决就不需要声明。

        2、catch是用于处理异常。如果没有catch就代表异常没有被处理，如果该异常是检测时异常。那么必须声明。

        3、在子父类覆盖时：

              a,子类抛出的异常必须是父类的异常的子类或者子集。

              b,如果父类或者接口没有异常抛出时，子类覆盖出现异常，只能try不能抛。