面向对象的多态性

学习目标：

1. Object类的toString()与equals(Object  obj)方法

2. 面向对象的多态性

3. 抽象类与接口

 

A.Object类

     ·Object类是所有Java类的根基类(“祖先类”)

     ·如果在类的声明中未使用extends关键字指明其基类，则

       默认基类为Object类

      

     a.toString方法

        1.Object类中定义有public  String toString()方法，

          其返回值是String类型，描述当前对象的有关信息

       ***如果直接打印某对象的引用，则默认会调用这个对象的

          toString()方法，默认打印的内容中包含这个引用所指

          向的内存地址

         

         

             

 

       2.可以根据需要在用户自定义类中重写toString()方法

       

       

                             

     b.equals( )方法

        1.Object类中定义有publicboolean equals(Object obj)

          方法，提供定义对象是否“相等”的逻辑

       2.Object的equals方法定义为：x.equals(y)，当x和y指向同

         一个地址时返回true，否则返回false

       3.String类中已经重写了equals(Object obj)方法，重写后的

         方法比较的是两个字符串的”内容”是否一样

         (注意：==比较对象的引用)

       4.可以根据需要在用户自定义类型中重写equals方法

         

            

B.多态性

     ·封装是为了保护属性的一种操作，继承是为了扩展类的功能

     ·是由封装性和继承性引出的面向对象程序设计语言的另一种特征

     a.多态的体现

       1.从方法的角度来看

         ·方法的重载和重写

          （1）重载(overloading)：根据传入的参数不同，完成的

                                  功能也不同

          （2）重写(override)：子类根据需求重写父类中的方法

       2.从对象的角度来看

         ·对象的多态性主要分为两种：

          （1）向上转型：子类对象--->父类对象(程序会自动完成)

                格式：父类  父类对象=子类实例

               或者  父类  父类对象=new 子类

            ***向上转型后，因为操作的是父类对象，所以无法找

               到在子类中定义的新方法;但如果子类重写了父类的

               某个方法，则调用的是重写后的方法  

        

        

        

        

  

     

     

         

          （2）向下转型：父类对象--->子类对象 (必须明确的指明要转型的子类类型)

               格式：子类  子类对象=(子类)父类实例

               注意：向下转型前先要向上转型

   

    

     

         

     b.instanceof关键字

       1.在java中可以使用instanceof关键字判断一个对象是否属于一个类的实例

       2.格式：对象  instanceof  类--->返回boolean类型

     

        

        

    

          

    c.final关键字

       1.在JAVA中声明类、属性和方法时，可以使用关键字final来修饰

       2.注意：

         （1）final修饰变量(成员变量或局部变量),则成为

              常量，只能赋值一次

              final 类型  variableName;

              修饰成员变量时，定义时同时给出初始值，而修饰

              局部变量时不做要求

                                              

         （2）final修饰方法，则该方法不能被子类重写

              final 返回值类型  methodName(paramList)

              {

                  …

              }

              

              

         （3）final修饰类，则类不能被继承

              final classfinalClassName{

                  …

              }

                          

               

C.抽象类与接口

    ·用abstract修饰的类即为抽象类

         abstract class 抽象类名{

         }

 

    ·抽象类不能被实例化，必须被继承，抽象方法必须被重写，生成它

      的子类

    ·由abstract修饰的方法就是抽象方法，抽象方法没有方法体

    ·抽象类不一定要包含抽象方法，若类中包含了抽象方法，则该类必须

      被定义为抽象类

    ·如果一个子类没有实现抽象父类中所有的抽象方法，则子类也成为一

      个抽象类

    ·构造方法、静态方法、私有方法、final方法不能被声明为抽象的方法

                      

                    

                    

                     

                             

      ***如果子类也是一个抽象类，则可以不用重写父类的抽象方法，但是

         当子类的子类为非抽象类时，子类的子类要重写子类的抽象方法，

         并且要将子类未重写的父类的抽象方法也写上

         

         

     a.接口

        ·接口（interface）是抽象方法和常量值的定义的集合

        ·接口是一种“标准”、“契约”。

        ·从本质上讲，接口是一种特殊的抽象类，这种抽象类中只能包含

          常量和方法的定义，而没有变量和方法的实现

        1.接口的声明语法

          （1）包括接口声明和接口体

          （2）完整的接口声明:

            [public] interface接口名称[extends listOfSuperInterface] { … }

          （3）接口体包括常量定义和方法定义

               ·常量定义: typeNAME=value;  该常量被实现该接口的多

                 个类共享; 具有public,final, static的属性.

               ·方法体定义:具有 public和abstract属性

        2.接口的实现类

          （1）与抽象类一样，接口要使用也必须通过子类，子类通过

               implements关键字实现接口

          （2）一个类可以实现多个接口,在implements子句中用逗号分开

          （3）非抽象子类必须实现接口中定义的所有方法

          （4）实现格式：

               ·class子类 implements接口A，接口B…{

                 }

        3.接口的使用规则

          （1）接口中所有的方法都是public abstract 

          （2）在接口中声明方法时，不能使用static，final，synchronized，

               private，protected等修饰符

          （3）一个接口可以继承自另一个接口

          （4）java中不允许类的多继承，但允许接口的多继承

          （5）接口中可以有数据成员，这些成员默认都是public static final

        4.接口的用途

          （1）通过接口实现不相关类的相同行为,而无需考虑这些类之间的关系

          （2）通过接口指明多个类需要实现的方法

          （3）通过接口了解对象的交互界面,而无需了解对象所对应的类

        5.eg1:

             

             

             

             

             

              

          eg2:

             

             

             

              

              

          eg3:

             

             

              

              

               

               

          eg4：