Java 继承、抽象、接口

时间:2021-08-28 15:25:58

一、继承

1. 概述

  • 继承是面向对象的重要特征之一,当多个类中存在相同的属性和行为时,将这些内容抽取到单独一个类中,那多个类中无需再定义这些属性和行为,只需继承那个单独的类即可。
    • 单独的类称为父类或超类
    • 多个类称为子类
    • 例如:
      • 猫和老虎都是属于猫科动物。
      • 描述猫、老虎这些对象所创建的类,就是子类;
      • 而描述猫科动物这个对象所创建的类,就是父类。
  • 类与类之间存在了继承关系,子类可以直接访问父类中非私有的属性和行为,代码中通过 extends 关键字来表示继承关系。
    • 例如:class Son extends Father{}//代码中的书写格式
  • 注:
    • 千万不能为了获取其他类中的功能,简化代码而去继承。
    • 必须是类与类之间有所属关系才能继承。
    • 这种所属关系的表示为 is a

2. 特点

1. 提高了代码的复用性。
2. 让类与类之间产生了关系,是多态的前提。
  • 注:
    • Java 语言中只支持单继承,不支持多继承。
    • Java 虽然不支持多继承,但是保留了类似的机制,并且以另一种形式来体现,也就是多实现。
      • 例如:一个儿子只能有一个父亲。
  • 只能单继承的原因?
    • 因为类与类多继承的话,容易产生安全隐患。
      • 例如:当多个父类中定义了相同的功能,但功能的内容不相同时,子类对象就无法确定要运行哪一个父类的功能了。

3. 应用

  • Java 中虽然不支持多继承,但是支持多层继承,也就是继承体系。

    • 例如:儿子继承父亲,父亲继承爷爷等。
      • class A{}
      • class B extends A{}
      • class C extends B{}
  • 如何使用继承体系中的功能?

    • 想要使用继承体系,先要查询继承体系中父类的描述,因为父类中定义的是该继承体系中的共性功能,了解共性功能后,就可以知道该体系的基本功能,这个继承体系就基本可以使用了。
  • 具体调用时,需要先创建最子类的对象,原因是?

    1. 有可能父类不能创建对象;
    2. 创建子类对象可以使用更多的功能,包括基本的父类共性功能,也包括子类的特有功能。
      • 总结:查阅父类功能,创建子类对象使用功能。
  • 例如:

    Java 继承、抽象、接口

    Java 继承、抽象、接口

  • 子父类出现后,类成员(变量、函数、构造函数)的特点:

    • 变量
      • 如果子类中出现非私有的同名成员变量时,子类要访问本类中的变量,用 this;子类要访问父类父类中的同名变量,用 super。
      • this 和 super 的使用几乎一致,并且两者都存于方法区中。
        • this 表示本类对象的引用
        • super 表示父类对象的引用
    • 函数 —— 重写(覆盖)
      • 当子类出现和父类一模一样的函数时,子类对象调用该函数,会运行子类的函数内容,相当于父类的函数被覆盖了,这就是函数的一个特性:重写(覆盖)。

      • 当子类继承父类,并且沿袭了父类的功能时,子类虽具备父类的该功能,但是子类中功能的内容却和父类不一致,这时,无需重新定义新功能,而是使用重写(覆盖)这一特性,保留父类的功能,并重写子类的功能内容,子类中同时想具有父类函数中的内容时,可以使用 super.() 方法。

      • 在上面例子中的 Student 类中重写 sleep() 方法,如下:

        Java 继承、抽象、接口

        Java 继承、抽象、接口

      • 注:

          1. 静态只能覆盖静态。
        2. 父类中的私有方法不能被重写(覆盖)。
        3. 子类重写(覆盖)父类,必须保证子类权限大于或等于父类权限,才可以重写(覆盖),否则会导致编译失败。
      • 重写(覆盖)与重载的区别:

        • 重写(覆盖):子父类方法要一模一样。
        • 重载:只看同名函数的参数列表。
    • 构造函数
      • 对子类对象进行初始化时,父类的构造函数也会运行,因为子类的每一个构造函数默认第一行都有一条隐式的语句 super();

      • super():访问父类中空参数的构造函数,而且子类中所有构造函数默认第一行都是 super();

      • 子类为什么一定会访问父类的构造函数?

        • 父类中的数据子类可以直接获取,子类对象在建立时,需先查看父类中是如何对这些数据进行初始化的,因此子类在对象初始化时,需要先访问父类中的构造函数。
      • 为什么 super() 和 this() 不能在同一个构造函数中?

        • 因为不能在同一行。
      • 为什么 super() 和 this() 不能在同一行?

        • 因为需要先做初始化动作,在子类构造函数中必须有一个 super 语句或 this 语句。
      • 注:

        1. super 语句一定是定义在子类构造函数中的第一行。
        2. 如果要访问父类中指定的构造函数,可以通过手动定义 super 语句的方式去指定。
      • 总结:

          1. 子类中所有构造函数,默认都会访问父类的空参数构造函数;
        2. 子类中每一个构造函数中的第一行都有一句隐式 super(); 语句;
        3. 父类没有空参数构造函数时,子类必须手动定义 super 语句或 this 语句形式去指定要访问的构造函数;
        4. 子类的构造函数第一行也可以手动指定 this 语句去访问本类中的其它构造函数;
        5. 子类中至少会有一个构造函数会访问父类中的构造函数。
  • final 关键字

    • 由于继承的出现,打破了对象的封装性,使得子类可以随意重写(覆盖)父类的功能,这也是继承的弊端。为了解决继承的这个弊端,便出现了 final(最终)关键字。

    • final 修饰符的特点:

        1. 可以修饰类、函数、变量。
      2. final 修饰的类不能被继承。(可以避免被继承、被子类重写父类函数功能)
      3. final 修饰的方法不能被重写。
      4. final 修饰的变量是常量,并且只能赋值一次,可以修饰成员变量,也可以修饰局部变量。
      5. 内部类定义在类中的局部位置时,只能访问该局部被 final 修饰的局部变量。

