黑马程序员---java基础---多态，抽象类，接口



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

一.多态：
  1.父类的引用指向子类的对象；
  2.多态前提和体现
   1).有继承关系 
   2).有方法重写 
   3).有父类引用指向子类对象
  3.多态的转型：
   1).自动转型：子类的引用转为父类的引用；Person p = new Student();
   2).强制转型：父类的引用转为它所指向的子类对象的引用；Student stu = (Student)p;
   3).在进行强制转型前，为保证安全，可以使用instanceof关键字进行判断：
    if(p instanceof Student){
     Student stu = (Student)p;
    }
  4.多态的好处：
   1).提高了程序的维护性(由继承保证)
   2).提高了程序的扩展性(由多态保证)
  5.多态的弊端：
   1).不能访问子类特有功能(可以向下转型)
  6.多态时的访问规则：
   1).总体规则：访问的任何成员父类中必须要有，否则编译错误；
    例如：
     class A{
      int num = 10;
     }
     class B extends A{
      int n = 20;
     }
     main(){
      A a = new B();
      System.out.println(a.n); //编译错误，父类中没有n
     }
   2).成员变量：如果子、父类中都有，访问的是“父类”的；
     class A{
      int num = 10;
     }
     class B extends A {
      int num = 20;
     }
     main(){
      A a = new B(); //多态
      System.out.println(a.num); //打印10；
     }
      普通方法：如果子、父类中都有(重写)，访问的是“子类”的；
     class A{
      void show(){
       System.out.println("A-->show()");
      }
     }
     class B extends A{
      void show(){
       System.out.println("B-->show()");
      }
     }
     main(){
      A a = new B();
      a.show(); //打印：B-->show()(访问的是子类的show());
     }
      静态方法：如果子、父类中都有(重写)，访问的是“父类”的；
   

 二.抽象类：
  1.使用abstract关键字修饰；可以修饰“类”，可以修饰“成员方法”；
   abstract class A{
    abstract void show();
   }
  2.“抽象类”的特点：
   1).不能被实例化，只能用于被继承；
   2).可以包含：成员变量、构造方法、成员方法、抽象方法；
   3).可以不包含抽象方法；
  3.“抽象方法”的特点：
   1).没有方法体；abstract void show();
   2).必须被子类重写。除非子类也是个抽象类；
  3.子类继承抽象类使用关键字：extends，仍然是单继承；
  4.一个子类继承 了一个抽象类，必须实现抽象类中所有的抽象方法；
    否则子类也必须是抽象的。
   例如：
    abstract class A{
     abstract void show();
    }
    class B extends A{  } //编译错误。类B不是抽象的，继承类抽象类必须重写抽象类中的所有抽象方法。
    abstract class B extends A{  } //编译通过。类B没有重写父类中的抽象方法，但类B是抽象的。
  5.abstract关键字不能和哪些关键字共存：
   1.private:抽象方法就是用来被子类重写的，而私有方法不能被子类重写；
   2.final：抽象类和抽象方法就是用来被子类继承和重写的，而fianl类和final方法不能
                                 被继承和重写；
   3.static：static修饰的方法在没有任何对象的情况下就会被分配内存空间；而抽象方法
                                  没有方法体，无法分配空间；
 三.接口：
  1.使用interface关键字定义：只能修饰“类”：
   interface IA{
   }
  2.“接口”的特点：
   1).不能被实例化，没有构造方法，只能用于子类“实现”；
   2).可以包含：
    A.成员变量(常量)：隐式的定义为：public static final。
                   上述三个关键字中任何一个都可以不写，系统会自动添加；
      例如：
      interface IA{
       public int num1 = 10;  //OK
       static final int num2 = 20; //OK
       final int num3 = 30;  //OK
       public final num4 = 40;  //OK
       int num5 = 50;   //OK
      }
    B.抽象方法：隐式的定义为：public abstract。可以省略，系统会自动添加
      例如：
      interface IA{
       void show1();  //OK
       public void show2(); //OK;
       abstract void show3(); //OK;
      }
   3).接口的功能是：扩展功能；
  3.子类实现接口使用关键字：implements
  4.一个子类可以同时实现多个接口；
   interface IA{}
   interface IB{}
   class C implements IA,IB{ //OK的。
   }
  5.子类实现接口时，必须重写接口中所有的抽象方法，而且必须是public的--因为
                           接口中抽象方法的定义隐式的是public的。
    例如：
     interface IA{
      void show();
     }
     class B implements IA{
      void show(){  }       //编译错误。父接口的show()隐式的为public的，子类重写时必须是public的；
     }
    
  5.接口编译后一样会生成.class文件。
 四.多态的形式：
  1.父类的多态；
  2.抽象类多态；
  3.接口多态；     
 五.类与类，类与接口，接口与接口的关系：
  1.类与类：继承关系，关键字：extends ，只能单继承，但是可以多层继承
  2.类与接口：实现关系，关键字：implements ，可以单实现，也可以多实现。还可以在继承一个类的同时实现多个接口
  3.接口与接口：继承关系，关键字：extends，可以单继承，也可以多继承
   例如：
    interface IA{}
    interface IB{}
    interface IC extends IA,IB{} //OK的
 六.抽象类和接口的区别：
  1.成员区别
   1).抽象类 变量,常量;有抽象方法;抽象方法,非抽象方法
   2).接口 常量;抽象方法
  2.关系区别
   1).类与类 继承，单继承
   2).类与接口 实现，单实现，多实现
   3).接口与接口 继承，单继承，多继承
  3.设计理念区别
   1).抽象类 被继承体现的是：”is a”的关系。共性功能
   2).接口 被实现体现的是：”like a”的关系。扩展功能
 七.
  一.类名作为形参：
   1.实参可以是：
    1).此类对象的引用;
    2).null;
    3).此类子类对象的引用；
     二.抽象类作为形参：
   1.实参可以是：
    1).此类子类对象的引用；
    2).null;
    三.接口作为形参：
   1.实参可以是：
    1).此接口子类对象的引用；
    2).null;
     四.类名作为返回值：
   1.可以返回的类型：
    1).此类对象的引用；
    2).null;
    3).此类子类对象的引用；
   2.可以用什么类型接收：
    1).使用此类类型；
    2).不能使用某个子类类型接收；
     五.抽象类作为返回值：
   1.可以返回的类型：
    1).null;
    2).此类子类对象的引用；
   2.可以用什么类型接收：
    1).使用此类类型；(多态)
    2).不能使用某个子类类型接收；
     六.接口作为返回值：
   1.可以返回的类型：
    1).null;
    2).此接口子类对象的引用；
   2.可以用什么类型接收：
    1).使用此接口类型；(多态)
    2).不能使用某个子类类型接收；