黑马程序员——Java基础---继承、抽象、接口（一）

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一、继承

1. 继承的描述

         通过 extends 关键字让类与类之间产生继承关系。
    多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。多个类可以称     为子类，单独这个类称为父类或者超类。

    P.S.
    1、子类可以直接访问父类中的非私有的属性和行为。
    2、子类无法继承父类中私有的内容。
    3、父类怎么来的？共性不断向上抽取而来的。

2. 继承的好处

    继承的出现提高了代码的复用性。
    继承的出现让类与类之间产生了关系，提供了多态的前提。

3. 继承的特点

    Java只支持单继承，不支持多继承。
    一个类只能有一个父类，不可以有多个父类。
    原因：多继承容易出现问题。两个父类中有相同的方法，子类到底要执行哪一个是不确定的。

    Java支持多层继承(继承体系)：
    C继承B，B继承A，就会出现继承体系。
    多层继承出现的继承体系中，通常看父类中的功能，了解该体系的基本功能，建立子类对象，即可使用该体系功能。

    定义继承需要注意：
    不要仅为了获取其他类中某个功能而去继承，类与类之间要有所属( "is a")关系。

4. super关键字和函数覆盖

    在子父类中，成员的特点体现：

1. 成员变量

      this和super的用法很相似。
      this代表本类对象的引用。
      super代表父类的内存空间的标识。

      当本类的成员和局部变量同名用this区分。
      当子父类中的成员变量同名用super区分父类。

示例：

/** * 需求：演示this和super关键字 * @author jinlong * */package com.blog.part2.继承;//创建父类fuclass Fu{//定义父类私有变量num和变量num1private int num=10;int num1 =20;//父类公共方法getNumpublic int getNum(){return num;}}//继承Fuclass Zi extends Fu{//子类私有变量num，与父类同名private int num=5;void show(){//这里同过super关键字可以调用父类非私有函数，已经获取非私有变量的值。System.out.println(this.num+"....."+super.getNum()+"....."+super.num1);}}public class FuZiDemo {public static void main(String[] args){//创建子类对象Zi z=new Zi();z.show();}}

运行结果：

2. 成员函数

      当子父类中出现成员函数一模一样的情况，会运行子类的函数。
      这种现象，称为覆盖操作，这是函数在子父类中的特性。
      在子类覆盖方法中，继续使用被覆盖的父类方法可以通过super.函数名获取。

     函数两个特性：
     1. 重载，同一个类中。
     2. 覆盖，子类中，覆盖也称为重写，覆写，override。

示例：

