多态

       多态

       1.1 Abstract抽象类
       1.2 Interface接口
       1.3 多态
       1.4 模版设计模式
       1.5 抽象类与接口的区别
       1.6 什么时候使用抽象类，什么时候使用接口
       1.7 构造代码块儿
      来吧，准备动手整吧，趁着还没有迷糊之前，把知识点过一遍，要不会儿又该犯困写不出来了。
  
       1.1 Abstract抽象类
             抽象：笼统，模糊，看不懂！不具体。
              1.1.1特点
                      1，  方法只有声明没有实现时，该方法就是抽象方法，需要被abstract修饰。抽象方法必须定义在抽象类中。该类必须也被abstract修饰。

                      2，  抽象类不可以被实例化，为什么？

                 因为调用抽象方法没意义。没有方法体。

                     3，  抽象类必须有其子类覆盖了所有的抽象方法后，该子类才可以实例化，否则，这个子类还是抽象类。

             1.1.2 抽象类中有构造函数吗？
                     有，用于给子类对象进行初始化。            
             1.1.3 抽象类可以不定义抽象方法吗？
                     可以的。但是很少见，目的就是不让该类创建对象。AWT的适配器对象就是这种类。 通常这个类中的方法有方法体，但是却没有内容。            
             1.1.4抽象关键字不可以和哪些关键字共存？

                     private不行。如果私有的话，子类如果要是覆盖父类方法的话是不知道私有方法的。

                     Static 不行。如果成员变静态的话就不需要对象，直接类名调用就行，但是调用是没有任何意义。

                             final 不行

             1.1.5 抽象类和一般类的异同点？
                     相同点：抽象类和一般类都是用来描述事物的，都在内部定义了成员。

                     不同点：

                  1，  一般类：有足够的信息描述事物。

           抽象类：描述事物的信息有可能不足。

                  2，  一般类：中不能定义抽象方法，只能定义非抽象方法。

           抽象类：中可定义抽象方法，同事也可以定义非抽象方法。

                  3，  一般类：可以被实例化。

                      抽象类：不可以被实例化。
             1.1.6 抽象类一定是个父类吗？
                     是的。因为需要子类覆盖其方法后才可以对子类实例化。            
             1.1.7 抽象类和接口的异同点：
                     相同点：都是不断向上抽取而来的。

            不同点：

                              1，抽象类需要被继承，而且只能单继承。

                 接口需要被实现，而且可以多实现。

                              2， 抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法。

                接口中只能定义抽象方法，必须由子类去实现。

                              3，  抽象类的继承，是is a关系，在定义该体系的基本共性内容。

                接口的实现是like a 关系，在定义体系额外的功能。

            1.1.8 Final关键字
                    final标记的类不能被继承。

                    final标记的方法不能被子类重写。

                    final标记的变量即为常量，只能赋值一次。注意引用数据类型和基本数据类型的区别。

                    使用public static final共同修饰的常量就是全局常量。通常全部字母大写。

       1.2 Interface接口
             接口是一种特殊的抽象类，接口中声明的所有方法都是抽象的            
              使用interface关键字定义一个接口。
             定义接口使用的关键字不是class，是interface。
             对于接口当中常见的成员：而且这些成员都有固定的修饰符。
                    全局常量。public static final
                    抽象方法。public abstract
           由此得出结论，接口中的成员都是公共的权限，权限都是最大的。
                                    类与类之间是继承关系，类与接口之间是实现关系。
                                    接口不可以实例化。 只能由实现了接口的子类并覆盖了接口中所有的抽象方法后，该子类才可以实例化，否则，这个子类就是一个抽象类。
          在Java中不直接支持多继承，因为会出现调用的不确定性，所以Java将多继承机制进行改良，在Java中变成了多实现。
                     一个类可以实现多个接口。一个类在继承另一个类的同时，还可以实现多个接口。
                    接口的出现避免了单继承的局限性。接口与接口之间是继承关系，而且接口可以多继承。
            1.2.1 接口的特点：
                     接口是对外暴露的规则。                     
                     接口是程序的功能扩展。
                     接口的出现降低耦合性。
                     接口可以用来多实现。
                     类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。
                     接口与接口之间可以有继承关系。
       1.3 多态
             1.3.1多态在代码中的体现
                    父类或者接口的引用指向其子类的对象。

           对象的多态性：

                   动物 x = new 猫();

                  一个对象两种形态。

                  就是一个对象对应着不同类型。

                  一般简单来说就是父类型的对象指向子类型的引用。

                                      

          注意：对于转型，自始自终都是子类对象在做着类型的变化。

                  向上转型特点：1，限制子类特有的功能。2，提高扩展性。   

             1.3.2 多态的好处：

            应用程序不必为每一个子类编写功能调用，只需要对父类进行处理即可。这一招叫“以不变应万变”，可以大大提高程序的可复用性。

            子类的功能可以被父类的变量调用，这叫向后兼容，可以提高程序的可扩充性和可维护性。现在写的程序可以调用将来写的程序不足为奇 。

             1.3.3多态的弊端
                    弊端：前期定义的内容不能使用（调用）后期子类的特有内容
             1.3.4 多态使用的前提：
                    1，  必须有关系，要么继承，要么实现。

             2，  要有覆盖。

           注意：对于转型，自始自终都是子类对象在做着类型的变化。

                   向上转型特点：1，限制子类特有的功能。2，提高扩展性。

             1.3.6多态时成员的特点：
                   成员变量。

           编译时：参考引用型变量所属的类中是否有调用的成员变量，有，编译通过，没有，编译失败。

           运行时：参考引用类型变量所属的类中是否有调用的成员变量，并运行该所属类中的成员变量。

           简单说：编译和运行都参考等号的左边。(一般开发里面少见)

               示例代码：

                                       class Fu

                                        {

                                             int num = 1;

                                        }

                                       class Zi extends Fu

                                       {

                                           int num = 9;         

                                       }

                                    class Demo

                                    {

                                         public static void main(String [] args)

                                          {

                                               Fu f = new Zi();

                                               System.out.println(f.num);// 1

                                               Zi a = (Zi)f;

                                              System.out.println(a.num);// 9

                                           }

                                    }

             成员函数(非静态)。

             编译时：参考引用型变量所属的类中是否有调用的函数。有，编译通过，没有，编译失败。

             运行时：参考的是对象所属的类中是否有调用的函数。

             简单点：编译时看左边，运行看右边。

             静态函数。

             编译时：参考引用型变量所属的类中是否有调用的静态方法。

             运行时：参考引用型变量所属的类中是否有调用的静态方法。

             简单说：编译和运行时都看左边。

             其实对应静态方法，是不需要对象的，直接用类名调用即可

             1.3.7 Instanceof
                     用于判断对象的具体类型。只能用与引用数据类型判断。主要用在判断接收的是否是自己需要的类型。通常在向下转型前用于健壮性的判断。

            示例代码：

                                   
             1.3.8 内部类：      
                     内部类：将一个类定义在另一个类里面，对里面那个类就称为内部类(内置类，嵌套类)。
                      1.1内部类访问特点：
                           1，   内部类可以直接访问外部类中的成员。
                           2，  外部类要访问内部类，必须建立内部类的对象。  
                      1.2 内部类什么时候用呢？
                           一般用于类的设计。分析事物时，发现该事物描述中还有事物，而且这个事物还在访问被描述事物的内容，这时就是还有的事物定义在内部类来描述。                                                      

                      1.3内部类的特点：
                           内部类定义在外部类就是成员了，成员就可以被修饰符所修饰。

               如果内部类是一个静态的话，相当于一个外部类。

               如果内部类是静态，成员是静态的。直接类名调用。

               如果当内部类成员被静态Static修饰，那么该内部类前必须加Static静态修饰。

                      1.4 为什么内部类能直接访问外部类中的成员呢？
                           那是因为内部类持有了外部类的引用。外部类名.this                     
                       1.5 内部类可以存放在局部位置上。
                           内部类在局部位置上，只能访问局部中被final修饰的局部变量。
                           
                      1.6 匿名内部类
                           匿名内部类：就是内部类的简写格式。

                           使用前提：内部类必须继承或者实现一个外部类或者接口。

                           匿名内部类：其实就是一个匿名子类对象。

               格式就是：new 父类or接口(){子类内容}.子类成员方法()

                          通常使用场景之一：

                                  当函数参数是接口类型时，而且接口中的方法不超过三个。可以用匿名内部类作为实际参数作为传递。

                                 当匿名内部类的方法超过一个时，可以给匿名内部类起个名字，但是起名字就涉及到了多态，这样就很容易出现父类引用指向了子类，

                                 子类就提升为了父类，当调用这个匿名内部类的时，调用子类特有的数据会失败，父类没有这个方法。

       1.4 模版设计模式
            在解决一些问题或者设计一个软件的时候，需要先定义一个模板，就相当于一种事先定义好的协议。以后要做这系列的事情都按照这个模板来做。
            这样就实现统一化管理。

      如何实现模板方法设计模式

           定义一个抽象的父类做为模板，定义所有需要的方法在父类中实现供外界调用的主方法，将方法声明为final.根据不同业务需求定义子类实现父类的抽象方法

       1.5 抽象类与接口的区别
            抽象类中可以有不抽象的方法，接口中全是抽象的方法

            抽象类用extends继承，接口用implements实现

             抽象类中的变量和方法没有默认修饰符，接口中的变量默认为public static final的，接口中的方法默认为public abstract

             一个类只能继承一个抽象类，一个类可以实现多个接口

       1.6 什么时候使用抽象类，什么时候使用接口
          如果能用接口，就不用抽象类，因为别人实现接口可以不占用继承的位置。

          如果定义一个抽象的父类，其中所有方法都是抽象的，那么就定义为接口。

         如 果定义一个抽象的父类的时候，需要有不抽象的方法，那么只能定义为抽象类。

       1.7 构造代码块儿