二、抽象

1. 概述

  • 从多个事物中将共性的、本质的内容抽取出来,这就是抽象。
    • 例如:狗和狼共性都是犬科,犬科就是抽象出来的概念。
  • Java 中可以定义没有方法体的方法,方法的具体实现由子类实现,多个对象如果具有相同功能,但功能的具体内容有所不同,那么在抽取过程中,只抽取功能定义,未抽取功能主体内容,这样只有功能声明,没有功能主体的方法,这样的方法称为抽象方法,而含有抽象方法的类称为抽象类。
    • 例如:狗和狼都有吼叫的方法,但是吼叫的内容不一样,因此抽象出来的犬科虽然有吼叫功能,但是并没有明确吼叫的实现内容细节。
  • 格式:
    • abstract 类名 {}
    • 子类名 extends 抽象类名 {}

2. 特点

  1. 抽象类和抽象方法必须使用 abstract 关键字进行修饰。

  2. 抽象方法只有方法声明,没有方法体,定义在抽象类中。

    • 格式:修饰符 abstract 返回值类型 函数名(参数列表);
  3. 抽象类不能被实例化,也就是说不能用 new 创建对象,抽象类是从具体事物抽取出来的,抽象类本身是不具体的,没有对应的实例。

    • 例如:犬科是一个抽象的概念,真正存在的实例是狗和狼。
  4. 抽象类通过其子类进行实例化,子类必须重写(覆盖)抽象类中所有的抽象方法,子类才能实例化,否则该子类也会是抽象类。

     注:抽象类中可以存在非抽象方法。
    • 例如:

      Java 继承、抽象、接口

3. 抽象类与一般类

  • 区别:

    1. 抽象类不可以实例化。
    2. 抽象类不能创建对象,但是也有构造函数,提供给子类实例化调用。
    3. 抽象类比一般类多了抽象方法,抽象类中可以定义抽象方法,也可以定义非抽象方法。
  • 注:

    1. 抽象类中可以不定义抽象方法,使抽象类不被实例化,常用于模块设计。
    2. 被 abstract 修饰的函数不能同时被 private、static、final 修饰。
      • private:抽象类中的抽象方法需要被子类重写,而 private 修饰的方法是私有的,不被子类所知,无法重写。
      • static:static 修饰的方法可以直接使用类名调用,不需要使用对象调用,如果 static 使用在抽象方法上就没有运行的意义了。
      • final:final 修饰的类不能有子类,而 abstract 修饰的类一定是一个父类。
  • 例如:

    Java 继承、抽象、接口

三、接口

1. 概述

  • 当抽象类中所有的方法都是抽象方法时,该类可以通过接口的形式表示,使用 interface 来表示,子类中使用 implements 来实现,接口可以认为是特殊的抽象类。
  • 格式:
    • interface 接口名{}
    • 子类名 implements 接口名 {}
  • 特点:
    1. 接口中常见定义:常量、抽象方法。
    2. 接口中成员都是使用 public 修饰的。
    3. 接口中成员都有固定的修饰符:
      • 常量:public static final
      • 方法:public abstract
      • 注:接口中的常量可以不写 public static final,方法可以不写 public abstract,编译时会自动添加这些修饰符,这是 Java 中接口固定的修饰符,为了方便阅读,一般都会写上。

2. 特点

  1. 接口是程序功能的扩展。

  2. 接口是对外暴露的规则。

  3. 接口的出现降低了耦合性。

  4. 接口可以用来多实现,对于 Java 不支持多继承的缺陷而做的转换,Java 支持多实现。

  5. 类与接口之间是实现关系,类只能继承一个类,但同时可以实现多个接口。

  6. 接口与接口之间可以有继承关系,而且接口与接口之间支持多继承。

     注:
    1. 接口不可以创建对象,因为接口有抽象方法需要子类实现(implements),子类需要全部重写接口中的抽象方法后,子类才能实例化,否则该子类也会是抽象类。
    2. 实现多个接口时,接口中不允许有返回类型不同的同名抽象函数,如果有这样的情况时,子类实现将无法重写接口的抽象方法。

3. 接口与抽象类

  • 相同点:都是不断向上抽取出来的抽象概念。

  • 区别:

      • 接口是实现,是 "like a" 关系;
      • 抽象类是继承,是 "is a" 关系。
      • 接口中的常量和方法都是 public 修饰的权限;
      • 抽象类中可以有私有变量或方法。
      • 接口体现的是实现关系,可以多实现,接口与接口之间可以有继承关系;
      • 抽象类体现的是继承关系,只能单继承。
      • 接口中所有方法都是抽象方法,接口中的成员都是有固定的修饰符;
      • 抽象类中可以定义非抽象方法,提供给子类直接使用。
  • 例如:

    Java 继承、抽象、接口

    Java 继承、抽象、接口