/** * 需求：演示函数的重载 * @author jinlong * */package com.blog.part2.继承;class Fu{    public void show()    {         System.out.println("fu show run" );   }}class Zi extends Fu{//定义与父类同名的函数    public void show()    {         System.out.println("zi show run" );   }}class ExtendDemo{    public static void main(String[] args)    {         Zi z = new Zi();         z.show();   }}

运行结果：

       

   当子类需要父类的功能，而功能主体子类有自己特有内容时，可以复写父类中的方法，这样，即沿袭了父类功能，又能实现自己的功能。

* 需求：展示同名函数的覆盖和功能扩展 * @author jinlong * */package com.blog.part2.继承;class Phone{    void call(){}    void show()    {         System.out.println("number" );    }}class NewPhone extends Phone{//与父类同名的函数    void show()    {    //自己定义的新功能         System.out.println("name" );         System.out.println("pic" );         //super关键字调用父类，实现旧功能         super.show();   }}class ExtendsDemo{    public static void main(String[] args)    {         NewPhone p = new NewPhone();         p.show();   } 

}  

注意： 1、父类中的私有方法不可以被覆盖。
     2、父类为static的方法无法覆盖。
     3、覆盖时，子类方法权限一定要大于等于父类方法权限。

3. 构造函数

        子父类中构造函数的特点：
    在子类构造函数执行时，发现父类构造函数也运行了。
    原因：在子类的构造函数中，第一行有一个默认的隐式语句：super();。
    注意：如果使用super(4);语句调用父类的其他构造函数，那么默认的父类构造函数将不会再被调用。

package com.blog.part2.继承;class Fu{      int num ;      Fu()       {            num = 10;            System.out.println("A fu run" );       }            Fu(int x)      {            System.out.println("B fu run..." + x);      }}class Zi extends Fu{      Zi()       {            //super();//默认调用的就是父类中的空参数的构造函数            System.out.println("C zi run " + num);       }      Zi(int x)       {            //super语句调用父类参数            super(4);            System.out.println("D zi run " + x);       }}class ExtendDemo{       public static void main(String[] args)        {            new Zi();            System.out.println("-------------------" );            new Zi(6);        }} 

运行结果：

5.子类实例化过程

    子类中所有的构造函数默认都会访问父类中空参数的构造函数。
    因为每一个构造函数的第一行都有一条默认的语句super();。

    为什么子类实例化的时候要访问父类中的构造函数呢？
    那是因为子类继承了父类，获取到了父类中内容（属性），所以在使用父类内容之前，要先看父类是如何对自己的内容进行初始化的。

    P.S.
    1、当父类中没有空参数的构造函数时，子类的构造函数必须通过this或者super语句指定要访问的构造函数。
    2、子类构造函数中如果使用this调用了本类构造函数，那么默认的super();就没有了，因为super和this都只能定义在第一行，所以只能有一       个。但是可以保证的是，子类中肯定会有其他的构造函数访问父类的构造函数。
    3、super语句必须要定义在子类构造函数的第一行！因为父类的初始化动作要先完成。

   示例：

/** * 需求：演示子类实例化过程 * @author jinlong * */package com.blog.part2.继承;class Fu{    Fu()          {           //理论上每个类都是Object类的子类，每个类的构造函数第一行都有super，不写的时候系统默认添加           super();           //调用的是子类的show方法，隐藏了this关键字其实，此时其成员变量num还未进行显示初始化           show();           return;         }    void show()    {          System.out.println("fu show" );    }}class Zi extends Fu{     int num ;     Zi()     {     //调用Fu的构造函数           super();           //通过super初始化父类内容时，子类的成员变量并未显示初始化,默认值为0，等super()父类初始化完毕后，才进行子类的成员变量显示初始化          this.num=10;          //调用的父类show方法。          super.show();           return;     }     void show()     {          System.out.println("zi show..." + num);     }}class ExtendDemo{     public static void main(String[] args){          Zi z = new Zi();          z.show();     }}

运行结果：

分析过程：从程序入口main函数开始运行，当读到 new Zi()时，要实例化Zi类

    1. JVM会读取指定的路径下的Zi.class文件，并加载进内存，并会先加载Zi的父类Fu.class。
    2. 在内存中开辟空间，并分配地址。
    3. 并在对象空间中，对对象的属性进行默认初始化,这是Zi的num变量值默认还是0。
    4. 调用对应的构造函数进行初始化，即调用Zi类构造函数
    5. 在构造函数中，第一行读到super(),会先到Fu类中构造函数进行初始化。父类构造函数中有个show方法调用，这里要清楚       的知道，这个show调用的是子类的方法，因为默认省略了this关键字，而this指向当前对象，即Zi。这时候子类的成员变       量还是默认值0，show打印出来的是0.
    6. 父类初始化完毕后，再对子类的属性进行显示初始化，即读到this.num=10；这句给才给子类成员变量赋值为10。
    7. 再进行子类构造函数的特定初始化。
    8. 初始化完毕后，将地址值赋值给引用变量。这时调用子类show方法，打印的num值已经是10了。

6.final关键字

    为什么要在这里讲这个关键字，因为继承打破了封装性。而finall关键字可以解决这问题。final可以修饰类，方法，变量。并且有以下特点

    final修饰的类不可以被继承。
    final修饰的方法不可以被覆盖。
    final修饰的变量是一个常量，只能被赋值一次。

    为什么要用final修饰变量，其实，在程序中如果一个数据是固定的。那么直接使用这个数据就可以了，但是这种阅读性差，所以应该给数据起     个名称。而且这个变量名称的值不能变化，所以加上final固定。
    写法规范：常量所有字母都大写，多个单词，中间用_连接。

二、抽象类

1. 抽象类概述

         抽象定义：
    抽象就是从多个事物中将共性的、本质的内容抽取出来。
    例如：狼和狗共性都是犬科，犬科就是抽象出来的概念。

    抽象类：
    Java中可以定义没有方法体的方法，该方法的具体实现由子类完成，该方法称为抽象方法，包含抽象方法的类就是抽象类。

    抽象方法的由来：
    多个对象都具备相同的功能，但是功能具体内容有所不同，那么在抽取过程中，只抽取了功能定义，并未抽取功能主体，那么只有功能声明，没     有功能主体的方法称为抽象方法。
    例如：狼和狗都有吼叫的方法，可是吼叫内容是不一样的。所以抽象出来的犬科虽然有吼叫功能，但是并不明确吼叫的细节。

2. 抽象类的特点

         抽象类和抽象方法必须用abstract关键字来修饰。

    抽象方法只有方法声明，没有方法体，定义在抽象类中。
    格式：修饰符 abstract 返回值类型 函数名(参数列表) ;

    抽象类不可以被实例化，也就是不可以用new创建对象。
    原因如下：
    1. 抽象类是具体事物抽取出来的，本身是不具体的，没有对应的实例。例如：犬科是一个抽象的概念，真正存在的是狼和狗。
    2. 而且抽象类即使创建了对象，调用抽象方法也没有意义。
    3. 抽象类通过其子类实例化，而子类需要覆盖掉抽象类中所有的抽象方法后才可以创建对象，否则该子类也是抽象类。

3. 抽象类的相关问题

    抽象类中是否有构造函数？
    答：有，用于给子类对象进行初始化。

    抽象关键字abstract不可以和哪些关键字共存？
    答：private、static、final。

    抽象类中可不可以没有抽象方法？
    答：可以，但是很少见。目的就是不让该类创建对象，AWT的适配器对象就是这种类。通常这个类中的方法有方法体，但是却没有内容。
          

         抽象类可不可以实现接口？

          答：可以，这种体系有很多应用。

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

    不同点：
    1. 一般类有足够的信息描述事物。
        抽象类描述事物的信息有可能不足。
    2. 一般类中不能定义抽象方法，只能定义非抽象方法。
       抽象类中可定义抽象方法，同时也可以定义非抽象方法。
    3. 一般类可以被实例化。
       抽象类不可以被实例化。

    抽象类一定是个父类吗？
    答：是的，因为需要子类覆盖其方法后才可以对子类实例化。

三、接口

1.接口概述

    当一个抽象类中的方法都是抽象的时候，这时可以将该抽象类用另一种形式定义和表示，就是接口。
    格式：interface {}

    接口中的成员修饰符是固定的：
    成员常量：public static final
    成员函数：public abstract
    由此得出结论，接口中的成员都是公共的权限。

    接口是对外暴露的规则。
    接口是程序的功能扩展。

    P.S.
    1、虽然抽象类中的全局变量和抽象方法的修饰符都可以不用写，但是这样阅读性很差。所以，最好写上。
    2、类与类之间是继承关系，类与接口直接是实现关系。
    3、接口不可以实例化，能由实现了接口并覆盖了接口中所有的抽象方法的子类实例化。否则，这个子类就是一个抽象类。

      这句话也可以理解为抽象类也可以继承接口，但是无需实例化，也不需要实现接口所有方法。所以抽象类经常作为一个接口和普通类之间的       过度。

2.多实现

    接口的出现将“多继承”通过另一种形式体现出来，即“多实现”。

    在java中不直接支持多继承，因为会出现调用的不确定性。
    所以，java将多继承机制进行改良，在java中变成了多实现，一个类可以实现多个接口。
    接口的出现避免了单继承的局限性。

示例：

interface A{       public void show();}interface Z{       public void show();}//多实现class Test implements A,Z{       public void show(){            System.out.println("Test");       }}class InterfaceDemo{       public static void main(String[] args){            Test t = new Test();            t.show();       }}<span style="font-size:14px;"></span>

3.接口和类异同点

          相同点：
    都是不断向上抽取而来的。
    不同点：
    1. 抽象类需要被继承，而且只能单继承。
        接口需要被实现，而且可以多实现。
    2. 抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法。
        接口中只能定义抽象方法，必须由子类去实现。
    3. 抽象类的继承，是is a关系，定义该体系的基本共性内容。
        接口的实现是like a关系。  

4.扩展性体现

示例：

/** * 需求：模拟笔记本电脑使用。 * 思路：为了扩展笔记本的功能，但日后出现什么功能设备不知道。因此需要定义一个规则，只要日后出现的设备都符合这个规则就可以了。 *           规则在java中就是接口。 * @author jinlong * */package com.blog.part2.继承;//定义USB接口，以后所有功能只要符合这个接口就能插上主板进行扩展interface USB{       //方法暴露的原则       public void open();       public void close();}//定义Upan设备//这些设备和电脑的耦合性降低了class UPan implements USB{         public void open()       {            System.out.println("upan open");       }       public void close()       {            System.out.println("upan close");       }}//定义UsbMouse设备class UsbMouse implements USB{       public void open(){            System.out.println("usbMouse open");       }       public void close(){            System.out.println("usbMouse close");       }}class BookPc{       public static void main(String[] args)       {             //功能扩展了，new UsbMouse等             useUSB(new UPan());             useUSB(new UsbMouse());       }       //注意这里BookPc的函数，传入参数为USB类型，接口类型的引用，用于接收（指向）接口的子类对象        //也就是所有实现了USB类的类都可以直接插入电脑       public static void useUSB(USB u)       {             if(u != null ){                  u.open();                  u.close();             }       }}

运行结果：