黑马程序员——多态和抽象类的相关知识

------android培训、java培训、期待与您交流------

有一个多态的宠物案例

  多态的转型中(强制转)，容易出现类型转换异常 ClassCastException，宠物的案例中，发生的原因，转型目标是Cat类，传递的参数不是Cat类型，而是Dog类型。

  Cat c = (Cat)a;  Animal a接收到的是Cat类型，接收到的是Dog类型，出现了转换异常，判断出这个a接收到的是什么类型，如果接收到的是Cat类型，强转成Cat，如果a接收到的是Dog类型，强转成Dog。

 比较运算符instanceof关键字，运算结果是布尔类型，判断出一个引用型变量，是哪一种类型的格式：

       引用变量instanceof  类

        a instanceof Cat 就可以判断出引用型变量a接收到的是不是Cat类型，如果是返回真，如果不是返回假。例如下面的小例子：

//宠物类共性抽取，形成一个父类

class Animal

{

         //共性方法eat

         public void eat(){}

}

 

 

//养猫，吃饭，抓老鼠

class Cat extends Animal

{

         public void eat(){

            System.out.println("猫吃猫粮");

         }

 

         public void catchMouse(){

            System.out.println("抓老鼠");

         }

}

//养狗，吃饭，看家

class Dog extends Animal

{

         public void eat(){

            System.out.println("狗吃狗粮");

         }

         public void lookHouse(){

           System.out.println("狗看家");

         }

}

//养鸟，吃饭，唱歌

class Bird extends Animal

{

   public void eat(){

            System.out.println("鸟吃虫子");

   }

   public void song(){

      System.out.println("鸟唱歌");

   }

}

class DuoTaiDemo

{

         public static void main(String[] args)

         {

                   eat(new Cat());        

                   eat(new Dog());

                   eat(new Bird());

         }

         /*

           定义一个方法

           方法中，封装了吃这个功能

           参数没有指定具体的动物，指定是这些动物的共性内容

           指挥具有共性的一个对象做事情

 

         */

         public static void eat(Animal a ){

              a.eat();

                   //调用cat特有方法，进行类型强转，提升为父类类型的cat转回cat自己

                   //判断a是不是接收到的Cat类型，是,在强转

                   if(a instanceof Cat ){

                     Cat c = (Cat)a;

                     c.catchMouse();

                   }

 

                    if(a instanceof Dog){

                     Dog d = (Dog)a;

                     d.lookHouse();

                   }

 

                    if(a instanceof Bird){

                      Bird b = (Bird)a;

                      b.song();

                   }

         }

}

多态的实现细节

多态中，引用变量调用方法和成员，运行的是谁

多态中，除非静态的方法以外，编译运行全看左边，只有非静态的成员方法，编译看左边，运行看右边

 

抽象方法：定义的方法中，没有方法体，没有大括号，抽象方法，不能调用！

标识出这个方法是抽象方法，使用关键字abstract(抽象)

抽象的方法，必须存在于抽象的类中，类也进行抽象的修饰

抽象类不能建立对象，不可以new 不能实例化

 

抽象类的使用需要定义子类继承抽象类，重写抽象类中的抽象方法，建立子类的对象

如果子类只重写了部分抽象方法，这个子类还是一个抽象类

 

abstract修饰符不能混用

  abstract final抽象方法，子类重写，加final，不能重写

  abstract static抽象方法，没有方法体，类名直接调用，不需要对象

  abstract private抽象方法，子类重写，私有后，子类不知道父类中有这个方法

 

接口概述

  接口：接口是一个特殊的抽象类，当一个抽象类中，方法全部都是抽象方法的时候，更贴切的名字，叫做接口

  定义接口上，不使用关键字class , 关键字interface接口名(类名)

  接口中的成员，都是固定格式

    成员变量： public static final 数据类型变量名 =值;

    成员方法： public abstract 返回值类型方法名(参数列表..);

 接口的权限必须public

 

接口的使用

  抽象类，子类继承抽象类，重写抽象方法，建立子类对象

  接口，不能new ，无法实例化，由于接口中全部抽象方法，子类实现接口，重写接口中的全部抽象方法，建立子类对象

  如果子类只重写了部分抽象方法，子类还是一个抽象类

  实现的关键字 implements 

  类的实现格式  class A implements 接口名{

                    重写全部的抽象方法

                }

 类A，叫做接口的实现类

 

接口的多实现

  类是单继承，一个类可以同时实现多个接口

  语法 class A implements 接口名,接口名{}类的多实现

  一个类在继承一个类的同时，可以实现多个接口

  多实现的好处：避免了单继承的局限性

 

接口之间的关系

 类与类之间是继承关系，类与接口是实现关系，接口与接口之间是继承关系

 接口之间支持多继承，一个接口可以同时继承多个接口

 

 作为实现类，全部实现整个继承下来的接口

 

接口中的特点：接口就是对外暴露的规则。还有就是接口就是程序的扩展。