Java 继承、抽象、接口

一、继承

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. 创建子类对象可以使用更多的功能，包括基本的父类共性功能，也包括子类的特有功能。
     
     • 总结：查阅父类功能，创建子类对象使用功能。

• 例如：

  
  

• 子父类出现后，类成员（变量、函数、构造函数）的特点：

  • 变量
    
    • 如果子类中出现非私有的同名成员变量时，子类要访问本类中的变量，用 this；子类要访问父类父类中的同名变量，用 super。
    • this 和 super 的使用几乎一致，并且两者都存于方法区中。
      
      • this 表示本类对象的引用
      • super 表示父类对象的引用

  • 函数 —— 重写（覆盖）

    • 当子类出现和父类一模一样的函数时，子类对象调用该函数，会运行子类的函数内容，相当于父类的函数被覆盖了，这就是函数的一个特性：重写（覆盖）。
    • 当子类继承父类，并且沿袭了父类的功能时，子类虽具备父类的该功能，但是子类中功能的内容却和父类不一致，这时，无需重新定义新功能，而是使用重写（覆盖）这一特性，保留父类的功能，并重写子类的功能内容，子类中同时想具有父类函数中的内容时，可以使用 super.() 方法。

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

      
      

    • 注：

      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. 抽象类通过其子类进行实例化，子类必须重写（覆盖）抽象类中所有的抽象方法，子类才能实例化，否则该子类也会是抽象类。

   注：抽象类中可以存在非抽象方法。
   

   • 例如：

     

3. 抽象类与一般类

• 区别：
  
  1. 抽象类不可以实例化。
  2. 抽象类不能创建对象，但是也有构造函数，提供给子类实例化调用。
  3. 抽象类比一般类多了抽象方法，抽象类中可以定义抽象方法，也可以定义非抽象方法。
• 注：
  
  1. 抽象类中可以不定义抽象方法，使抽象类不被实例化，常用于模块设计。
  2. 被 abstract 修饰的函数不能同时被 private、static、final 修饰。
     
     • private：抽象类中的抽象方法需要被子类重写，而 private 修饰的方法是私有的，不被子类所知，无法重写。
     • static：static 修饰的方法可以直接使用类名调用，不需要使用对象调用，如果 static 使用在抽象方法上就没有运行的意义了。
     • final：final 修饰的类不能有子类，而 abstract 修饰的类一定是一个父类。

• 例如：

  

三、接口

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. 接口与抽象类

• 相同点：都是不断向上抽取出来的抽象概念。
• 区别：
  
  1. 
     
     • 接口是实现，是 “like a” 关系；
     • 抽象类是继承，是 “is a” 关系。
  2. 
     
     • 接口中的常量和方法都是 public 修饰的权限；
     • 抽象类中可以有私有变量或方法。
  3. 
     
     • 接口体现的是实现关系，可以多实现，接口与接口之间可以有继承关系；
     • 抽象类体现的是继承关系，只能单继承。
  4. 
     
     • 接口中所有方法都是抽象方法，接口中的成员都是有固定的修饰符；
     • 抽象类中可以定义非抽象方法，提供给子类直接使用。

• 例如：