多态的好处与弊端

多态的好处：
  1.提高了代码的维护性（继承保证）
  2.提高了代码的扩展性（由多态保证）
多态的弊端：
  1.不能使用子类的特有功能
  2.创建子类对象调用方法（可行但是很多时候是不合理的，而且太占内存）
  3. 对象间的转型问题
1.向上转型（父类引用指向子类对象） Fu  f=new  zi();现在是zi类型的，外面看到的是fu类型的所以是zi向fu的向上转型
2.向下转型（父类引用转为子类对象） Zi    z=（zi）f；看到的是f，外面看到的是zi所以是f向zi的向下转型
 多态的成员访问特点：
  成员变量：编译看左边，运行看左边
  成员方法：编译看左边，运行看右边
  构造方法：创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化。
  静态方法：编译看左边，运行看左边
  成员方法存在方法的重写，所以运行看右边 继承的时候：
  子类中有和父类中一样的方法，叫重写
  子类中没有父类中出现过的方法，方法被继承过来了。
抽象类的概述
特点：抽象类和抽象方法必须用abstract关键字修饰
抽象类的实例化是靠具体的子类进行实例化的
接口的特点：
 接口不能实例化，以多态的方式实例化 成员变量：只能是常量，而且是静态的
   1.Public int num=10;
   2.Public  final int  num2=20;
   3.Public  static  final int num3=30;
注：如果写成第一种方式的，那么它就是省略了第三种里面的static和final 接口中的变量默认是常量
   接口没有构造方法，因为接口主要是扩展功能的，而没有具体存在
   成员方法：只能是抽象方法  默认修饰符public  abstract  
类与类 ，类与接口，接口与接口的关系
    类与类继承关系，只能单继承，可以多层继承
    类与接口实现关系
    接口与接口：可以多继承，单继承

抽象类和接口之间的区别
    抽象类：
 1.成员区别：a,成员变量：可以是变量
 2.构造方法：有
 3.成员方法：可以抽象，也可以非抽象
  接口：
1.成员变量：只可以常量
2.长远方法：只可以抽象；
设计理念区别 
抽象类 被继承体现的是：is a的关系。抽象类中定义的是噶继承体系的共性功能
接口   被实现体现的是：like  a的关系。接口中定义的是该继承体系的扩展功能。

 

多态的好处与弊端 
当父类的引用指向子类对象时，就发生了向上转型，即把子类类型对象转成了父类类型。向上转型的好处是隐藏了子类类型，提高了代码的扩展性。 
但向上转型也有弊端，只能使用父类共性的内容，而无法使用子类特有功能，功能有限制。看如下代码 
//描述动物类，并抽取共性eat方法 
abstract class Animal { 
       abstract void eat(); 
}

// 描述狗类，继承动物类，重写eat方法，增加lookHome方法 
class Dog extends Animal { 
     void eat() { 
          System.out.println(“啃骨头”); 
     }

    void lookHome() {
         System.out.println("看家");
    }
}

// 描述猫类，继承动物类，重写eat方法，增加catchMouse方法 
class Cat extends Animal { 
   void eat() { 
       System.out.println(“吃鱼”); 
   }

   void catchMouse() {
    System.out.println("抓老鼠");
   }
}

public class Test { 
           public static void main(String[] args) { 
                    Animal a = new Dog(); //多态形式，创建一个狗对象 
                   a.eat(); // 调用对象中的方法，会执行狗类中的eat方法 
                   // a.lookHome();//使用Dog类特有的方法，需要向下转型，不能直接使用

                   // 为了使用狗类的lookHome方法，需要向下转型

                  // 向下转型过程中，可能会发生类型转换的错误，即ClassCastException异常 
                 // 那么，在转之前需要做健壮性判断 
                 if( !a instanceof Dog){ // 判断当前对象是否是Dog类型 
                     System.out.println(“类型不匹配，不能转换”); 
                     return; 
                  } 
                 Dog d = (Dog) a; //向下转型 
                 d.lookHome();//调用狗类的lookHome方法 
         } 
}

我们来总结一下： 
什么时候使用向上转型： 
当不需要面对子类类型时，通过提高扩展性，或者使用父类的功能就能完成相应的操作，这时就可以使用向上转型。 
如：Animal a = new Dog(); 
a.eat(); 
什么时候使用向下转型 
当要使用子类特有功能时，就需要使用向下转型。 
如：Dog d = (Dog) a; //向下转型 
d.lookHome();//调用狗类的lookHome方法 
向下转型的好处：可以使用子类特有功能。 
弊端是：需要面对具体的子类对象；在向下转型时容易发生ClassCastException类型转换异常。在转换之前必须做类型判断。 
如：if( !a instanceof Dog){…}